struct 结构体类型

Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。

结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。

结构体表示一项记录，比如所有的学生可以看作是一个结构体，每个学生包含，姓名，性别，年龄，学号…的属性。

1. 定义结构体

结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。

type 结构体名 struct {// 成员变量成员变量名 数据类型
}

2. 访问结构体成员

在Go中访问结构体成员，也是通过 ”结构体.成员变量名“ 的方式来访问。

结构体.成员名

例如创建一个学生结构体，然后对其进行初始化赋值，接着打印出对应结构体的详细信息

package mainimport "fmt"// 结构体的使用// 1.struct 指明结构体类型 ，type 指明 数据类型
type student struct {name stringsex  stringage  intsid  int
}func main() {// 结构体对象创建格式var st1 = student{}st2 := student{}printSt(st1)printSt(st2)// 赋值初始化st1.sex = "男"st1.name = "黄飞鸿"st1.age = 18st1.sid = 2020040413// 赋值初始化st2.sex = "男"st2.name = "叶问"st2.age = 18st2.sid = 2020040414printSt(st1)printSt(st2)// 声明并且同时赋值初始化var st4 = student{name: "李四", age: 22, sex: "男", sid: 2020040415}st5 := student{name: "张三", age: 22, sex: "男", sid: 2020040416}printSt(st4)printSt(st5)
}// 打印结构体成员的函数
func printSt(st student) {fmt.Printf("学生信息:姓名%v\t,性别:%v\t,年龄:%d\t,学号:%d\t\n",st.name, st.sex, st.age, st.sid)
}

运行输出如下：

学生信息:姓名   ,性别:  ,年龄:0 ,学号:0
学生信息:姓名   ,性别:  ,年龄:0 ,学号:0
学生信息:姓名黄飞鸿     ,性别:男        ,年龄:18        ,学号:2020040413
学生信息:姓名叶问       ,性别:男        ,年龄:18        ,学号:2020040414
学生信息:姓名李四       ,性别:男        ,年龄:22        ,学号:2020040415
学生信息:姓名张三       ,性别:男        ,年龄:22        ,学号:2020040416

这里只是简单的单个结构体的使用，一般我们都使用结构体嵌套的方式，以更好的对实体进行描述。

3. 结构体的使用及匿名字段

Go支持只提供类型，而不写字段名的方式，也就是匿名字段，也称为嵌入字段（在上面的方式中，结构体成员变量名与数据类型一一对应）。

比如，创建一个People的结构体，然后People是一个很大的范围，学生是其中的一个结构体。

package mainimport "fmt"type People struct{name stringsex stringage int
}type Student struct{People // 匿名字段的使用，只写数据类型，不写字段名sid int
}func main() {var st1 = Student{People{name: "叶问", sex: "男", age: 23}, 10001}printSt(st1)
}func printSt(st Student) {fmt.Printf("学生信息:姓名%v\t,性别:%v\t,年龄:%d\t,学号:%d\t\n",st.name, st.sex, st.age, st.sid)
}

当然，在结构体中其他的普通字段也可以使用匿名字段

在复合结构体中，若存在相同名称的字段，优先访问外层结构体的重名字段,若是想访问内层的重名字段，则需要以内层结构体.成员变量的方式来访问。

type people struct {name string sex string
}
type student struct {people name stringsid int
}

访问外部的重名成员字段

结构体.成员变量字段

访问内部的重名成员字段

结构体.内嵌结构体.成员变量字段

例如下面的例子：

// 创建一个struct结构体
var st1 = student{people{"张三","男"},"李四",10001}
// 访问外部重名成员字段
print(st1.name) // 李四
print(st1.people.name) //张三

指针

Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。

一个指针变量指向了一个值的内存地址。类似于变量和常量，在使用指针前需要声明指针。

1. 指针变量的声明及使用

指针变量声明的格式如下：

var 指针名 *数据类型

指针使用流程：

• 定义指针变量。
• 为指针变量赋值。
• 访问指针变量中指向地址的值。

在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。

使用如下：

package mainfunc main() {var a = 10println(a) // 10var p *int// 将指针p指向变量ap = &a// 对指针p指向的值进行更改，a的值也会发生更改*p = 11println(a) // 11println(*p) // 11
}

2. 指针数组的定义及使用

指针数组的声明定义格式:

var 指针数组名 [size] *数据类型

与指针变量声明格式基本一致，只是指针数组多了数组长度。

// 定义一个整型数组，然后使用指针数组分别指向里面的每个数组元素
var numbers = []int {11,22,33}
var ptrs [3]*int
for i:= range numbers{ptrs[i] = &numbers[i]
}
for j:= range ptrs{println(*ptrs[j])
}
// 11
// 22 
// 33

3. 函数传参修改值

还是指针的特性，直接指向值。函数传参修改值，其实就是在调用函数时，传入地址即可。

比如，一个交换两个变量的值

package mainimport "fmt"func main() {var a int = 10var b int = 20fmt.Printf("a:%d\t,b:%d\t\n", a, b)swap(&a, &b)fmt.Printf("a:%d\t,b:%d\t\n", a, b)
}func swap(ptr1 *int, ptr2 *int) {var temp inttemp = *ptr1*ptr1 = *ptr2*ptr2 = temp
}
// a:10    ,b:20
// a:20    ,b:10

---