《快学 Go 语言》第 14 课 —— 魔术变性指针

本节我们要学习一些 Go 语言的魔法功能，通过内置的 unsafe 包提供的功能，直接操纵指定内存地址的内存。有了 unsafe 包，我们就可以洞悉 Go 语言内置数据结构的内部细节。

unsafe.Pointer

Pointer 代表着变量的内存地址，可以将任意变量的地址转换成 Pointer 类型，也可以将 Pointer 类型转换成任意的指针类型，它是不同指针类型之间互转的中间类型。Pointer 本身也是一个整型的值。

type Pointer int

图片

在 Go 语言里不同类型之间的转换是要受限的。普通的基础变量转换成不同的类型需要进行内存浅拷贝，而指针变量类型之间是禁止直接转换的。要打破这个限制，unsafe.Pointer 就可以派上用场，它允许任意指针类型的互转。

指针的加减运算

Pointer 虽然是整型的，但是编译器禁止它直接进行加减运算。如果要进行运算，需要将 Pointer 类型转换 uintptr 类型进行加减，然后再将 uintptr 转换成 Pointer 类型。uintptr 其实也是一个整型。

type uintptr int

图片

下面让我们就来尝试一下刚刚学到的魔法

package main

import "fmt"
import "unsafe"

type Rect struct {
    Width int
    Height int
}

func main() {
    var r = Rect {50, 50}
    // *Rect => Pointer => *int => int
    var width = *(*int)(unsafe.Pointer(&r))
    // *Rect => Pointer => uintptr => Pointer => *int => int
    var height = *(*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + uintptr(8)))
    fmt.Println(width, height)
}

------
50 50

package main

import "fmt"
import "unsafe"

type Rect struct {
    Width int
    Height int
}

func main() {
    var r = Rect {50, 50}
    // var pw *int
    var pw = (*int)(unsafe.Pointer(&r))
    // var ph *int
    var ph = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + uintptr(8)))
    *pw = 100
    *ph = 100
    fmt.Println(r.Width, r.Height)
}

--------
100 100

var ph = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&r)) + unsafe.Offsetof(r.Height))

探索切片内部结构

在切片小节，我们知道了切片分为切片头和内部数组两部分，下面我们使用 unsafe 包来验证一下切片的内部数据结构，看看它和我们预期的是否一样。

package main

import "fmt"
import "unsafe"

func main() {
    // head = {address, 10, 10}
    // body = [1,2,3,4,5,6,7,8,9,10]
    var s = []int{1,2,3,4,5,6,7,8,9,10}
    var address = (**[10]int)(unsafe.Pointer(&s))
    var len = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(8)))
    var cap = (*int)(unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + uintptr(16)))
    fmt.Println(address, *len, *cap)
    var body = **address
    for i:=0; i< len(body); i++ {
        fmt.Printf("%d ", body[i])
    }
}

------------------
0xc42000a080 10 10
1 2 3 4 5 6 7 8 9 10

图片

字符串与字节切片的高效转换

在字符串小节我们提到字节切片和字符串之间的转换需要复制内存，如果字符串或者字节切片的长度较大，转换起来会有较高的成本。下面我们通过 unsafe 包提供另一种高效的转换方法，让转换前后的字符串和字节切片共享内部存储。

图片

字符串和字节切片的不同点在于头部，字符串的头部 2 个 int 字节，切片的头部 3 个 int 字节

package main

import "fmt"
import "unsafe"

func main() {
    fmt.Println(bytes2str(str2bytes("hello")))
}

func str2bytes(s string) []byte {
    var strhead = *(*[2]int)(unsafe.Pointer(&s))
    var slicehead [3]int
    slicehead[0] = strhead[0]
    slicehead[1] = strhead[1]
    slicehead[2] = strhead[1]
    return *(*[]byte)(unsafe.Pointer(&slicehead))
}

func bytes2str(bs []byte) string {
    return *(*string)(unsafe.Pointer(&bs))
}

-----
hello

