Go 指针

在 Go 语言中,指针(pointer)是一个非常基础且重要的概念。把指针的原理弄清楚,我们就能明白数据在计算机内存中是如何存放和访问的,后面学习指针传参、结构体与方法时也会顺畅很多。

Go 指针是什么?

当我们在程序中定义一个变量(比如 a := 10)时,计算机会在内存中开辟一块空间,把整数 10 存进去。为了能够准确找到这块空间,计算机会给内存中的每一个位置分配一个唯一的编号,这个编号就叫做 “内存地址”。

所谓的 “指针”,指的就是内存地址,而专门用来保存内存地址的变量就叫做 “指针变量”。说白了,普通变量存的是具体的数据值,指针变量存的是数据所在的内存地址。

形象来说,普通变量 a 就像一间住着数字 10 的 808 号酒店房间,内存地址是门牌号 “808”。而指针变量则是一张记录着 808 门牌号的 “房卡”,拿着这张房卡,我们随时都能找到对应的房间。

普通变量与指针变量的内存关系

严格来说,“指针” 代表具体的内存地址,“指针变量” 代表保存该地址的变量。不过在日常交流和大多数资料中,大家经常把 “指针变量” 直接简称为 “指针”。小伙伴们根据上下文理解即可,不用在字眼上过多纠结。

声明指针与取地址(&)

既然指针变量是用来存放内存地址的,那我们应该怎么获取一个变量的地址,又应该怎么声明指针变量呢?在 Go 语言中,这需要配合取地址符 & 和指针类型(如 *int)来实现。

语法:

// 方式 1
var 指针变量名 *数据类型 = &普通变量

// 方式 2(推荐)
指针变量名 := &普通变量

说明:

在上面的语法中,我们需要重点掌握以下 2 个部分的作用:

  • 取地址符(&):放在普通变量名前面(如 &a),用来获取该变量在内存中的地址。
  • 指针类型(*数据类型):在数据类型前面加上星号 *,就表示对应的指针类型。例如,*int 表示指向 int 变量的指针,*string 表示指向 string 变量的指针。

前面学习键盘输入时,我们在调用 fmt.Scan() 时给变量名前面加上 &,其实就是把变量的内存地址传给函数,让函数把输入内容直接存进该变量里。

在实际开发中,如果已经有了普通变量,我们更习惯直接使用方式 2 的短变量声明 :=(如 p := &a),由编译器自动推导出指针类型。

示例 1:获取变量的内存地址

package main

import "fmt"

func main() {
    a := 10
    fmt.Println(a)
    fmt.Printf("%p\n", &a)
}

运行结果如下。

10
0xc0000180a8

分析:

&a 表示获取变量 a 在内存中的地址。在 fmt.Printf() 中,%p 是专门用来输出指针地址的格式化占位符,其中 p 是 “pointer(指针)” 的首字母。打印出来的 0xc0000180a8 就是变量 a 的十六进制内存地址。

需要注意的是,每次重新运行程序时,操作系统分配给变量的内存地址都可能发生变化。因此小伙伴们在自己电脑上运行看到的地址编号可能跟上面不一样,这是正常现象。

取出了变量的内存地址后,我们就可以把它保存到一个指针变量中。请看下面例子。

示例 2:声明指针变量

package main

import "fmt"

func main() {
    a := 10
    s := "lvye"

    var p1 *int = &a    // 完整声明整型指针
    p2 := &s            // 短变量声明字符串指针

    fmt.Println(p1)
    fmt.Println(p2)
    fmt.Printf("p1 的类型:%T,p2 的类型:%T\n", p1, p2)
}

运行结果如下。

0xc0000180a8
0xc000014070
p1 的类型:*int,p2 的类型:*string

分析:

在这个例子中,变量 a 是 int 类型,因此取出的地址 &a 需要赋值给 *int 类型的指针变量 p1。变量 s 是 string 类型,当我们使用 p2 := &s 时,编译器会自动推导出 p2 的类型为 *string。

直接使用 fmt.Println() 打印指针变量时,默认也会输出它保存的十六进制内存地址。此外,Go 语言对指针类型的检查非常严格,*int 指针只能保存 int 变量的地址,把 &s 赋给 *int 指针会直接报错。

指针的解引用(*)

拿到了变量的内存地址之后,如果我们想根据这个地址读取里面存放的数据,或者直接修改里面的数据,就需要使用解引用符 *。所谓的 “解引用(dereference)”,指的就是通过指针保存的内存地址,找到它指向的那个原变量。

语法:

变量名 := *指针变量名
*指针变量名 = 新值

说明:

在已经定义好的指针变量名前面加上星号 *(如 *p),就代表指针所指向的那个原变量本身。把 *p 放在等号右边或直接打印,表示读取它指向的变量值。把 *p 放在等号左边(如 *p = 99),则表示直接修改原变量的值。

很多初学的小伙伴看到星号 * 容易搞混,其实只要看星号跟在谁的前面,就能分清它的作用:

  • 跟在数据类型前面:比如 *int,用于声明指针类型,表示这是一个指向 int 数据的指针。
  • 跟在指针变量前面:比如 *p,用于解引用操作,表示根据地址找到目标变量,进而读取或修改它的值。

示例 3:读取指针指向的值

package main

import "fmt"

