你必须非常努力，才能看起来毫不费力！

微信搜索公众号[ 漫漫Coding路 ]，一起From Zero To Hero !

前言

在写 Go 的过程中，我们不免会使用指针，但是大多数情况下使用的是类型安全的指针，类型安全的指针有助于我们写出安全的代码，但是却有诸多限制，比如不能对地址进行算数运算、不支持任意两个类型相互转换等。

Go 实际上是支持非类型安全的指针的，通过非类型安全指针，我们可以绕过诸多限制，在某些情况下甚至可以写出更高效的代码，但同时也可能会引入一些潜在的不容易发现的问题。其次，非类型安全指针没有受到 Go1兼容性保证 的保护，在后续的Go版本中，使用非类型安全指针的代码可能会无法编译通过。

即使会有上述的风险，但目前源码的很多地方都使用了非类型安全指针，同时官方给出了正确的使用方式，本篇文章我们就一起来学习下吧！

说明：本文中的示例，均是基于Go1.17 64位机器

类型安全指针

如何获得一个指针

我们有两种方式来获取类型安全的指针：

1. 通过内置函数 new 获取某个类型值的指针
2. 通过取地址符 & 获取某个变量的指针

func main() {
    // 通过 new 为int类型的值开辟一块内存，并返回指向内存起始地址的指针
    a := new(int)
    fmt.Printf("%p\n", a) // 0xc00034a4b8

    // 通过取地址符 & ，获取一个变量的指针
    b := int32(1)
    c := &b
    fmt.Printf("%p\n", c) //0xc00034a4c0
}

为什么需要使用指针

在 Go 中，所有的参数传递都是值传递，没有引用传递。

1. 如果参数占用内存过大，每次函数传递都需要变量拷贝，比较耗费内存；
2. 如果我们想要在函数内部修改变量的状态，并在调用完毕后看到这种修改，就需要使用指针。

比如我们想要调用 add 完成变量的加一操作，但是最终并没有达到期望的效果，原因就是值传递，即调用 add(b) 的时候，传入的参数是 变量b 的一份复制，并不会影响 main函数 中 变量b 本身。

func add(a int) {
    a = a + 1
}

func main() {
    b := 1
    add(b)
    println(b) // 1
}

如果想要达到修改成功的目的，就需要传递指针：

func add(a *int) {
    *a = *a + 1
}

func main() {
    a := 1
    add(&a)
    println(a) // 2
}

类型安全指针的限制

1. 不能对指针的地址进行算术运算

我们定义一个变量 a ，然后取地址，对地址算数运算 addr++ 会编译不通过；*addr++ 编译通过，最后输出 a=2，其实 *addr++ 被编译器解释为了(*addr)++，即解引用操作符 * 的优先级 高于 自增符++

func main() {
    a := 1
    addr := &a
    // addr++  编译不通过
    *addr++ // 编译通过
    fmt.Println(a) // 2
}  

2. 两个任意指针类型不能随意转换

只有两个类型的底层数据类型是一致的，才可以完成转换

type MyInt int64
type T1 *int64
type T2 *MyInt

func main() {

    var a *int64
    var myInt *MyInt

    var t1 T1
    t1 = a // t1 是 *int64类型，a 是 *int64 类型，可以隐式转换

    var t2 T2
    t2 = myInt       // t2 是 *MyInt类型，myInt 是 *MyInt类型，可以隐式转换
    t2 = (*MyInt)(a) // t2 的底层类型是 *int64，a 是 *int64 类型，需要显式转换

    t1 = (*int64)((*MyInt)(t2)) // t2 的底层类型是 *int64，t1 是 *int64类型，需要显式转换
}

但是这些类型，无论怎么转换，都转换不了 *uint64 类型

unsafe包

我们说的 非类型安全指针 就是指 unsafe 包中的 Pointer，它被类型定义为 type Pointer *ArbitraryType，ArbitraryType 在这里仅仅是用于表示任意类型，也就是说 Pointer 可以指向任意数据类型，可以和任意类型的指针相互转换。

// 表示任意类型
type ArbitraryType int

type Pointer *ArbitraryType

