Golang——6、指针和结构体

1、指针

关于指针：通过前面的教程我们知道变量是用来存储数据的，变量的本质是给存储数据的内存地址起了一个好记的别名。比如我们定义了一个变量 a := 10，这个时候可以直接通过 a 这个变量来读取内存中保存的10这个值。在计算机底层a这个变量其实对应了一个内存地址。指针也是一个变量，但它是一种特殊的变量，它存储的数据不是一个普通的值，而是另一个变量的内存地址。

不过我们写的代码中的所有地址，包括指针等，全都是虚拟地址，有兴趣可以去看看Linux栏目下的博客，具体讲述了进程虚拟内存、页表、物理内存之间的关系。

1.1、指针地址和指针类型

**每个变量在运行时都拥有一个地址，这个地址代表变量在内存中的位置。Go语言中使用&字符放在变量前面对变量进行取地址操作。Go语言中的值类型（int、float、bool、string、array、struct） 都有对应的指针类型，如： *int、 int64、 string 等。

package mainimport "fmt"func main() {var a = 10var p = &afmt.Printf("a的值: %v, a的类型: %T, a的地址: %p\n", a, a, &a)fmt.Printf("p的值: %v, p的类型: %T, p的地址: %p\n", p, p, &p)
}

---

1.2、指针取值

在对普通变量使用&操作符取地址后会获得这个变量的指针，然后可以对指针使用*操作，也就是指针取值，代码如下：

a := 10
p := &a
fmt.Println(a, *p)
*p = 20
fmt.Println(a, *p)

总结：取地址操作符&和取值操作符*是一对互补操作符，&取出地址，*根据地址取出地址指向的值。

例如实现一个交换函数：

package mainimport "fmt"func swap(x, y *int) {tmp := *x*x = *y*y = tmp
}func main() {a := 10b := 20fmt.Println(a, b)swap(&a, &b)fmt.Println(a, b)}

如果使用传值，那么修改的swap函数栈帧上开辟的变量，无法实现交换两个数。

---

1.3、new和make

var userinfo map[string]string
userinfo["username"] = "张三"
fmt.Println(userinfo)

执行上面的代码会引发panic，为什么呢？在Go语言中对于引用类型的变量，我们在使用的时候不仅要声明它， 还要为它分配内存空间，否则我们的值就没办法存储。而对于值类型的声明不需要分配内存空间，是因为它们在声明的时候已经默认分配好了内存空间。要分配内存，就引出来今天的new和make。Go语言中new和make是内建的两个函数，主要用来分配内存。

1、new函数分配内存。

var p1 = new(int)
*p1 = 10
fmt.Printf("p1的值: %v, p1的类型: %T, p1的地址: %p, p1指向的值: %v\n", p1, p1, &p1, *p1)var p2 *int
p2 = new(int)
*p2 = 20
fmt.Printf("p2的值: %v, p2的类型: %T, p2的地址: %p, p2指向的值: %v\n", p2, p2, &p2, *p2)

2、make函数分配内存
make也是用于内存分配的，区别于 new，它只用于slice、 map以及channel的内存创建，而且它返回的类型就是这三个类型本身，而不是他们的指针类型，因为这三种类型就是引用类型， 所以就没有必要返回他们的指针了。 make函数的函数签名如下：

func make(t Type, size ...IntegerType) Type

make函数是无可替代的，我们在使用slice、map以及channel的时候，都需要使用make进行初始化，然后才可以对它们进行操作。这个我们在前面的教程中都有说明，关于 channel我们会在后续的章节详细说明。

3、new与make的区别
1、二者都是用来做内存分配的。
2、make只用于slice、map以及channel的初始化，返回的还是这三个引用类型本身。
3、而 new用于类型的内存分配，并且内存对应的值为类型零值，返回的是指向类型的指针。

---

2、结构体

