Go中的指针

翻译自

https://go101.org/article/pointer.html

尽管Go吸收了很多其他语言的特性，但Go总体来说是一个C家族语言。其中一个证据就是Go也支持指针。Go指针和C指针在许多方面非常相似，但其中也有一些不同。本文将会列举Go指针的概念和细节。

Memory Address 内存地址

内存地址指的是整个系统管理（通常由操作系统管理）的内存空间中的偏移量（byte的个数）。

通常，内存地址被存储成一个无符号（整型）字。字长在32位机器上是4字节，在64位机器上是8字节。所以理论最大寻址范围，在32位机器上是2^32，也就是4GB。在64位机器上是2^64，也就是16EB（1EB=1024PB，1PB=1024TB，1TB=1024GB）。

内存地址通常用Hex表达模式书写，如0x1234CDEF

Value Address 值地址

值的地址代表这个值在内存段中的起始地址

什么是指针？

指针是Go的一种类型。指针用来存储内存地址。跟C语言不同，为了安全的原因，Go指针上有一些限制。

Go指针类型和值

在Go中，未定义的指针类型可以被写成*T，T可以是任意类型。T是*T的基础类型。

我们也可以自定义指针类型，通常由于未定义指针类型拥有更好的可读性，不推荐使用自定义指针类型。

如果一个定义的指针类型的底层类型（underlying type）是*T，那么该指针的基础类型是T。这个基础类型相同的指针也是同一种类型。样例

// 未定义的指针类型，基础类型是int
*int
// 未定义的指针类型，基础类型是*int
**int 

// Ptr是一个定义指针类型，基础类型是int
type Ptr *int 
// PP是一个定义指针类型，基础类型是Ptr
type PP *Ptr

指针的零值是nil，不存储任何地址。

基础类型为T的指针仅能存储T类型值的地址

如何获得指针值、什么是可寻址值

有两种方式可用于获取非nil的指针值