在上篇文章中Go语言内存对齐详解，我们也简单了解了 unsafe 包中有如下三个函数：

1. func Sizeof(x ArbitraryType) uintptr

   返回一个变量占用的内存字节数

2. func Offsetof(x ArbitraryType) uintptr

   返回结构体某个字段的地址相对于此结构体起始地址的偏移量

3. func Alignof(x ArbitraryType) uintptr

   返回对齐系数

这三个函数的返回值的类型均为内置类型 uintptr，uintptr 是一个整数值，来保存变量的内存地址，可以和 Pointer 相互转换。

Pointer 表示指向任意类型的指针，对于该类型有四种合法的操作：

• 任意类型的指针可以转为 Pointer
• Pointer 可以转为任意类型的指针
• uintptr 可以转为 Pointer
• Pointer 可以转为 uintptr

func main() {

    a := int(1)

    b := (*int64)(unsafe.Pointer(&a)) // 将 *int 先转为 Pointer，再转为 *int64

    c := uintptr(unsafe.Pointer(&a)) // 将 *int 先转为 Pointer，再转为 uintptr

    fmt.Printf("%p\n", b) // 打印地址 0xc0003cdbb0
    fmt.Printf("%x\n", c) // 地址 c0002124b8

  
    type T struct {
        a string
        b int
    }
    t := T{a: "abc", b: 1}

    /*
        1. 将 t 的地址转为 Pointer：符合第一种
        2. 将 Pointer 转为 uintptr 后得到地址的整数值：符合第四种
        3. 加上 t.b 的offset，得到 t.b 的地址整数值：uintptr是整数，可以直接相加
        4. 将 uintptr 转为 Pointer：符合第三种
        5. 将 Pointer 转为 *int :符合第二种
        6. 最后解引用，得到具体的值
    */
    d := *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&t)) + unsafe.Offsetof(t.b)))
    fmt.Println(d) // 1
}  

Pointer 越过了类型检查，可以直接操作底层的内存，因此使用时需要格外小心。对于 Pointer的操作，只有如下六种是合法的，其余的使用方式均为非法，我们一起来看下。

正确使用非类型安全指针

使用方式一：利用 Pointer 作为中介，完成 T1 类型 到 T2 类型的转换

T1 和 T2 是任意类型，如果 T1 的内存占用大于等于 T2，并且 T1 和 T2 的内存布局一致，可以利用 Pointer 作为中介，完成 T1类型 到 T2类型的转换。（如果T1 的内存占用小于 T2，那么 T2 剩余部分没法赋值，就会有问题）

math 包中的 Float64bits 函数将一个 float64 值转换为一个 uint64值，Float64frombits 为此转换的逆转换，即 Float64bits(Float64frombits(x)) == x。

func Float64bits(f float64) uint64 {
    return *(*uint64)(unsafe.Pointer(&f)) 
}

func Float64frombits(b uint64) float64 {
    return *(*float64)(unsafe.Pointer(&b)) 
}

如下所示，slice 和 string 结构的底层布局类似，且 slice 的内存占用大于 string，我们可以利用此种方式完成 slice 到 string 的正确转换，但是无法正确完成 string 到 slice 的转换。

// slice 和 string 的底层结构
type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

type stringStruct struct {
    str unsafe.Pointer
    len int
}

func main() {

    // slice 转 string，可以正确转换
    sli := []byte{'a', 'b', 'c'}
    str := *(*string)(unsafe.Pointer(&sli))
    fmt.Println(str)      // abc
    fmt.Println(len(str)) // 3

    // string 转 slice，cap 字段无法赋值，无法正确转换
    str = "1234"
    b := *(*[]byte)(unsafe.Pointer(&str))
    fmt.Println(string(b)) // 1234
    fmt.Println(len(b))    // 4
    fmt.Println(cap(b))    // 824634066744
}  
  

slice 转为 string 后，两者对应的指针指向的是同一个字节数组，因此修改底层的数组值，string 相应的也会跟着改变。