func main() {
    a := 10
    p := &a

    fmt.Println(p)     // 输出 p 保存的地址
    fmt.Println(*p)    // 输出 p 指向的变量值
}

运行结果如下。

0xc0000180a8
10

分析:

直接打印 p 得到的是变量 a 的内存地址 0xc0000180a8。而在 p 前面加上星号写成 *p 后,程序就会根据这个地址找到目标变量 a,把里面存放的整数 10 读取出来。

提示: 在 Go 语言中,取地址符 & 和解引用符 * 是一对互逆的操作:& 是 “由变量获取地址”,而 * 则是 “由地址找到变量”。因此,对于任意一个普通变量 a,*&a 的结果就等价于变量 a 本身。

除了读取数据之外,我们还可以直接给 *p 赋一个新的值,从而修改原变量的数据。

示例 4:通过指针修改原变量的值

package main

import "fmt"

func main() {
    a := 10
    p := &a

    *p = 99    // 修改 p 指向的变量值

    fmt.Println(*p)
    fmt.Println(a)
}

运行结果如下。

99
99

分析:

*p = 99 表示通过指针 p 保存的内存地址,直接把目标变量的值修改为 99。由于指针 p 指向的正是变量 a,操作 *p 就相当于直接操作变量 a 本身,因此原变量 a 的值也就同步变成了 99。

看到这里,可能你会觉得奇怪:“直接写 a = 99 不就行了吗,为什么要绕一圈使用指针来修改呢?” 其实在同一个函数内部确实没必要这么麻烦,这里只是为了方便大家看清语法。

在实际开发中,指针主要用于在函数内部修改外部变量的值,以及在传递大型数据时省去复制开销,我们会在下一节 “值传递与指针传递” 中展开介绍。

需要注意的是,通过指针修改目标变量的值时,前面的星号 * 千万不能漏掉。下面这 2 种写法有着本质区别。

// 正确方式
*p = 99

// 错误方式
p = 99

在上面的错误方式中,漏掉星号写成 p = 99,编译器会认为我们想把整数 99 当作内存地址赋给指针变量 p,编译时就会直接报错。

不过,如果我们给 p 赋的是另一个同类型变量的地址(比如 p = &b),那就完全合法了。这相当于把房卡上的门牌号从 808 改写成了 809,原来 808 房间里的数字 10 不会受到影响,后续再操作 *p 修改的就是变量 b 的值。

下面代码中,变量 a 和 b 的最终值分别是 10 和 25,小伙伴们可以思考一下为什么。

a := 10
b := 20
p := &a
p = &b
*p = *p + 5

使用指针的注意事项

在日常开发中使用指针时,我们还需要注意以下 3 点:

  • 同类型指针支持判等比较:我们可以使用 == 或 != 判断两个同类型指针保存的地址是否相同,也就是判断它们是否指向同一个变量。不同类型的指针之间不能直接比较。
  • 不能对字面量或常量取地址:取地址符 & 只能用于已经在内存中分配了存储空间的变量。像整数 10、字符串 "lvye" 这样的字面量,或者使用 const 定义的常量,都没有可供寻址的内存空间,我们不能对它们使用 &。
  • 未赋值的指针不能直接解引用:如果我们只声明了指针变量(如 var p *int)而没有赋初始地址,它的默认值为 nil,属于空指针。此时千万不能直接读写 *p,否则程序运行时会直接崩溃。

下面我们通过一个例子来验证两个指针的判等比较。

示例 5:使用 == 比较两个指针

package main

import "fmt"

func main() {
    a := 10
    b := 10
    p1 := &a
    p2 := &a
    p3 := &b

    fmt.Println(p1 == p2)
    fmt.Println(p1 == p3)
}

运行结果如下。

true
false

分析:

p1 和 p2 保存的都是变量 a 的内存地址,它们指向同一个变量,因此 p1 == p2 返回 true。而变量 b 虽然数值也是 10,但它是另一个独立的变量,拥有不同的内存地址,所以 p1 == p3 返回 false。

此外,平时想要获取某个数值的指针时,我们必须先定义一个普通变量再取地址。如果直接对字面量或常量加上 &,编译器就会报错。

// 正确方式
n := 10
p := &n

// 错误方式
const Max = 5
p1 := &10     // 不能对字面量取地址
p2 := &Max    // 不能对常量取地址

因为整数 10 和常量 Max 在编译阶段只是固定的值,系统并没有为它们分配可寻址的内存空间。直接取地址会触发编译报错 cannot take address of 10,提示无法获取 10 的内存地址。

Go 指针与 C/C++ 指针的区别

不少小伙伴可能听说过,C 或 C++ 语言里的指针很容易引发内存越界或程序崩溃。这主要是因为在 C/C++ 中,程序可以对指针直接执行加减运算(如 p++ 或 p + 1),让指针跳到相邻的内存位置读写数据。一旦算错偏移量,就会破坏其他内存中的数据。

为了兼顾运行效率与内存安全,Go 语言在保留指针的同时做了严格的安全限制。在常规的 Go 代码中,不支持对指针执行 p++、p + 1 等偏移运算,也不允许随意将不同类型的指针相互转换,大大降低了指针出错的风险。

给站长反馈

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

邮箱:lvyenet@vip.qq.com

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