Golang中没有类的概念，Golang中的结构体和其他语言中的类有点相似。和其他面向对象语言中的类相比，Golang中的结构体具有更高的扩展性和灵活性。
Golang中的基础数据类型可以表示一些事物的基本属性，但是当我们想表达一个事物的全部或部分属性时，这时候再用单一的基本数据类型就无法满足需求了，Golang 提供了一种自定义数据类型，可以封装多个基本数据类型，这种数据类型叫结构体，英文名称 struct。也就是我们可以通过struct来定义自己的类型了。

2.1、type关键字的使用

1、自定义类型
在Go语言中有一些基本的数据类型，如 string、整型、浮点型、布尔等数据类型，Go语言中可以使用 type 关键字来定义自定义类型。

package mainimport "fmt"type myInt int
type clacType func(int, int) intfunc main() {var a myInta = 10var b int = 20fmt.Printf("值: %d, 类型: %T\n", a, a)fmt.Printf("值: %d, 类型: %T\n", b, b)
}

2、类型别名
类型别名规定：TypeAlias只是Type的别名，本质上TypeAlias与Type是同一个类型。

package mainimport "fmt"type myInt int
type clacType func(int, int) inttype myFloat = float64func main() {var a myInta = 10var b int = 20fmt.Printf("值: %d, 类型: %T\n", a, a)fmt.Printf("值: %d, 类型: %T\n", b, b)var f myFloatf = 3.1415926fmt.Printf("值: %v, 类型: %T\n", f, f)
}

这里类似C/C++中的typedef和using对类型起别名。

---

2.2、结构体的定义和初始化

使用type和struct关键字来定义结构体，具体代码格式如下：

其中：
• 类型名：表示自定义结构体的名称，在同一个包内不能重复。
• 字段名：表示结构体字段名。结构体中的字段名必须唯一。
• 字段类型：表示结构体字段的具体类型。

比如定义一个Person结构体，里面保存了人的各种信息：

type Person struct {Name stringAge  intSex  string
}

注意：结构体首字母可以大写也可以小写，大写表示这个结构体是公有的，在其他的包里面可以使用。小写表示这个结构体是私有的，只有这个包里面才能使用。

---

以下是结构体初始化的几种方式：
方式一：

package mainimport "fmt"type Person struct {Name stringAge  intSex  string
}func main() {var p1 Personp1.Name = "张三"p1.Age = 18p1.Sex = "男"fmt.Printf("值: %v, 类型: %T\n", p1, p1)fmt.Printf("值: %#v, 类型: %T\n", p1, p1)
}

可以看到使用%#v打印结构体类型数据，可以打印出更详细的信息。

---

方式二：

var p2 = new(Person)
p2.Name = "李四"
p2.Age = 19
p2.Sex = "女"
fmt.Printf("值: %#v, 类型: %T\n", p2, p2)

注意：在Golang中支持对结构体指针直接使用.来访问结构体的成员。p2.name = "李四"其实在底层是(*p2).name = “李四”。

---

方式三：

var p3 = &Person{}
p3.Name = "王五"
p3.Age = 20
p3.Sex = "男"
fmt.Printf("值: %#v, 类型: %T\n", p3, p3)

可以看出来，这时候p3也是一个结构体指针类型。

---

方式四：

var p4 = Person{Name: "赵六",Age:  21,Sex:  "女",
}
fmt.Printf("值: %#v, 类型: %T\n", p4, p4)

---

方式五：

var p5 = &Person{Name: "田七",Age:  22,Sex:  "女",
}
fmt.Printf("值: %#v, 类型: %T\n", p5, p5)

---

方式六：

var p6 = &Person{Name: "周八",
}
fmt.Printf("值: %#v, 类型: %T\n", p6, p6)

可以在{}中只初始化一部分，可以看到剩下的变量都被初始化成默认值。

---

方式七：

var p7 = &Person{"吴九",23,"男",
}
fmt.Printf("值: %#v, 类型: %T\n", p7, p7)

这一种方式可以省略前面变量名，但是要跟声明顺序一致。

---