func main() {

    // 字节数组转字符串
    sli := []byte{'a', 'b', 'c'}
    str := *(*string)(unsafe.Pointer(&sli))
    fmt.Println(str)      // abc
    fmt.Println(len(str)) // 3

    sli[0] = 'd'
    sli[1] = 'e'
    fmt.Println(str) // dec
}  

使用方式二：将 Pointer 转为 uintptr (不再转回 Pointer)

将 Pointer 转为 uintptr，并且不再转回 Pointer，此方式用处不大，通常我们只用来打印值。

此方式相当于取变量的内存地址，由于 uintptr 是个变量值，而非引用，后续该变量被移动到其他位置，其对应的uintptr值不会更新；其次，如果后续没有使用该变量，随时可能会被垃圾回收掉。

// 每次运行得到的内存地址，可能不一样
func main() {
    a := int(10)
    fmt.Printf("%p\n", &a)                          // 0xc0001184b8
    fmt.Printf("%x\n", uintptr(unsafe.Pointer(&a))) // c0001184b8
}  

因此，将 uintptr 转回 Pointer 是存在风险的，只有接下来我们列举的几种转换方式合法的。

使用方式三：将Pointer转为 uintptr，然后再通过算数方式将 uintptr 转回 Pointer

我们可以将一个变量的 Pointer 转为 uintptr，然后再加上一定的偏移量转回 Pointer，这种方式通常用来获取结构体中的成员变量地址或者数组中第i个元素的地址。

结构体：我们可以先拿到结构体变量 e 的地址，然后加上 成员b 的偏移量，就可以得到 e.b 的地址，再转回 Pointer 就能够拿到对应的值了。

func main() {

    type Example struct {
        a int32
        b string
    }

    e := Example{
        a: 1,
        b: "test",
    }

    // 等价于 *(*string)(unsafe.Pointer(&e.b))
    c := *(*string)(unsafe.Pointer(uintptr(unsafe.Pointer(&e)) + unsafe.Offsetof(e.b)))

    fmt.Println(c, d)
}  

数组：拿到了数组第一个元素 a[0] 的地址，转为 uintptr 后，加上 2倍 个元素类型占用的内存大小，就可以得到第 3 个元素的地址值，再转回 Pointer，最后转为 int，就得到了第三个元素的值。

func main() {
    a := []int{1, 2, 3, 4}
    b := *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&a[0])) + 2*unsafe.Sizeof(a[0])))
    fmt.Println(b)
}  

同理，获取一个成员或元素的地址，然后减去相应的偏移量，也是合法操作。但是无论怎么操作，需要保证最后得到的地址，是在当前变量占用的地址范围内，不能超出，如下几种就是非法的操作：

• 非法操作一：超出变量内存范围

// 从初始地址，最多加  unsafe.Sizeof(s)-1
var s thing
end = unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + unsafe.Sizeof(s))

// 声明了 n 个字节的长度，从初始地址最多加 n-1
b := make([]byte, n)
end = unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(n))

• 非法操作二：使用变量保存 uintptr 的值

在将 uintptr 类型转为 Pointer 类型之前，不能将 uintptr 的的值赋值给变量

// 非法操作示例
func main() {

    type Example struct {
        a int32
        b string
    }

    e := Example{
        a: 1,
        b: "test",
    }

    // 正确操作 c := *(*string)(unsafe.Pointer(uintptr(unsafe.Pointer(&e)) + unsafe.Offsetof(e.b)))
    addr := uintptr(unsafe.Pointer(&e)) + unsafe.Offsetof(e.b)

    // 到这里，变量 e 没有任何引用了，因此可能随时被垃圾回收器回收，一旦被回收，再使用 e.b 原来的地址将是非常危险的
    c := *(*string)(unsafe.Pointer(addr))

    fmt.Println(c)
」   

• 非法操作三：Pointer 指向 nil

Pointer 需要指向一个分配过内存的变量，不能指向 nil

// Pintere指向nil是非法的
u := unsafe.Pointer(nil)
p := unsafe.Pointer(uintptr(u) + offset)

使用方式四：将 Pointer 转为 uintptr， 传递给系统调用 syscall.Syscall

我们知道 uintptr 是一个整数，获取到了一个变量的 uintptr 值，并不能保证变量不被垃圾回收掉，如果变量被垃圾回收掉，使用原先的 uintptr 值将是非常危险的。

下面这个函数是危险的原因在于，函数本身不能保证传递进来的地址对应的内存块一定没有被回收。 如果此内存块已经被回收了或者被重新分配给了其它变量，那么此函数内部的操作将是非法和危险的。

func DoSomething(addr uintptr) {
    // 对处于传递进来的地址处的值进行读写...
}

然而系统调用则有这种特权，保证了地址对应的内存块在函数执行过程中不被回收和移动。例如 syscall 标准库包中的 Syscall 函数的原型为：

func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno)

