指针

在Go中，一个非定义指针类型的字面形式为*T，其中T为一个任意类型。类型T称为指针类型*T的基类型（base type）。 如果一个指针类型的基类型为T，则我们可以称此指针类型为一个T指针类型。

虽然我们可以声明定义指针类型，但是一般不推荐这么做。非定义指针类型的可读性更高。

如果一个指针类型的底层类型是*T，则它的基类型为T。

如果两个非定义指针类型的基类型为同一类型，则这两个非定义指针类型亦为同一类型。

一些指针类型的例子：

*int  // 一个基类型为int的非定义指针类型。
**int // 一个多级非定义指针类型，它的基类型为*int。

type Ptr *int // Ptr是一个定义的指针类型，它的基类型为int。
type PP *Ptr  // PP是一个定义的多级指针类型，它的基类型为Ptr。

指针类型的零值的字面量使用预声明的nil来表示。一个nil指针（常称为空指针）中不存储任何地址。

如果一个指针类型的基类型为T，则此指针类型的值只能存储类型为T的值的地址。

1. 我们可以用内置函数new来为任何类型的值开辟一块内存并将此内存块的起始地址做为此值的地址返回。 假设T是任一类型，则函数调用new(T)返回一个类型为*T的指针值。 存储在返回指针值所表示的地址处的值（可被看作是一个匿名变量）为T的零值。
2. 我们也可以使用前置取地址操作符&来获取一个可寻址的值的地址。 对于一个类型为T的可寻址的值t，我们可以用&t来取得它的地址。&t的类型为*T。

package main

import "fmt"

func main() {
    p0 := new(int)   // p0指向一个int类型的零值
    fmt.Println(p0)  // （打印出一个十六进制形式的地址）
    fmt.Println(*p0) // 0

    x := *p0              // x是p0所引用的值的一个复制。
    p1, p2 := &x, &x      // p1和p2中都存储着x的地址。
                          // x、*p1和*p2表示着同一个int值。
    fmt.Println(p1 == p2) // true
    fmt.Println(p0 == p1) // false
    p3 := &*p0            // <=> p3 := &(*p0)
                          // <=> p3 := p0
                          // p3和p0中存储的地址是一样的。
    fmt.Println(p0 == p3) // true
    *p0, *p1 = 123, 789
    fmt.Println(*p2, x, *p3) // 789 789 123

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

下面这张图描绘了上面这个例子中各个值之间的关系。

package main

import "fmt"

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

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

我们本期望上例中的double函数将变量a的值放大为原来的两倍，但是事实证明我们的期望没有得到实现。 为什么呢？因为在Go中，所有的赋值（包括函数调用传参）过程都是一个值复制过程。 所以在上面的double函数体内修改的是变量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
}

从上例可以看出，通过将double函数的输入参数的类型改为*int，传入的实参&a和它在此函数体内的一个副本x都引用着变量a。 所以对*x的修改等价于对*p（也就是变量a）的修改。 换句话说，新版本的double函数内的操作可以反映到此函数外了。

当然，在此函数体内对传入的指针实参的修改x = nil依旧不能反映到函数外，因为此修改发生在此指针的一个副本上。 所以在double函数调用之后，局部变量p的值并没有被修改为nil。

简而言之，指针提供了一种间接的途径来访问和修改一些值。 虽然很多语言中没有指针这个概念，但是指针被隐藏其它概念之中。

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

在Go中，指针是不能参与算术运算的。比如，对于一个指针p， 运算p++和p-2都是非法的。

如果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
}

1. 类型T1和T2的底层类型必须一致（忽略结构体字段的标签）。 特别地，如果类型T1和T2中只要有一个是非定义类型并且它们的底层类型一致（考虑结构体字段的标签），则此转换可以是隐式的。 关于结构体，请参阅下一篇文章。
2. 类型T1和T2都为非定义类型并且它们的基类型的底层类型一致（忽略结构体字段的标签）。

比如，

type MyInt int64
type Ta    *int64
type Tb    *MyInt

对于上面所示的这些指针类型，下面的事实成立：

1. 类型*int64的值可以被隐式转换到类型Ta，反之亦然（因为它们的底层类型均为*int64）。
2. 类型 *MyInt的值可以被隐式转换到类型Tb，反之亦然（因为它们的底层类型均为*MyInt）。
3. 类型*MyInt的值可以被显式转换为类型*int64，反之亦然（因为它们都是非定义的并且它们的基类型的底层类型均为int64）。
4. 类型Ta的值不能直接被转换为类型Tb，即使是显式转换也是不行的。 但是，通过上述三条事实，通过三层显式转换Tb((*MyInt)((*int64)(ta)))，一个类型为Ta的值ta可以被间接地转换为类型Tb。

这些指针类型的任何值都无法被转换到类型*uint64。

1. 这两个指针的类型相同。
2. 其中一个指针可以被隐式转换为另一个指针的类型。换句话说，这两个指针的类型的底层类型必须一致并且其中一个指针类型为非定义的（考虑结构体字段的标签）。
3. 其中一个并且只有一个指针用类型不确定的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)
    */
}