2.3、结构体方法和接收者

首先我们来看看结构体是值类型还是引用类型：

package mainimport "fmt"type Person struct {Name stringAge  intSex  string
}func main() {var p1 = Person{Name: "张三",Age:  18,Sex:  "男",}p2 := p1p2.Name = "李四"fmt.Println(p1)fmt.Println(p2)
}

从输出结果我们可以知道，结构体是值类型，这里将p1赋值给p2是拷贝。

在go语言中，没有类的概念但是可以给类型（结构体， 自定义类型） 定义方法。所谓方法就是定义了接收者的函数。接收者的概念就类似于其他语言中的this或者self。

其中
• 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为p，Connector类型的接收者变量应该命名为c等。
• 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
• 方法名、参数列表、返回参数：具体格式与函数定义相同。

下面给Person结构体实现一个PrintInfo打印信息：

package mainimport "fmt"type Person struct {Name stringAge  intSex  string
}func (p Person) PrintInfo() {fmt.Printf("姓名: %v, 年龄: %v\n", p.Name, p.Age)
}func main() {var p1 = Person{Name: "张三",Age:  18,Sex:  "男",}var p2 = Person{"李四",19,"女",}p1.PrintInfo()p2.PrintInfo()
}

我们也可以实现一个函数修改结构体内变量的值，但是这时候接收者类型就不能是结构体类型了，因为结构体类型是值类型，这样调用成员函数本质上是值拷贝，这时候就需要指针出场了。

package mainimport "fmt"type Person struct {Name stringAge  intSex  string
}func (p Person) PrintInfo() {fmt.Printf("姓名: %v, 年龄: %v\n", p.Name, p.Age)
}func (p *Person) SetInfo(name string, age int) {p.Name = namep.Age = age
}func main() {var p1 = Person{Name: "张三",Age:  18,Sex:  "男",}p1.PrintInfo()p1.SetInfo("李四", 20)p1.PrintInfo()
}

---

2.4、给任意类型添加方法

在Go语言中，接收者的类型可以是任何类型，不仅仅是结构体，任何类型都可以拥有方法。举个例子，我们基于内置的int类型使用type关键字可以定义新的自定义类型，然后为我们的自定义类型添加方法。

package mainimport "fmt"type myInt intfunc (m myInt) PrintInfo() {fmt.Println("我是自定义类型里面的自定义方法!")
}func main() {var a myInt = 10a.PrintInfo()
}

注意事项：非本地类型不能定义方法，也就是说我们不能给别的包的类型定义方法。

---

2.5、结构体的匿名字段

结构体允许其成员字段在声明时没有字段名而只有类型，这种没有名字的字段就称为匿名字段。

package mainimport "fmt"type Person struct {stringint
}func main() {p := Person{"张三",19,}fmt.Println(p)
}

注意事项：结构体匿名字段不能出现重复的类型，例如上面的Person已经出现过string了，后面就不能再写string了。

---

2.6、嵌套结构体

结构体的字段类型可以是：基本数据类型、也可以是切片、Map以及结构体。
如果结构体的字段类型是：指针，slice，和map的零值都是nil，即还没有分配空间。如果需要使用这样的字段，需要先make，才能使用。

下面先演示结构体字段有切片、map的例子：

// package main// import "fmt"// type Person struct {
// 	string
// 	int
// }// func main() {
// 	p := Person{
// 		"张三",
// 		19,
// 	}
// 	fmt.Println(p)
// }package mainimport "fmt"type Person struct {Name  stringAge   intHobby []stringmap1  map[string]string
}func main() {var p Personp.Name = "张三"p.Age = 18p.Hobby = make([]string, 3, 6)p.Hobby[0] = "跑步"p.Hobby[1] = "徒步"p.Hobby[2] = "写代码"p.map1 = make(map[string]string)p.map1["address"] = "厦门"p.map1["phone"] = "13912344321"fmt.Printf("%#v\n", p)
}

下面演示嵌套结构体：