那么此函数是如何保证传递给它的地址参数值a1、a2和a3处的内存块在执行过程中一定没有被回收和被移动呢？ 此函数无法做出这样的保证，事实上，是编译器做出了这样的保证。 这是 syscall.Syscall 这样函数的特权，其它自定义函数无法享受到这样的待遇。

正确的使用姿势为：

// 将 p 对应的 Pointer 值转为 uintptr
syscall.Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(n))

同时需要注意的是，我们也不能先将 uintptr 的值赋值给一个变量，然后再传入 syscall.Syscall

u := uintptr(unsafe.Pointer(p))
// 此时 p 可能被回收或者移动
syscall.Syscall(SYS_READ, uintptr(fd), u, uintptr(n))

使用方式五：将 reflect.Value.Pointer 或者 reflect.Value.UnsafeAddr 的 uintptr 值转为 unsafe.Pointer

reflect包中，Value 类型的 Pointer和 UnsafeAddr方法都返回一个 uintptr 值，而不是 unsafe.Pointer 值，这样做是为了避免用户在没有引入 unsafe 包的条件下，就可以将这两个方法的返回值转为任意类型安全的指针。（比如返回值 a 是 unsafe.Pointer 类型，不引入unsafe包，可以直接进行(*int32)(a)，将其转为 int32 类型的指针 ）。

因此，这种设计需要我们在调用完 reflect.Value.Pointer 或者 reflect.Value.UnsafeAddr后，立即调用 unsafe.Pointer 转为 Pointer 类型，否则在调用的空窗期，变量可能被移动或者回收。

func main() {

    type Example struct {
        a int32
        b string
    }

    e := Example{
        a: 1,
        b: "test",
    }

    // 1. 正确使用方式
    b := *(*string)(unsafe.Pointer(reflect.ValueOf(&e.b).Pointer()))
    fmt.Println(b) // test

  // 2. 错误使用方式
    p := reflect.ValueOf(&e.b).Pointer()
    // 此时变量可能被移动或者回收
    b = *(*string)(unsafe.Pointer(p))
    fmt.Println(b) 
}  

使用方式六：将 reflect.SliceHeader 或者 reflect.StringHeader 的 Data 域对应的 uintptr 转为 Pointer，或者将其他 Pointer 转为 uintptr 赋值给 Data

slice 和 string 底层的数据结构如下：其中 slice 结构的 array 字段和 string 结构的 str 字段底层其实都指向 字节数组。

SliceHeader 和 StringHeader 分别是 slice 和 string 结构的运行时表示，对于任意一个 slice 或者 string，我们可以拿到它的运行时表示，然后修改其 Data 值，达到修改其底层数据的目的。即我们可以将一个字符串的指针值 转换为 *reflect.StringHeader ，进而可以对此字符串的内部进行修改。类似，我们也可以将一个切片的指针值转换为 *reflect.SliceHeader ，从而对此切片的内部进行修改。

这样做的好处是，在不重新分配内存的情况下，将 string 或 slice 的底层数据改变。

type slice struct {
    array unsafe.Pointer
    len   int
    cap   int
}

type stringStruct struct {
    str unsafe.Pointer
    len int
}

type SliceHeader struct {
    Data uintptr
    Len  int
    Cap  int
}

type StringHeader struct {
    Data uintptr
    Len  int
}

和上面第五条同样的原因，为了避免用户没有引入 unsafe包 就可以直接转换， reflect.SliceHeader 或者 reflect.StringHeader 的 Data 域都是 uintptr 类型。

