Golang 结构体

在 Golang 中没有 class，使用 struct 实现 class 的思想

1. 结构体的定义和初始化

• 结构体定义: type 结构体名称 struct {}
• 结构体初始化

import "fmt"

// 定义一个学生信息的结构体
type Student struct {
    id      int
    name    string
    age     int
    sex     int
    score   float32
    address string
}

func main() {
    // 1. 初始化对象
    s1 := Student{1, "zs", 18, 0, 99.8, "bj"}
    fmt.Println(s1)

    // 2. 指定几个字段赋值(其他未指定的值则使用指定类型的默认值)
    s2 := Student{id: 2, name: "ls"}
    fmt.Println(s2)

    // 3. 先定义再初始化
    var s3 Student
    s3.id = 3
    s3.name = "ww"
    fmt.Println(s3)

    // 4. 结构体作为指针变量初始化
    var s4 *Student = &Student{4, "ll", 20, 1,68.9, "sh"}
    fmt.Println(s4)

    // s4.name也可以，go会自动转为(*s4).name
    fmt.Println((*s4).name)
    fmt.Println(s4.name)

    // 5. :=
    s5 := &Student{5, "lh", 20, 1,68.9, "sz"}
    fmt.Println(s5)
}

2. 结构体参数

结构体作为函数的参数传递(值和指针传递不一样)

package main

import "fmt"

// 定义一个学生信息的结构体
type Student struct {
    id      int
    name    string
    age     int
    sex     int
    score   float32
    address string
}

// 结构体值传递
func test001(stu Student) {
    stu.name = "hhhhhh"
    fmt.Println("值传递", stu)
}

// 结构体指针传递
func test002(stu *Student) {
    stu.name = "dddddd"
    fmt.Println("指针传递", stu)

}

func main() {
    // 1. 初始化对象
    stu := Student{1, "zs", 18, 0, 99.8, "bj"}
    fmt.Println("外部", stu)

    // 值传递(不会修改原来的结构体)
    test001(stu)
    fmt.Println("外部，值传递", stu)

    // 指针传递，会修改原来的结构体
    test002(&stu)
    fmt.Println("外部，指针传递", stu)
}

3. 结构体内存结构

一个结构体，会占用一段连续的内存空间

package main

import "fmt"

type st struct {
    a int32
    b int32
    c int32
    d int32
    e int32
}

func main() {
    var st01 st

    fmt.Printf("a->addr: %p\n", &st01.a)
    fmt.Printf("b->addr: %p\n", &st01.b)
    fmt.Printf("c->addr: %p\n", &st01.c)
    fmt.Printf("d->addr: %p\n", &st01.d)
    fmt.Printf("e->addr: %p\n", &st01.e)
}

// 输出结果
/* 同类型可以看出每个值之间的内存地址是连续的(相隔4个)
a->addr: 0xc0000a0000
b->addr: 0xc0000a0004
c->addr: 0xc0000a0008
d->addr: 0xc0000a000c
e->addr: 0xc0000a0010
 */

4. 构造函数

• go 语言中没有构造函数，但可以自己去实现
• 构造函数是一种特殊的函数，主要用来在创建对象时初始化对象，即为对象成员变量赋初始值

package main

import "fmt"

// 定义一个用户的结构体
type User struct {
    id   int
    name string
    age  int
}

// 模拟一个构造函数, 返回一个初始化后的指针对象
func NewUser(id int, name string, age int) *User {
    user := new(User)
    user.id = id
    user.name = name
    user.age = age
    return user
}

func main() {
    // 初始化一个user
    user001 := NewUser(1, "zs", 18)
    fmt.Println(user001)
}