Go36-15-指针

指针

之前已经用到过很多次指针了，不过大多数时候是指指针类型及其对应的指针值。这里要讲更为深入的内容。

其他指针

从传统意义上说，指针是一个指向某个确切的内存地址的值。这个内存地址可以是任何数据或代码的起始地址，比如，某个变量、某个字段或某个函数。

uintptr
在Go语言中还有其他几样东西可以代表“指针”。其中最贴近传统意义的当属uintptr类型了。该类型实际上是一个数值类型，也是Go语言内建的数据类型之一。根据当前计算机的计算架构的不同，它可以存储32位或64位的无符号整数，可以代表任何指针的位（bit）模式，也就是原始的内存地址。

unsafe.Pointer
在Go语言标准库中的unsafe包。unsafe包中有一个类型叫做Pointer，也代表了“指针”。unsafe.Pointer可以表示任何指向可寻址的值的指针，同时它也是前面提到的指针值和uintptr值之间的桥梁。也就是说，通过它，我们可以在这两种值之上进行双向的转换。这里有一个很关键的词——可寻址的（addressable）。在我们继续说unsafe.Pointer之前，需要先要搞清楚这个词的确切含义。

不可寻址的值

一下的值都是不可寻址的：

• 常量的值
• 基本类型值的字面量
• 算数操作的结果值
• 对各种字面量的索引表达式和切片表达式的结果值。例外，切片字面量的索引结果值是可寻址的
• 对字符串变量的索引表达式和切片表达式的结果值
• 对字典变量的索引表达式的结果值
• 函数字面量和方法字面量，以及对他们的调用表达式的结果值
• 结构体字面量的字段值，也就是对结构体字面量的选择表达式的结果值
• 类型转换表达式的结果值
• 类型断言表达式的结果值
• 接收表达式的结果值

上面一堆术语，看看在代码里具体指的是哪些类型：

package main

type Named interface {
    // Name 用于获取名字。
    Name() string
}

type Dog struct {
    name string
}

func (dog *Dog) SetName(name string) {
    dog.name = name
}

func (dog Dog) Name() string {
    return dog.name
}

func main() {
    // 示例1。
    const num = 123
    //_ = &num // 常量不可寻址。
    //_ = &(123) // 基本类型值的字面量不可寻址。

    var str = "abc"
    _ = str
    //_ = &(str[0]) // 对字符串变量的索引结果值不可寻址。
    //_ = &(str[0:2]) // 对字符串变量的切片结果值不可寻址。
    str2 := str[0]
    _ = &str2 // 但这样的寻址就是合法的。

    //_ = &(123 + 456) // 算术操作的结果值不可寻址。
    num2 := 456
    _ = num2
    //_ = &(num + num2) // 算术操作的结果值不可寻址。

    //_ = &([3]int{1, 2, 3}[0]) // 对数组字面量的索引结果值不可寻址。
    //_ = &([3]int{1, 2, 3}[0:2]) // 对数组字面量的切片结果值不可寻址。
    _ = &([]int{1, 2, 3}[0]) // 对切片字面量的索引结果值却是可寻址的。
    //_ = &([]int{1, 2, 3}[0:2]) // 对切片字面量的切片结果值不可寻址。
    //_ = &(map[int]string{1: "a"}[0]) // 对字典字面量的索引结果值不可寻址。

    var map1 = map[int]string{1: "a", 2: "b", 3: "c"}
    _ = map1
    //_ = &(map1[2]) // 对字典变量的索引结果值不可寻址。

    //_ = &(func(x, y int) int {
    //  return x + y
    //}) // 字面量代表的函数不可寻址。
    //_ = &(fmt.Sprintf) // 标识符代表的函数不可寻址。
    //_ = &(fmt.Sprintln("abc")) // 对函数的调用结果值不可寻址。

    dog := Dog{"little pig"}
    _ = dog
    //_ = &(dog.Name) // 标识符代表的函数不可寻址。
    //_ = &(dog.Name()) // 对方法的调用结果值不可寻址。

    //_ = &(Dog{"little pig"}.name) // 结构体字面量的字段不可寻址。

    //_ = &(interface{}(dog)) // 类型转换表达式的结果值不可寻址。
    dogI := interface{}(dog)
    _ = dogI
    //_ = &(dogI.(Named)) // 类型断言表达式的结果值不可寻址。
    named := dogI.(Named)
    _ = named
    //_ = &(named.(Dog)) // 类型断言表达式的结果值不可寻址。

    var chan1 = make(chan int, 1)
    chan1 <- 1
    //_ = &(<-chan1) // 接收表达式的结果值不可寻址。
}

总结一个不可寻址的值的特点：

1. 不可变的值不可寻址。常量、基本类型的值字面量、字符串变量的值、函数以及方法的字面量都是如此。其实这样规定也有安全性方面的考虑。
2. 绝大多数被视为临时结果的值都是不可寻址的。算术操作的结果值属于临时结果，针对值字面量的表达式结果值也属于临时结果。但有一个例外，对切片字面量的索引结果值虽然也属于临时结果，但却是可寻址的。
3. 若拿到某值的指针可能会破坏程序的一致性，那么就是不安全的，该值就不可寻址。由于字典的内部机制，对字典的索引结果值的取址操作都是不安全的。另外，获取由字面量或标识符代表的函数或方法的地址显然也是不安全的。

最后，如果把临时结果赋值给一个变量，那么它就是可寻址的了。

