在 Go 语言中,结构体指针指的就是指向结构体变量的指针。
前面我们学过,结构体属于值类型,直接赋值或传参时都会把所有字段完整复制一份。如果结构体包含的字段较多,改用指针只传递它的内存地址,不仅能省去复制整个结构体的开销,还能在函数内部直接修改原结构体的数据。
创建结构体指针
在 Go 语言中,创建结构体指针常用的有以下 3 种方式:
- 对已有变量取地址:先定义普通的结构体变量,再使用取地址符
&获取它的内存地址。 - 字面量前直接加 &:在初始化结构体字面量时直接在前面加上
&符号,一步完成创建与取地址。 - 调用 new() 函数:调用内置的 new() 函数创建一个所有字段均为默认零值的结构体指针。
语法:
// 方式 1
指针变量 := &结构体变量
// 方式 2(推荐)
指针变量 := &结构体名{字段名1: 值1, 字段名2: 值2}
// 方式 3
指针变量 := new(结构体名)说明:
不管采用哪一种方式创建,结构体指针的类型名都在结构体名称前面带有一个星号 *(比如 *Student)。其中,方式 2 直接在初始化字面量前加上 & 符号,能够一步完成内存分配和字段赋初值,在实际开发中用得最多。
示例 1:创建结构体指针
package main
import "fmt"
type Student struct {
Name string
Age int
}
func main() {
// 方式 1:对已有变量取地址
stu := Student{Name: "Jack", Age: 20}
p1 := &stu
// 方式 2:字面量前直接加 &
p2 := &Student{Name: "Lucy", Age: 18}
// 方式 3:调用 new() 创建
p3 := new(Student)
fmt.Printf("p2 的类型:%T\n", p2)
fmt.Println(p1)
fmt.Println(p2)
fmt.Println(p3)
}运行结果如下。
p2 的类型:*main.Student
&{Jack 20}
&{Lucy 18}
&{ 0}分析:
在这个例子中,我们分别演示了创建结构体指针的 3 种方式。从 %T 的输出结果可以看出,p2 的类型为 *main.Student,表示它是一个指向 Student 结构体的指针。
为什么打印普通整型指针时输出的是十六进制地址,而打印结构体指针 p2 时输出的却是 &{Lucy 18} 呢?这是因为 fmt 包为了方便查看数据,自动把结构体指针格式化成了 &{字段值} 的样式,开头的 & 用来提示这是一个指针。
如果我们确实需要查看结构体指针保存的十六进制内存地址,调用 fmt.Printf("%p\n", p2) 就可以了。
这里小伙伴们还要特别注意区分普通结构体声明 var stu Student 与结构体指针声明 var p *Student。如果只声明结构体指针变量而不赋初值,此时 p 只是一个值为 nil 的空指针。如果我们直接通过它读写字段,程序运行时就会崩溃:
var p *Student
p.Name = "Jack" // 空指针不能直接读写字段因为 var p *Student 并没有分配结构体内存,直接执行 p.Name = "Jack" 会触发空指针解引用错误。读写字段前,我们必须先通过 &Student{}、new(Student) 或 &stu 让指针指向有效的内存。
访问结构体指针的字段
按照上一章学习的指针规则,拿到结构体指针 p 之后,原本需要先通过 *p 解引用拿到结构体本身,再写成 (*p).Name 去访问里面的字段。
为了简化日常编码,Go 语言提供了一项非常方便的简化规则:不管是普通的结构体变量,还是结构体指针,我们都可以统一使用英文点号(.)来读写字段。
语法:
结构体指针.字段名
结构体指针.字段名 = 新值说明:
当我们写下 p.Name 时,Go 编译器在底层会自动帮我们转换成标准的解引用写法 (*p).Name。这种让代码写起来更省事的简化语法,在编程中通常称为 “语法糖”。
示例 2:通过结构体指针读写字段
package main
import "fmt"
type Student struct {
Name string
Age int
}
func main() {
p := &Student{Name: "Jack", Age: 20}
// 直接使用点号读取字段
fmt.Println(p.Name)
// 直接使用点号修改字段
p.Age = 25
fmt.Println(p.Age)
fmt.Println((*p).Age)
}运行结果如下。
Jack
25
25分析:
p.Name 表示读取结构体指针 p 所指向的 Name 字段,而 p.Age = 25 表示将 Age 字段的值修改为 25。对于这个例子来说,下面 2 种写法是等价的。
// 写法 1(推荐)
p.Age = 25
// 写法 2
(*p).Age = 25很明显,写法 1 省去了星号和小括号,更加直观好读,在实际开发中我们直接使用写法 1 就可以了。
注意: 如果手动写出解引用过程,*p 外面的小括号千万不能省略。因为点号(.)的运算优先级高于星号(*),写成 *p.Age 会被编译器当成 *(p.Age) 去对整数解引用,从而直接报错。
结构体指针作为函数参数
与基本数据类型的值传递与指针传递一样,把普通结构体传给函数时传递的是数据副本,而把结构体指针传给函数时传递的是内存地址。因此,只有将函数形参声明为结构体指针(如 *Student),才能在函数内部直接修改外部原结构体的字段。
示例 3:结构体值传参与指针传参
package main
import "fmt"
type Student struct {
Name string
Age int
}
// 接收普通结构体
func growUpVal(s Student) {
s.Age = 30
}
// 接收结构体指针
func growUpPtr(p *Student) {
p.Age = 30
}
func main() {
stu := Student{Name: "Jack", Age: 20}
growUpVal(stu)
fmt.Println(stu.Age)
growUpPtr(&stu)
fmt.Println(stu.Age)
}运行结果如下。
20
30分析:
当我们调用 growUpVal(stu) 时,程序把 stu 复制了一份传给形参 s。函数内部执行 s.Age = 30 改的只是副本,所以外部 stu.Age 依然输出 20。
而调用 growUpPtr(&stu) 时,我们把 stu 的内存地址传给了指针形参 p。函数内部执行 p.Age = 30 会通过地址直接找到外部的 stu 并修改它的年龄,因此再次打印 stu.Age 时就变成了 30。
编写 NewXXX() 构造函数
在实际项目开发中,我们经常需要在创建结构体时统一设置某些字段的默认值,或者对传入的参数做合法性检查。
Go 语言本身没有专门的构造函数语法。我们通常会编写一个以 New 开头的普通函数(如 NewStudent),在里面完成参数检查与初始化,再返回一个结构体指针。
示例 4:编写 NewStudent() 构造函数
package main
import "fmt"
type Student struct {
Name string
Age int
Score float64
}
// 自定义构造函数
func NewStudent(name string, age int) *Student {
if age < 0 {
age = 0 // 修正非法年龄
}
return &Student{
Name: name,
Age: age,
Score: 60.0,
}
}
func main() {
stu1 := NewStudent("Tony", 19)
stu2 := NewStudent("Lucy", -5)
fmt.Printf("%+v\n", stu1)
fmt.Printf("%+v\n", stu2)
}运行结果如下。
&{Name:Tony Age:19 Score:60}
&{Name:Lucy Age:0 Score:60}分析:
NewStudent() 函数接收姓名 name 和年龄 age 两个参数。在创建结构体之前,函数先检查 age < 0,一旦传入负数就自动修正为 0。随后再将 Score 设为默认及格分 60.0,并通过 &Student{...} 返回结构体指针。
比起直接写 &Student{...},封装一个 NewStudent() 既能统一默认值,又能拦住明显不合理的脏数据。以后阅读 Go 标准库或开源项目代码时,小伙伴们会经常看到这类 NewXXX() 函数,这是 Go 社区约定俗成的创建方式。
提示: 在 C 或 C++ 中,函数内部普通变量的地址在函数结束后就会失效,不能直接返回。而在 Go 语言中完全不用担心这一点。当编译器发现函数内部创建的 &Student{...} 地址被返回到外部继续使用时,会自动把这块数据保留下来,函数执行结束后依然可以安全读写。
