Golang——6、指针和结构体

指针和结构体

1、指针
- 1.1、指针地址和指针类型
- 1.2、指针取值
- 1.3、new和make
2、结构体
- 2.1、type关键字的使用
- 2.2、结构体的定义和初始化
- 2.3、结构体方法和接收者
- 2.4、给任意类型添加方法
- 2.5、结构体的匿名字段
- 2.6、嵌套结构体
- 2.7、嵌套匿名结构体
- 2.8、结构体的继承
3、结构体与Json序列化、反序列化
- 3.1、结构体对象转换成Json字符串
- 3.2、Json字符串转换成结构体对象
- 3.3、结构体标签Tag
- 3.4、嵌套结构体json序列化和反序列化

1、指针

关于指针：通过前面的教程我们知道变量是用来存储数据的，变量的本质是给存储数据的内存地址起了一个好记的别名。比如我们定义了一个变量 a := 10，这个时候可以直接通过 a 这个变量来读取内存中保存的10这个值。在计算机底层a这个变量其实对应了一个内存地址。指针也是一个变量，但它是一种特殊的变量，它存储的数据不是一个普通的值，而是另一个变量的内存地址。
在这里插入图片描述
不过我们写的代码中的所有地址，包括指针等，全都是虚拟地址，有兴趣可以去看看Linux栏目下的博客，具体讲述了进程虚拟内存、页表、物理内存之间的关系。

1.1、指针地址和指针类型

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

package main

import "fmt"

func main() {
	var a = 10
	var p = &a
	fmt.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 main

import "fmt"

func swap(x, y *int) {
	tmp := *x
	*x = *y
	*y = tmp
}

func main() {
	a := 10
	b := 20
	fmt.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 main

import "fmt"

type myInt int
type clacType func(int, int) int

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

在这里插入图片描述

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

package main

import "fmt"

type myInt int
type clacType func(int, int) int

type myFloat = float64

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

在这里插入图片描述
这里类似C/C++中的typedef和using对类型起别名。

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

使用type和struct关键字来定义结构体，具体代码格式如下：
在这里插入图片描述
其中：
• 类型名：表示自定义结构体的名称，在同一个包内不能重复。
• 字段名：表示结构体字段名。结构体中的字段名必须唯一。
• 字段类型：表示结构体字段的具体类型。

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

type Person struct {
	Name string
	Age  int
	Sex  string
}

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

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

package main

import "fmt"

type Person struct {
	Name string
	Age  int
	Sex  string
}

func main() {
	var p1 Person
	p1.Name = "张三"
	p1.Age = 18
	p1.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 main

import "fmt"

type Person struct {
	Name string
	Age  int
	Sex  string
}

func main() {
	var p1 = Person{
		Name: "张三",
		Age:  18,
		Sex:  "男",
	}
	p2 := p1
	p2.Name = "李四"
	fmt.Println(p1)
	fmt.Println(p2)
}

在这里插入图片描述

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

在go语言中，没有类的概念但是可以给类型（结构体，自定义类型）定义方法。所谓方法就是定义了接收者的函数。接收者的概念就类似于其他语言中的this或者self。
在这里插入图片描述
其中
• 接收者变量：接收者中的参数变量名在命名时，官方建议使用接收者类型名的第一个小写字母，而不是self、this之类的命名。例如，Person类型的接收者变量应该命名为p，Connector类型的接收者变量应该命名为c等。
• 接收者类型：接收者类型和参数类似，可以是指针类型和非指针类型。
• 方法名、参数列表、返回参数：具体格式与函数定义相同。

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

package main

import "fmt"

type Person struct {
	Name string
	Age  int
	Sex  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 main

import "fmt"

type Person struct {
	Name string
	Age  int
	Sex  string
}

func (p Person) PrintInfo() {
	fmt.Printf("姓名: %v, 年龄: %v\n", p.Name, p.Age)
}

func (p *Person) SetInfo(name string, age int) {
	p.Name = name
	p.Age = age
}

func main() {
	var p1 = Person{
		Name: "张三",
		Age:  18,
		Sex:  "男",
	}
	p1.PrintInfo()
	p1.SetInfo("李四", 20)
	p1.PrintInfo()
}

在这里插入图片描述

2.4、给任意类型添加方法

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

package main

import "fmt"

type myInt int

func (m myInt) PrintInfo() {
	fmt.Println("我是自定义类型里面的自定义方法!")
}

func main() {
	var a myInt = 10
	a.PrintInfo()
}

在这里插入图片描述

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

2.5、结构体的匿名字段

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

package main

import "fmt"

type Person struct {
	string
	int
}

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 main

import "fmt"

type Person struct {
	Name  string
	Age   int
	Hobby []string
	map1  map[string]string
}

func main() {
	var p Person
	p.Name = "张三"
	p.Age = 18
	p.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 main

import "fmt"

type User struct {
	Username string
	Password string
	Address  Address
}

type Address struct {
	Name  string
	Phone string
	City  string
}

func main() {
	var u User
	u.Username = "zhangsan"
	u.Password = "123456"
	u.Address.Name = "张三"
	u.Address.Phone = "13912344321"
	u.Address.City = "厦门"
	fmt.Printf("%#v\n", u)
}

在这里插入图片描述

2.7、嵌套匿名结构体

package main

import "fmt"

type User struct {
	Username string
	Password string
	Address
}

type Address struct {
	Name  string
	Phone string
	City  string
}

func main() {
	var u User
	u.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 main

import "fmt"

type User struct {
	Username string
	Password string
	AddTime  string
	Address
}

type Address struct {
	Name    string
	Phone   string
	City    string
	AddTime string
}

func main() {
	var u User
	u.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 main

import "fmt"

type User struct {
	Username string
	Password string
	Address
	Email
}

type Address struct {
	Name    string
	Phone   string
	City    string
	AddTime string
}

type Email struct {
	Account string
	AddTime string
}

func main() {
	var u User
	u.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 main

import "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()
}

在这里插入图片描述

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

package main

import "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 main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	Id     int
	Gender string
	Name   string
	Sno    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 main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	Id     int
	Gender string
	Name   string
	Sno    string
}

func main() {
	jsonStr := `{"Id":1,"Gender":"男","Name":"张三","Sno":"s0001"}`
	var s Student
	err := 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 main

import (
	"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 main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	Id     int
	Gender string
	Name   string
}

type Class struct {
	Title    string
	Students []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 main

import (
	"encoding/json"
	"fmt"
)

type Student struct {
	Id     int
	Gender string
	Name   string
}

type Class struct {
	Title    string
	Students []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)
}