不可寻址的值的限制
无法使用取址操作符&获取他们的指针。如果尝试取址会是编译器报错，所以不用太担心。这里再看个小问题：

package main

import "fmt"

type Dog struct {
    name string
}

func (d *Dog) SetName (name string) {
    d.name = name
}

func New(name string) Dog {
    return Dog{name}
}

func main() {
    obj := New("Snoopy")
    obj.SetName("Goofy")
    fmt.Println(obj.name)
    // New("Snoopy").SetName("Wishbone")  //
}

这里写了一个New函数，用于获取Dog的结构体。返回的是结构体的值类型。还有一个指针方法，这里直接对值类型调用指针方法是没有问题的。因为会被自动转译成(&dog).SetName("Goofy")。但是New函数的调用结果值是不可寻址的，所以最后一行尝试直接以链式的方法调用就会有编译问题。这个不可取址的情况应该是属于临时结果，所以把结果赋值给一个变量，再调用指针方法是没有问题的。

自增++和自减--
另外，在Go语言中++和--不属于操作符，而是自增语句或自减语句的组成部分。只要在++或--的左边添加一个表达式，就组成了一个自增语句或自减语句，但是表达式的结果值必须是可寻址的。比如值字面的表达式就是无法自增的1++。
这里也有例外，字典字面量和字典变量索引表达式的结果值都是不可寻址的，但是可以自增、自减。
类似的规则还有两个：

1. 赋值语句，赋值操作符左边的表达式的结果值必须是可寻址的。但是对字典的索引结果值也是赋值
2. 带有range子句的for语句中，在range关键字左边的表达式的结果值也必须是可寻址的。还是对字典的索引结果值例外。

unsafe.Pointer黑科技

下面讲的方法，可以绕过Go语言的编译器和其他工具的重重检查，并达到潜入内存修改数据的目的。这不是一种正常的手段，使用它会很危险，还很可能造成安全隐患。我们总是应该优先使用常规代码包中提供的API去编写程序，当然也可以把像reflect以及go/ast这样的代码包作为备选项。
指针值、unsafe.Pointer、uintptr有如下的转换规则：

1. 指针值和unsafe.Pointer可以互相转换
2. uintptr和unsafe.Pointer也可以互相转换
3. 指针值和uintptr无法直接互相转换

所以说unsafe.Pointer是指针值和uintptr值之间的桥梁。到这一步，我们现在已经可以获取到变量的uintptr类型的值了：

s := student{}
sP := &s
sPtr := uintptr(unsafe.Pointer(sP))

unsafe.Offsetof 的使用
unsafe.Offsetof函数返回变量（struct类型）指定属性的偏移量，以字节为单位。如下使用就可以获取到结构体的属性相对于结构体的偏移量了：

func main() {
    type student struct {
        name string
        age int
    }
    s1 := student{}
    p1 := unsafe.Offsetof((&s1).name)  // 结构体的第一个变量，偏移量是0
    p2 := unsafe.Offsetof((&s1).age)  // 这里就会有偏移量了
    fmt.Println(p1, p2)
}

搭配使用获取属性的地址
简单的把结构体的地址和属性的偏移量相加，就能获得属性的地址了。获取到了属性的地址后，如果再对这个地址做两次地址转换，就变回属性的指针值了：

package main

import (
    "unsafe"
    "fmt"
)

func main() {
    type student struct {
        name string
        age int
    }
    s1 := student{"Adam", 18}
    s1P := &s1
    s1Ptr := uintptr(unsafe.Pointer(s1P))  // 结构体的地址
    fmt.Println(s1Ptr)
    namePtr := s1Ptr + unsafe.Offsetof(s1P.name)  // name属性的地址
    agePtr := s1Ptr + unsafe.Offsetof(s1P.age)  // age属性的地址
    fmt.Println(namePtr, agePtr)
    nameP := (*string)(unsafe.Pointer(namePtr))  // 获取到属性的指针
    ageP := (*int)(unsafe.Pointer(agePtr))
    fmt.Println(*nameP, *ageP)  // 取值获取到属性指针的值
}

上面的方法，饶了一大圈就是为了获取到结构体里属性的地址。有了地址就可以对操作，也就可以直接修改埋藏的很深的内部数据了。比如可以直接结果别的包里的结构体内的不可导出的属性值。

修改结构体不可导出的属性值
知识点都在上面了，这里直接试着修改别的包的结构体内的不可导出的属性的值：

// article15/example06/model/s.go
package model

// 结构体属性全小写
type Student struct {
    name string
    age int
}

// article15/example06/main.go
package main

import (
    "Go36/article15/example06/model"
    "fmt"
    "unsafe"
)

func main() {
    s1 := model.Student{}
    s1P := &s1
    s1Ptr := uintptr(unsafe.Pointer(s1P))
    namePtr := s1Ptr + 0
    agePtr := s1Ptr + 16
    nameP := (*string)(unsafe.Pointer(namePtr))
    ageP := (*int)(unsafe.Pointer(agePtr))
    *nameP = "Adam"
    *ageP = 22
    fmt.Println(s1)
}

这里unsafe.Pointer类型和uintptr类型所代表指针更贴近于底层和内存，理论上可以利用它们去访问或修改一些内部数据。但是这么用会带来安全隐患，在很多时候，使用它们操纵数据是弊大于利的。总之知道就行了，别这么用。