Go 结构体指针

在 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{...} 地址被返回到外部继续使用时,会自动把这块数据保留下来,函数执行结束后依然可以安全读写。

上一篇:

下一篇:

给站长反馈

绿叶网正在不断完善中,小伙伴们如果发现任何问题,还望多多给站长反馈,谢谢!

邮箱:lvyenet@vip.qq.com

「绿叶网」服务号
绿叶网服务号放大
关注服务号,微信也能看教程。
绿叶网服务号