go内置的new函数，可以分配任何类型的内存。new(T)在内存中分配一个T值的空间，然后返回T值的地址。分配的值是T类型的零值。返回的地址就是一个T类型的指针
我们还可以直接获取可寻址值的地址。对于一个可寻址类型T的值t，我们可以使用&t来获取t的地址，`&操作符用来获取值地址。

通常上来说，可寻址值意味着该值存放在内存中的某处。现在，我们只需要知道任何变量都是可寻址的，同时常数、函数调用和显示转换的结果是不可寻址的。变量声明的时候，Go运行时将会为这个变量分配一片内存，这片内存的开始地址就是这个变量的地址。

Pointer Derefernece 指针解引用

对于一个基础类型为T的指针类型p，你如何获取指针中存储的值（或者说，被指针指向的值）？只需要使用表达式*p，*被称为解引用操作符。指针的解引用是取地址的逆运算。*p的返回值是T类型，也就是p的基础类型。

对nil指针进行解引用会导致运行时异常。

这个程序展示了地址获取和解引用的例子:

package main

import "fmt"

func main() {
    // p0指向int的零值
    p0 := new(int)
    // hex表达的地址
    fmt.Println(p0)
    // 0
    fmt.Println(*p0)

    // x是p0指向值的拷贝
    x := *p0
    // 都取得x的地址
    // x, *p1, *p2 的值相同
    p1, p2 := &x, &x
    // true
    fmt.Println(p1 == p2)
    // false
    fmt.Println(p0 == p1)
    // p3 和 p0 也存储相同的地址
    p3 := &*p0
    fmt.Println(p0 == p3)
    *p0, *p1 = 123, 789
    // 789 789 123
    fmt.Println(*p2, x, *p3)

    // int, int
    fmt.Printf("%T, %T \n", *p0, x)
    // *int, *int
    fmt.Printf("%T, %T \n", p0, p1)
}

下图揭示了上面程序存储的值间关系

image-20210712093648121

为什么我们需要指针

让我们先来看一个样例程序

package main

import "fmt"

func double(x int) {
    x += x
}

func main() {
    var a = 3
    double(a)
    fmt.Println(a) // 3
}

上例中的double函数预期对输入值进行双倍处理。但是它失败了。为什么？因为所有值的分配，包括函数参数的传递，都是值拷贝。double函数操作的x只是a变量的拷贝，而不是a变量。

修复上例的一种方式是让double函数返回一个新值。但这并不是所有场景都适用。下例展示了另一种使用指针的方案

package main

import "fmt"

func double(x *int) {
    *x += *x
    // 这行只为了解释用途
    x = nil 
}

func main() {
    var a = 3
    double(&a)
    fmt.Println(a) // 6
    p := &a
    double(p)
    fmt.Println(a, p == nil) // 12 false
}

我们可以发现，通过将参数改为指针类型，传递的指针参数&a和它的拷贝x都指向相同的值，所以在*x上进行的修改，在a上也体现了出来。同时，因为参数传递都是值拷贝，上面将x赋值为nil，在p上也不生效。

简而言之，指针提供了操作值的间接方式。大部分语言没有指针的概念。然而，指针的概念只是隐藏在了语言的其他概念中。

返回局部变量指针在Go是安全的

和C语言不通，Go支持垃圾回收，所以返回局部变量的指针在Go中是绝对安全的

func newInt() *int {
    a := 3
    return &a
}

Go指针的限制

为了安全原因，相比C语言来说，Go在指针上做了一些限制。通过这些限制，Go保持了指针带来的收益，并且避免了危险的指针使用。

Go指针不支持算术操作

在Go中，指针不能进行算术运算。对于指针p，p++和p-2都是非法的。

如果指针p指向一个数值，编译器会将*p++识别为一个合法的语句，并解析为(*p)++。换句话说，*p操作的优先级高于++、--操作符。样例

package main

import "fmt"

func main() {
    a := int64(5)
    p := &a

    // 下面的语句无法编译
    /*
    p++
    p = (&a) + 8
    */

    *p++
    fmt.Println(*p, a)   // 6 6
    fmt.Println(p == &a) // true

    *&a++
    *&*&a++
    **&p++
    *&*p++
    fmt.Println(*p, a) // 10 10
}

指针值不能转换为任意的指针类型

在Go中，T1的指针值可以被隐式或是显示地转换为T2，需要满足如下两个条件

T1和T2的底层类型相同（忽略结构体Tag）。特别地，如果T1和T2都是未定义类型并且它们的底层类型相同（考虑结构体Tag），可以进行隐式转换。
T1和T2都是未定义指针类型，并且它们的基础类型的底层类型相同（忽略结构体Tag）

举个例子，有如下类型

type MyInt int64
type Ta *int64
type Tb *MyInt

有如下事实

*int64类型的值可以被隐式转换为Ta类型，反过来也是可以的。因为它们的底层类型都是*int64
*MyInt类型的值可以被隐式转换为Tb类型，反过来也行。因为它们的底层类型都是*MyInt
*MyInt类型的值可以被限制转换为*int64，反之亦然。因为它们的基础类型的底层类型都是int64
即使是显示转换，Ta类型的值也不能直接转换为Tb。因为Ta和底层类型和Tb不同，并且都是定义指针类型。不过可以进行连续几次转换，将Ta类型的pa间接转化为Tb类型。先将pa转化为*int64类型（因为基础类型的底层类型都是int64），再将*int64类型转换为*MyInt类型，再将*MyInt类型转化为*Tb类型。Tb((*MyInt)((*int64)(pa)))

上面的值通过任何安全的手段，都不能转化为类型*uint64

任意两个指针的值不能比较

在Go中，指针可以通过==和!=符号比较。如果满足如下任意一个条件，那么两个Go指针的值可以进行比较

两个Go指针类型一致
指针值可以隐式转换为另一类型
两个指针中的一个且仅一个用无类型 nil 标识符表示。

package main

func main() {
    type MyInt int64
    type Ta    *int64
    type Tb    *MyInt

    // 4个不同类型的指针零值
    var pa0 Ta
    var pa1 *int64
    var pb0 Tb
    var pb1 *MyInt

    // 下面这6行都可以正常编译
    // 比较结果都为true
    // 指针可以隐式转换
    _ = pa0 == pa1
    // 指针类型一致
    _ = pb0 == pb1
    _ = pa0 == nil
    _ = pa1 == nil
    _ = pb0 == nil
    _ = pb1 == nil

    // 这三行都不能正常编译
    /*
    _ = pa0 == pb0
    _ = pa1 == pb1
    _ = pa0 == Tb(nil)
    */
}

指针值不能赋值给其他指针类型

指针值互相赋值的条件和比较的条件一样

有手段打破Go对指针的限制

unsafe 标准包提供的机制（特别是 unsafe.Pointer 类型）可以用来打破 Go 中对指针的限制。 unsafe.Pointer 类型类似于 C 中的 void*。一般不推荐使用unsafe。

Go 指针