深入接口变量的赋值

在接口变量的小节，有一个问题还悬而未决，那就是接口变量在赋值时发生了什么？

图片

通过 unsafe 包，我们就可以看清里面的细节，下面我们将一个结构体变量赋值给接口变量，看看修改结构体的内存会不会影响到接口变量的数据内存

package main

import "fmt"
import "unsafe"

type Rect struct {
    Width int
    Height int
}

func main() {
    var r = Rect{50, 50}
    // {typeptr, dataptr}
    var s interface{} = r

    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    // var dataptr *Rect
    var sdataptr = sptrs[1]
    fmt.Println(sdataptr.Width, sdataptr.Height)

    // 修改原对象，看看接口指向的对象是否受到影响
    r.Width = 100
    fmt.Println(sdataptr.Width, sdataptr.Height)
}

-------
50 50
50 50

package main

import "fmt"
import "unsafe"

type Rect struct {
    Width int
    Height int
}

func main() {
    // {typeptr, dataptr}
    var s interface{} = Rect{50, 50}
    var r = s

    var rptrs = *(*[2]*Rect)(unsafe.Pointer(&r))
    var rdataptr = rptrs[1]
    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    var sdataptr = sptrs[1]

    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)

    // 修改原对象
    sdataptr.Width = 100
    // 再对比一下原对象和目标对象
    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)
}

-----------
50 50
50 50
100 50
100 50

package main

import "fmt"
import "unsafe"

type Areable interface {
    Area() int
}

type Rect struct {
    Width int
    Height int
}

func (r Rect) Area() int {
    return r.Width * r.Height
}

func main() {
    // {typeptr, dataptr}
    var s Areable = Rect{50, 50}
    var r interface{} = s

    var rptrs = *(*[2]*Rect)(unsafe.Pointer(&r))
    var rdataptr = rptrs[1]
    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    var sdataptr = sptrs[1]

    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)

    // 修改原对象
    sdataptr.Width = 100
    // 再对比一下原对象和目标对象
    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)
}

------
50 50
50 50
100 50
100 50

package main

import "fmt"
import "unsafe"

type Areable interface {
    Area() int
}

type Rect struct {
    Width int
    Height int
}

func (r Rect) Area() int {
    return r.Width * r.Height
}

func main() {
    // {typeptr, dataptr}
    var s interface{} = Rect{50, 50}
    var r Areable = s.(Areable)

    var rptrs = *(*[2]*Rect)(unsafe.Pointer(&r))
    var rdataptr = rptrs[1]
    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    var sdataptr = sptrs[1]

    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)

    // 修改原对象
    sdataptr.Width = 100
    // 再对比一下原对象和目标对象
    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(rdataptr.Width, rdataptr.Height)
}

------
50 50
50 50
100 50
100 50

package main

import "fmt"
import "unsafe"

type Areable interface {
    Area() int
}

type Rect struct {
    Width int
    Height int
}

func (r Rect) Area() int {
    return r.Width * r.Height
}

func main() {
    // {typeptr, dataptr}
    var s interface{} = Rect{50, 50}
    var r Rect = s.(Rect)

    var sptrs = *(*[2]*Rect)(unsafe.Pointer(&s))
    var sdataptr = sptrs[1]

    // 修改原对象
    sdataptr.Width = 100
    // 再对比一下原对象和目标对象
    fmt.Println(sdataptr.Width, sdataptr.Height)
    fmt.Println(r.Width, r.Height)
}

从上面 5 个 问题，我们可以得出结论，接口类型和结构体类型似乎是两个不同的世界。只有接口类型之间的赋值和转换会共享数据，其它情况都会复制数据，其它情况包括结构体之间的赋值，结构体转接口，接口转结构体。不同接口变量之间的转换本质上只是调整了接口变量内部的类型指针，数据指针并不会发生改变。

通过 unsafe 包我们还可以分析很多细节，在高级内容部分，我们将会频繁使用这个工具。

扫一扫二维码，订阅《快学 Go 语言》更多内容