package mainimport "fmt"type User struct {Username stringPassword stringAddress  Address
}type Address struct {Name  stringPhone stringCity  string
}func main() {var u Useru.Username = "zhangsan"u.Password = "123456"u.Address.Name = "张三"u.Address.Phone = "13912344321"u.Address.City = "厦门"fmt.Printf("%#v\n", u)
}

---

2.7、嵌套匿名结构体

package mainimport "fmt"type User struct {Username stringPassword stringAddress
}type Address struct {Name  stringPhone stringCity  string
}func main() {var u Useru.Username = "zhangsan"u.Password = "123456"u.Address.Name = "张三"u.Address.Phone = "13912344321"u.Address.City = "厦门"fmt.Printf("%#v\n", u)u.Name = "李四"fmt.Printf("%#v\n", u)
}

访问嵌套匿名结构体成员的方式可以直接.Address.Name访问。还可以直接.Name访问，此时会现在User中查找是否有该成员变量，如果没有就到匿名结构体中去查找。

---

那如果嵌套的结构体跟本结构体中有同名的变量怎么办呢？如下：

package mainimport "fmt"type User struct {Username stringPassword stringAddTime  stringAddress
}type Address struct {Name    stringPhone   stringCity    stringAddTime string
}func main() {var u Useru.Username = "zhangsan"u.Password = "123456"u.Address.Name = "张三"u.Address.Phone = "13912344321"u.City = "厦门"u.AddTime = "2025-06-02"fmt.Printf("%#v\n", u)u.Address.AddTime = "2025-07-02"fmt.Printf("%#v\n", u)
}

可以看到跟我们说的一样，首先在User结构体中找AddTime，没有才会去嵌套的结构体中找。

---

再看另一种情况，User中并没有AddTime，而是在Address和Email结构体中都有AddTime。

package mainimport "fmt"type User struct {Username stringPassword stringAddressEmail
}type Address struct {Name    stringPhone   stringCity    stringAddTime string
}type Email struct {Account stringAddTime string
}func main() {var u Useru.Username = "zhangsan"u.Password = "123456"u.Address.Name = "张三"u.Address.Phone = "13912344321"u.Address.City = "厦门"u.Address.AddTime = "2025-06-02"u.Email.AddTime = "2025-07-02"fmt.Printf("%#v\n", u)
}

在这种情况下，不能直接u.AddTime访问，因为存在冲突，必须在前面指明类。

---

2.8、结构体的继承

Go语言中使用结构体也可以实现其他编程语言中的继承。

package mainimport "fmt"// 父结构体
type Animal struct {Name string
}func (a Animal) run() {fmt.Printf("%v在运动!\n", a.Name)
}type Dog struct {Age    intAnimal // 嵌套匿名结构体--继承
}func (d Dog) wang() {fmt.Printf("%v在汪汪!\n", d.Name)
}func main() {var d = Dog{Age: 3,Animal: Animal{Name: "阿奇",},}d.run()d.wang()
}

当然了，不仅仅可以是结构体类型，也可以嵌套结构体指针类型：

package mainimport "fmt"// 父结构体
type Animal struct {Name string
}func (a Animal) run() {fmt.Printf("%v在运动!\n", a.Name)
}type Dog struct {Age     int*Animal // 嵌套匿名结构体--继承
}func (d Dog) wang() {fmt.Printf("%v在汪汪!\n", d.Name)
}func main() {var d = Dog{Age: 3,Animal: &Animal{Name: "阿奇",},}d.run()d.wang()
}

---

3、结构体与Json序列化、反序列化

Golang JSON序列化是指把结构体数据转化成JSON格式的字符串，Golang JSON的反序列化是指把JSON数据转化成Golang中的结构体对象。
Golang中的序列化和反序列化主要通过"encoding/json"包中的json.Marshal()和json.Unmarshal()方法实现。

3.1、结构体对象转换成Json字符串

