结构体（struct）
文章发布较早，内容可能过时，阅读注意甄别。
# 1，概述。
有时我们需要将不同类型的数据组合成一个有机的整体，如：一个学生有学号、性能、性别、年龄、地址等属性。如果一个一个定义变量会比较繁琐，数据不便于管理。这时就可以引入结构体了。
结构体是一种聚合的数据类型，它是由一系列具有相同类型或者不同类型的数据构成的数据集合。每个数据成为结构体的成员。
# 2，结构体普通变量初始化。
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
//顺序初始化，每个成员都需要初始化，否则报错
var s1 Student = Student{1, "mike", 'm', 12, "beijing"}
fmt.Println("s1 = ", s1)
//指定成员初始化，没有初始化的默认为0
s2 := Student{name: "mike", age: 13}
fmt.Println("s2 = ", s2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
简单使用：
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
var s Student
//操作成员需要使用点(.)运算符
s.id = 1
s.name = "mike"
s.sex = 'm'
s.age = 12
s.addr = "hangzhou"
fmt.Println("s = ", s)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# 3，结构体指针变量初始化。
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
//顺序初始化，每个成员都需要初始化，否则报错
var s1 *Student = &Student{1, "mike", 'm', 12, "beijing"}
fmt.Println("s1 = ", s1)
//指定成员初始化，没有初始化的默认为0
s2 := &Student{name: "mike", addr: "hangzhou"}
fmt.Printf("s2 type is:%T\n", s2)
fmt.Println("s2 = ", s2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
简单使用：
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
//1，指针有合法指向后，再操作成员
//先定义一个普通结构体变量
var s Student
//再定义一个指针变量，保存s的地址
var p1 *Student
p1 = &s
//通过指针操作成员，p1.id和(*p1).id都可以
p1.id = 1
(*p1).name = "mike"
p1.sex = 'm'
p1.age = 12
p1.addr = "hangzhou"
fmt.Println("p1 = ", p1)
//2，通过new申请一个结构体
p2 := new(Student)
p2.id = 1
p2.name = "mike"
p2.sex = 'm'
p2.age = 12
p2.addr = "hangzhou"
fmt.Println("p2 = ", p2)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
# 4，结构体的比较和赋值。
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func main() {
s1 := Student{1, "mike", 'm', 12, "beijing"}
s2 := Student{1, "mike", 'm', 12, "beijing"}
s3 := Student{2, "mike", 'm', 12, "beijing"}
fmt.Println("s1 = s2", s1 == s2)
fmt.Println("s1 = s3", s1 == s3)
//同类型的2个结构体，可以相互赋值
var tmp Student
tmp = s3
fmt.Println("tmp = ", tmp)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
# 5，结构体做函数参数-值传递
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
//相当于拷贝一份到test函数中，那么对应的操作也就在test作用域当中生效
func test(s Student) {
s.id = 666
fmt.Println("test = ", s)
}
func main() {
s := Student{1, "mike", 'm', 12, "beijing"}
test(s) //值传递，形参无法改实参
fmt.Println("main = ", s)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
# 6，结构体做函数参数-地址传递。
package main
import "fmt"
type Student struct {
id int
name string
sex byte
age int
addr string
}
func test(p *Student) {
p.id = 666
}
func main() {
s := Student{1, "mike", 'm', 12, "beijing"}
test(&s) //地址传递，形参修改就是对实参修改
fmt.Println("main = ", s)
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
# 7，可见性。
在 Go 语言当中，所有想要全局调用的变量，函数，结构体类型，结构体成员，都必须在定义的时候，首字母大写，否则只能在当前作用域生效。
上次更新: 2024/11/19, 23:11:42
|