struct 结构体类型
Go 语言中数组可以存储同一类型的数据，但在结构体中我们可以为不同项定义不同的数据类型。
结构体是由一系列具有相同类型或不同类型的数据构成的数据集合。
结构体表示一项记录，比如所有的学生可以看作是一个结构体，每个学生包含，姓名，性别，年龄，学号…的属性。
1. 定义结构体
结构体定义需要使用 type 和 struct 语句。struct 语句定义一个新的数据类型，结构体中有一个或多个成员。type 语句设定了结构体的名称。
type 结构体名 struct {
// 成员变量
成员变量名 数据类型
}
2. 访问结构体成员
在Go中访问结构体成员，也是通过 ”结构体.成员变量名“ 的方式来访问。
结构体.成员名
例如创建一个学生结构体，然后对其进行初始化赋值，接着打印出对应结构体的详细信息
package main
import "fmt"
// 结构体的使用
// 1.struct 指明结构体类型 ，type 指明 数据类型
type student struct {
name string
sex string
age int
sid int
}
func main() {
// 结构体对象创建格式
var st1 = student{
}
st2 := student{
}
printSt(st1)
printSt(st2)
// 赋值初始化
st1.sex = "男"
st1.name = "黄飞鸿"
st1.age = 18
st1.sid = 2020040413
// 赋值初始化
st2.sex = "男"
st2.name = "叶问"
st2.age = 18
st2.sid = 2020040414
printSt(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 main
import "fmt"
type People struct{
name string
sex string
age 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 string
sid int
}
访问外部的重名成员字段
结构体.成员变量字段
访问内部的重名成员字段
结构体.内嵌结构体.成员变量字段
例如下面的例子：
// 创建一个struct结构体
var st1 = student{
people{
"张三","男"},"李四",10001}
// 访问外部重名成员字段
print(st1.name) // 李四
print(st1.people.name) //张三
指针
Go 语言的取地址符是 &，放到一个变量前使用就会返回相应变量的内存地址。
一个指针变量指向了一个值的内存地址。类似于变量和常量，在使用指针前需要声明指针。
1. 指针变量的声明及使用
指针变量声明的格式如下：
var 指针名 *数据类型
指针使用流程：
- 定义指针变量。
- 为指针变量赋值。
- 访问指针变量中指向地址的值。
在指针类型前面加上 * 号（前缀）来获取指针所指向的内容。
使用如下：
package main
func main() {
var a = 10
println(a) // 10
var p *int
// 将指针p指向变量a
p = &a
// 对指针p指向的值进行更改，a的值也会发生更改
*p = 11
println(a) // 11
println(*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 main
import "fmt"
func main() {
var a int = 10
var b int = 20
fmt.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 int
temp = *ptr1
*ptr1 = *ptr2
*ptr2 = temp
}
// a:10 ,b:20
// a:20 ,b:10