// 修改字符串对应的Data域
func main() {

    str := "test"
  
  // 字节数组，修改后字符串底层数据指向这个数组
    a := [3]byte{'a', 'b', 'c'}

    strHeader := (*reflect.StringHeader)(unsafe.Pointer(&str))
    strHeader.Data = uintptr(unsafe.Pointer(&a))
    strHeader.Len = len(a)

    fmt.Println(str) // abc
}  

func main() {
  
    sli := []byte{'h', 'e', 'l', 'l', 'o'}

    array := [4]byte{'1', '2', '3', '4'}

    // 将切片转为 reflect.SliceHeader 结构
    sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&sli))

    // 修改对应的字段数据，修改后 sli 底层的数据指向了 array
    sliceHeader.Data = uintptr(unsafe.Pointer(&array))
  
  // 先设置长度为2
    sliceHeader.Len = 2
    sliceHeader.Cap = len(array)
    fmt.Printf("%s\n", sli) // 12

    // 修改 sli 的长度
    sli = sli[:cap(sli)]
    fmt.Printf("%s\n", sli) // 1234
  
}

一般来说，我们应该从一个已经存在的字符串得到 *reflect.StringHeader，或者从一个已经存在的切片得到 *reflect.SliceHeader，不能直接声明 reflect.SliceHeader 或 reflect.StringHeader 变量：

// 错误使用方式
var hdr reflect.StringHeader
hdr.Data = uintptr(unsafe.Pointer(new([5]byte)))
 // 在此时刻，上一行代码中刚开辟的数组内存块已经不再被任何值所引用，所以它可以被回收
hdr.Len = n
s := *(*string)(unsafe.Pointer(&hdr)) // 危险

使用 reflect.SliceHeader 和 reflect.StringHeader，我们可以在不重新分配底层数据内存的情况下，完成 slice 和 string 类型互换：

// 字节切片转 string
func ByteSlice2String(slice []byte) (s string) {
    sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))
    stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))
    stringHeader.Data = sliceHeader.Data
    stringHeader.Len = sliceHeader.Len
    return
}

// string 转字节切片
func String2ByteSlice(s string) (slice []byte) {
    stringHeader := (*reflect.StringHeader)(unsafe.Pointer(&s))
    sliceHeader := (*reflect.SliceHeader)(unsafe.Pointer(&slice))

    sliceHeader.Data = stringHeader.Data
    sliceHeader.Len = stringHeader.Len
    sliceHeader.Cap = stringHeader.Len
    return
}

func main() {

    b := []byte{'h', 'e', 'l', 'l', 'o'}
    fmt.Println(ByteSlice2String(b)) // hello

    s := "hello"
    fmt.Println(String2ByteSlice(s)) // [104 101 108 108 111]
  
}  
  

由于默认字符串内存是分配在不可修改区的，使用上述的 String2ByteSlice将 string 转为 slice 后，只能进行读取，不能修改其底层数据值：

func main() {

    s1 := "Goland" // 官方标准编译器会将 s1 的字节开辟在不可修改内存区
    
    b1 := String2ByteSlice(s1) // 转为字节数组
    fmt.Printf("%s\n", b1) // Goland

    // 由于字符串 s1 底层指向的字节数组在不可修改区，此时不能修改值，否则会panic
    // b1[5] = 'a'

    // 这种方式不会存放在不可修改区，转为字节数组后，可以修改值
    s2 := strings.Join([]string{"Go", "land"}, "")
    b2 := String2ByteSlice(s2)
    fmt.Printf("%s\n", b2) // Goland
    b2[5] = 'g' // 相当于修改底层数组的值，原字符串的值也会随之改变
    fmt.Println(s2) // Golang
}

总结

本篇文章从类型安全指针切入，介绍了如何获取指针、为什么需要使用指针以及类型安全指针的局限性，然后进一步介绍了 unsafe 包中对于非类型安全指针类型 Pointer 的定义以及使用方法，最后通过具体示例详细介绍了六种正确使用 Pointer 的场景。

更多

个人博客: https://lifelmy.github.io/

微信公众号：漫漫Coding路