package mainimport ("encoding/json""fmt"
)type Student struct {Id     intGender stringName   stringSno    string
}func main() {var s1 = Student{Id:     1,Gender: "男",Name:   "张三",Sno:    "s0001",}fmt.Printf("%#v\n", s1)jsonByte, _ := json.Marshal(s1)jsonStr := string(jsonByte)fmt.Println(jsonStr)
}

json.Marshal的返回值为[]byte切片和error，所以需要先切片接收然后再强转成字符串。
需要注意，成员变量的名字必须首字母大写，这样表示公有属性，如果首字母是小写则表示私有属性。私有属性是无法被json包访问的！

---

3.2、Json字符串转换成结构体对象

package mainimport ("encoding/json""fmt"
)type Student struct {Id     intGender stringName   stringSno    string
}func main() {jsonStr := `{"Id":1,"Gender":"男","Name":"张三","Sno":"s0001"}`var s Studenterr := json.Unmarshal([]byte(jsonStr), &s)if err != nil {fmt.Println("err:", err)}fmt.Printf("%#v\n", s)
}

由于要将json字符串反序列化并赋值给s中的成员变量，所以需要传s的地址。

---

3.3、结构体标签Tag

Tag是结构体的元信息，可以在运行的时候通过反射的机制读取出来。Tag 在结构体字段的后方定义， 由一对反引号包裹起来， 具体的格式如：key1:"value1" key2:"value2"
结构体tag由一个或多个键值对组成。键与值使用冒号分隔，值用双引号括起来。同一个结构体字段可以设置多个键值对tag，不同的键值对之间使用空格分隔。
注意事项：为结构体编写Tag时，必须严格遵守键值对的规则。结构体标签的解析代码的容错能力很差， 一旦格式写错，编译和运行时都不会提示任何错误，通过反射也无法正确取值。例如不要在key和value之间添加空格。

前面说过，我们结构体成员变量名字必须为首字母大写开头，表示公有属性，这样才能被json包访问。这样默认序列化出来的key就是首字母大写的，那如果我想让序列化的首字母为小写的呢？这时候就需要结构体标签出场了。

package mainimport ("encoding/json""fmt"
)type Student struct {Id     int    `json:"id"`Gender string `json:"gender"`Name   string `json:"name"`Sno    string `json:"sno"`
}func main() {var s1 = Student{Id:     1,Gender: "男",Name:   "张三",Sno:    "s0001",}fmt.Printf("%#v\n", s1)jsonByte, _ := json.Marshal(s1)jsonStr := string(jsonByte)fmt.Println(jsonStr)
}

---

3.4、嵌套结构体json序列化和反序列化

先来看嵌套结构体的序列化：

package mainimport ("encoding/json""fmt"
)type Student struct {Id     intGender stringName   string
}type Class struct {Title    stringStudents []Student
}func main() {c := Class{Title:    "001班",Students: make([]Student, 0),}for i := 1; i <= 5; i++ {s := Student{Id:     i,Gender: "男",Name:   fmt.Sprintf("stu_%v", i),}c.Students = append(c.Students, s)}fmt.Printf("%#v\n", c)jsonByte, _ := json.Marshal(c)jsonStr := string(jsonByte)fmt.Println(jsonStr)
}

再来看反序列化：

package mainimport ("encoding/json""fmt"
)type Student struct {Id     intGender stringName   string
}type Class struct {Title    stringStudents []Student
}func main() {var c = &Class{}jsonStr := `{"Title":"001班","Students":[{"Id":1,"Gender":"男","Name":"stu_1"},{"Id":2,"Gender":"男","Name":"stu_2"},{"Id":3,"Gender":"男","Name":"stu_3"},{"Id":4,"Gender":"男","Name":"stu_4"},{"Id":5,"Gender":"男","Name":"stu_5"}]}`err := json.Unmarshal([]byte(jsonStr), c)if err != nil {fmt.Println("err:", err)}fmt.Printf("%#v\n", c)fmt.Println(c.Title)
}