作用

  • 一般我们在C语言中通过指针，在知道变量在内存中占用的字节数情况下，就可以通过指针加偏移量的操作，直接在地址中，修改，访问变量的值。在 Go 语言中不支持指针运算，那怎么办呢？其实通过unsafe包，我们可以完成类似的操作。
  • golang是一种静态的强类型的语言，所有的类型都是不能随意转换的，Go语言是不允许两个指针类型进行转换的。
  • go官方是不推荐使用unsafe的操作因为它是不安全的，它绕过了golang的内存安全原则，容易使你的程序出现莫名其妙的问题，不利于程序的扩展与维护。但是在很多地方却是很实用。在一些go底层的包中unsafe包被很频繁的使用。

unsafe 定义

在unsafe包中，只提供了3个函数，两个类型。就这么少的量，却有着超级强悍的功能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
package unsafe

// ArbitraryType仅用于文档目的，实际上并不是unsafe包的一部分,它表示任意Go表达式的类型。
// ArbitraryType 是以int为基础定义的一个新类型，但是 Go 语言unsafe包中，对ArbitraryType赋予了特殊的意义，
// 通常，我们把interface{}看作是任意类型，那么ArbitraryType这个类型，在 Go 语言系统中，比interface{}还要随意。
type ArbitraryType int

// 任意类型的指针，类似于C的*void
// Pointer 是ArbitraryType指针类型为基础的新类型，可以把Pointer类型理解成任何指针的亲爹。
type Pointer *ArbitraryType

// 确定结构在内存中占用的确切大小
// 返回变量在内存中占用的字节数，
// 切记，如果是slice，则不会返回这个slice在内存中的实际占用长度。
func Sizeof(x ArbitraryType) uintptr

// 返回结构体中某个field的偏移量
// 返回变量指定属性的偏移量，
// 所以如果变量是一个struct类型，不能直接将这个struct类型的变量当作参数，只能将这个struct类型变量的属性当作参数。
func Offsetof(x ArbitraryType) uintptr

// 返回结构体中某个field的对其值（字节对齐的原因）
// 返回变量对齐字节数量
func Alignof(x ArbitraryType) uintptr

其它的unsafe包的go代码去哪里了？答案很简单：当你import到你程序里的时候，Go编译器实现了这个unsafe库。

许多系统库，例如runtime,syscall和os会经常使用到usafe库

官方中定义了四个描述：

  1. 任何类型的指针都可以被转化为Pointer
  2. Pointer可以被转化为任何类型的指针
  3. uintptr可以被转化为Pointer
  4. Pointer可以被转化为uintptr

unsafe中，通过ArbitraryType 、Pointer 这两个类型，可以将其他类型都转换过来，然后通过这三个函数，分别能取长度，偏移量，对齐字节数，就可以在内存地址映射中，来回游走。

事实上，一般在GO里使用的指针的完整称呼应该为类型安全指针。 虽然类型安全指针有助于我们轻松写出安全的代码，但是有时候施加在类型安全指针上的限制也确实导致我们不能写出最高效的代码。

1
type Pointer *ArbitraryType

这里的ArbitraryType仅仅是暗示**unsafe.Pointer类型值可以被转换为任意类型安全指针（反之亦然）**。

换句话说，unsafe.Pointer类似于C语言中的void*。

非类型安全指针是指底层类型为unsafe.Pointer的类型。非类型安全指针的零值也使用预声明的nil标识符来表示。

unsafe.Sizeof函数

Sizeof函数返回操作数在内存中的字节大小（返回该类型所占用的内存大小），参数可以是任意类型的表达式，但是它并不会对表达式进行求值。

一个 Sizeof 函数调用是一个对应 uintptr 类型的常量表达式，因此返回的结果可以用作数组类型的长度大小，或者用作计算其他的常量。

Sizeof函数可以返回一个类型所占用的内存大小，这个大小只有类型有关，和类型对应的变量存储的内容大小无关，比如bool型占用一个字节、int8也占用一个字节。

1
2
3
4
5
6
7
8
9
10
11
12
import "unsafe" 

func main() {
  fmt.Println(unsafe.Sizeof("true"))                // 16
	fmt.Println(unsafe.Sizeof(true))                  // 1
	fmt.Println(unsafe.Sizeof(int8(0)))               // 1
	fmt.Println(unsafe.Sizeof(int16(10)))             // 2
	fmt.Println(unsafe.Sizeof(int32(10000000)))       // 4
	fmt.Println(unsafe.Sizeof(int64(10000000000000))) // 8
	fmt.Println(unsafe.Sizeof(int(1)))                // 8
	fmt.Println(unsafe.Sizeof(float64(0)))            // 8
}

对于整型来说，占用的字节数意味着这个类型存储数字范围的大小，比如int8占用一个字节，也就是8bit，所以它可以存储的大小范围是-128~~127,也就是−2^(n-1)到2^(n-1)−1，n表示bit，int8表示8bit，int16表示16bit，其他以此类推。

对于和平台有关的int类型，这个要看平台是32位还是64位，会取最大的。比如我自己测试，以上输出，会发现int和int64的大小是一样的，因为我的是64位平台的电脑。

1
func Sizeof(x ArbitraryType) uintptr

以上是Sizeof的函数定义，它接收一个ArbitraryType类型的参数，返回一个uintptr类型的值。这里的ArbitraryType不用关心，他只是一个占位符，为了文档的考虑导出了该类型，但是一般不会使用它，我们只需要知道它表示任何类型，也就是我们这个函数可以接收任意类型的数据。

1
2
3
 // ArbitraryType is here for the purposes of documentation only and is not actually
// part of the unsafe package. It represents the type of an arbitrary Go expression.
type ArbitraryType int

Alignof 函数

Alignof返回一个类型的对齐值，也可以叫做对齐系数或者对齐倍数。对齐值是一个和内存对齐有关的值，合理的内存对齐可以提高内存读写的性能。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
func main() {
  var b bool
	var i8 int8
	var i16 int16
	var i64 int64

	var f32 float32

	var s string

	var m map[string]string

	var p *int32

	fmt.Println(unsafe.Alignof(b))   // 1
	fmt.Println(unsafe.Alignof(i8))  // 1
	fmt.Println(unsafe.Alignof(i16)) // 2
	fmt.Println(unsafe.Alignof(i64)) // 8
	fmt.Println(unsafe.Alignof(f32)) // 4
	fmt.Println(unsafe.Alignof(s))   // 8
	fmt.Println(unsafe.Alignof(m))   // 8
	fmt.Println(unsafe.Alignof(p))   // 8
}

从以上例子的输出，可以看到，对齐值一般是2^n,最大不会超过8（原因见下面的内存对齐规则）。Alignof的函数定义和Sizeof基本上一样。这里需要注意的是每个人的电脑运行的结果可能不一样，大同小异。

1
func Alignof(x ArbitraryType) uintptr

获取对齐值还可以使用反射包的函数，也就是说：unsafe.Alignof(x)等价于reflect.TypeOf(x).Align()。

Offsetof 函数

Offsetof函数只适用于struct结构体中的字段相对于结构体的内存位置偏移量。结构体的第一个字段的偏移量都是0。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
func main() {
	var u1 user1

	fmt.Println(unsafe.Offsetof(u1.b)) // 0
	fmt.Println(unsafe.Offsetof(u1.i)) // 4
	fmt.Println(unsafe.Offsetof(u1.j)) // 8
	fmt.Println(unsafe.Sizeof(u1))     // 16

}


type user1 struct {
	b byte
	i int32
	j int64
}

字段的偏移量，就是该字段在struct结构体内存布局中的起始位置(内存位置索引从0开始)。

根据字段的偏移量，我们可以定位结构体的字段，进而可以读写该结构体的字段，哪怕他们是私有的。这里可以直接用汇编获取对应偏移量的字段值。

同样也可以用反射表示：

unsafe.Offsetof(u1.i) 等价于 reflect.TypeOf(u1).Field(i).Offset

unsafe的使用

类型转换

使用unsafe可以实现类型的转换，下面的例子可以看到i是一个int类型，使用unsafe.Pointer转换成float64并且还修改了指针对应的值。

1
2
3
4
5
6
7
8
9
10
func main() {
    i := 10
    ip := &i

    fp := (*float64)(unsafe.Pointer(ip))
    *fp = *fp * 3
    fmt.Println(i)
}

// 结果： 30

但是使用起来要十分的小心，如果使用不当会引发错误。可以举一个例子：

1
2
3
4
5
6
7
8
9
func main() {
    i := 10
    ip := &i

    fp := (*string)(unsafe.Pointer(ip))
    *fp = "a"
    fmt.Println(i)
    // 结果：19678090
}

上面的误操作就是把int类型转成了string，并且修改了值导致结果出现了错误，并且这种错误

根据位移获取、修改对象的字段

利用unsafe的Pointer和Offsetof函数，可以获取对象的属性，并且可以修改对象的属性

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
type Student struct {
    Name string
    Age  int
}

func main() {
    s := Student{}
    s.Name = "Peter"
    s.Age = 33

    pStudent := unsafe.Pointer(&s)
    // 整个对象转换成指针，默认是获取第一个属性
    name := (*string)(unsafe.Pointer(pStudent))
    fmt.Println("name:", *name) // name: Peter
  
    // 利用Offsetof获取age属性的偏移量获取属性
    age := (*int)(unsafe.Pointer(uintptr(pStudent) + unsafe.Offsetof(s.Age)))
    fmt.Println("age:", *age) // age: 33
    
    // 修改指针的值
    *name = "Mary"
    *age = 20
    fmt.Println(s) // {Mary 20}
}

获取私有变量

可以通过unsafe获取私有变量的值，也可以修改值。这个操作跟上面的获取值是一样的简单的例子如下：

1
2
3
4
5
6
7
8
9
10
11
12
type Teacher struct {
    name string
    age  int
}

func main() {
    t := Teacher{"ttt", 20}

    pt := unsafe.Pointer(&t)
    name := (*string)(unsafe.Pointer(pt))
    fmt.Println("name:", *name) // name: ttt
}

根据sizeof函数获取、修改

利用unsafe中的sizeof函数获取数组的值

1
2
3
4
5
6
7
8
9
10
11
func main() {
    array := []int{0, 1, -2, 3, 4}
    pointer := &array[0]
    fmt.Print(*pointer, " ") // 0
    memoryAddress := uintptr(unsafe.Pointer(pointer)) + unsafe.Sizeof(array[0])
    for i := 0; i < len(array)-1; i++ {
        pointer = (*int)(unsafe.Pointer(memoryAddress))
        fmt.Print(*pointer, " ") // 1 -2 3 4 
        memoryAddress = uintptr(unsafe.Pointer(pointer)) + unsafe.Sizeof(array[0])
    }
}
  1. 首先，pointer变量指向array[0]的地址，array[0]是整型数组的第一个元素。
  2. 接下来指向整数值的pointer变量会传入unsafe.Pointer()方法，然后传入uintptr。最后结果存到了memoryAddress里。
  3. unsafe.Sizeof(array[0])是为了去访问下一个数组元素，这个值是每个元素占的内存大小。每次for循环遍历，都会把这个值加到memoryAddress上，这样就能获取到下一个数组元素的地址。*pointer的*符号对指针进行解引用，然后返回了所存的整数值。

内存对齐详解

struct 字段顺序不同，最终大小可能不同

1
2
3
4
5
6
7
type Part1 struct {
    a bool
    b int32
    c int8
    d int64
    e byte
}

来看一下 Part1 共占用的大小是多少呢？

1
2
3
4
5
6
7
8
func main() {
    fmt.Printf("bool size: %d\n", unsafe.Sizeof(bool(true))) // bool size: 1
    fmt.Printf("int32 size: %d\n", unsafe.Sizeof(int32(0))) // int32 size: 4
    fmt.Printf("int8 size: %d\n", unsafe.Sizeof(int8(0))) // int8 size: 1
    fmt.Printf("int64 size: %d\n", unsafe.Sizeof(int64(0))) // int64 size: 8
    fmt.Printf("byte size: %d\n", unsafe.Sizeof(byte(0))) // byte size: 1
    fmt.Printf("string size: %d\n", unsafe.Sizeof("EDDYCJY")) // string size: 16
}

然后你也许就会得出这个结果：

Part1 这一个结构体的占用内存大小为 1+4+1+8+1 = 15 个字节。相信有的小伙伴是这么算的，看上去也没什么毛病

但是实际答案却是：

1
2
3
4
5
6
7
8
9
10
11
12
type Part1 struct {
    a bool
    b int32
    c int8
    d int64
    e byte
}

func main() {
    part1 := Part1{}
    fmt.Printf("part1 size: %d, align: %d\n", unsafe.Sizeof(part1), unsafe.Alignof(part1))
}

输出结果：

1
part1 size: 32, align: 8

最终输出为占用 32 个字节。这与前面所预期的结果完全不一样。这充分地说明了先前的计算方式是错误的。为什么呢？

在这里要提到 “内存对齐” 这一概念，才能够用正确的姿势去计算，接下来我们详细的讲讲它是什么

内存对齐

有的小伙伴可能会认为内存读取，就是一个简单的字节数组摆放

image

上图表示一个坑一个萝卜的内存读取方式。但实际上 CPU 并不会以一个一个字节去读取和写入内存。

相反 CPU 读取内存是一块一块读取的，块的大小可以为 2、4、6、8、16 字节等大小。块大小我们称其为内存访问粒度。如下图：

image

在样例中，假设访问粒度为 4。 CPU 是以每 4 个字节大小的访问粒度去读取和写入内存的。这才是正确的姿势

为什么要关心对齐？

  • 你正在编写的代码在性能（CPU、Memory）方面有一定的要求
  • 你正在处理向量方面的指令
  • 某些硬件平台（ARM）体系不支持未对齐的内存访问

为什么要做对齐

  • 平台（移植性）原因：不是所有的硬件平台都能够访问任意地址上的任意数据。例如：特定的硬件平台只允许在特定地址获取特定类型的数据，否则会导致异常情况
  • 性能原因：若访问未对齐的内存，将会导致 CPU 进行两次内存访问，并且要花费额外的时钟周期来处理对齐及运算。而本身就对齐的内存仅需要一次访问就可以完成读取动作

image

在上图中，假设从 Index 1 开始读取，将会出现很崩溃的问题。因为它的内存访问边界是不对齐的。因此 CPU 会做一些额外的处理工作。如下：

  • CPU 首次读取未对齐地址的第一个内存块，读取 0-3 字节。并移除不需要的字节 0
  • CPU 再次读取未对齐地址的第二个内存块，读取 4-7 字节。并移除不需要的字节 5、6、7 字节
  • 合并 1-4 字节的数据
  • 合并后放入寄存器

从上述流程可得出，不做 “内存对齐” 是一件有点 “麻烦” 的事。因为它会增加许多耗费时间的动作

而假设做了内存对齐，从 Index 0 开始读取 4 个字节，只需要读取一次，也不需要额外的运算。这显然高效很多，是标准的空间换时间做法。

CPU看待内存是以block为单位的，就像是linux下文件大小的单位IO block为4096一样，是一种牺牲空间换取时间的做法.

image-20210604170227503

默认对齐系数

在不同平台上的编译器都有自己默认的 “对齐系数”，可通过预编译命令 #pragma pack(n) 进行变更，n 就是代指 “对齐系数”。一般来讲，我们常用的平台的系数如下：

  • 32 位：4
  • 64 位：8

另外要注意，不同硬件平台占用的大小和对齐值都可能是不一样的。因此本文的值不是唯一的，调试的时候需按本机的实际情况考虑

成员对齐

1
2
3
4
5
6
7
8
9
func main() {
    fmt.Printf("bool align: %d\n", unsafe.Alignof(bool(true))) // bool align: 1
    fmt.Printf("int32 align: %d\n", unsafe.Alignof(int32(0))) // int32 align: 4
    fmt.Printf("int8 align: %d\n", unsafe.Alignof(int8(0))) // int8 align: 1
    fmt.Printf("int64 align: %d\n", unsafe.Alignof(int64(0))) // int64 align: 8
    fmt.Printf("byte align: %d\n", unsafe.Alignof(byte(0))) // byte align: 1
    fmt.Printf("string align: %d\n", unsafe.Alignof("EDDYCJY")) // string align: 8
    fmt.Printf("map align: %d\n", unsafe.Alignof(map[string]string{})) // map align: 8
}

关于 unsafe.Alignof 是用来来返回相应类型的对齐系数，上面已经说了。

通过观察输出结果，可得知基本都是 2^n，最大也不会超过 8。这是因为我本机（64 位）编译器默认对齐系数是 8，因此最大值不会超过这个数

整体对齐 （结构体本身也要对齐）

上面提到了结构体中的成员变量要做字节对齐。那么想当然身为最终结果的结构体，也是需要做字节对齐的。

对齐规则

  • 结构体的成员变量，第一个成员变量的偏移量为 0。往后的每个成员变量的对齐值必须为编译器默认对齐长度（#pragma pack(n)）或当前成员变量类型的长度（unsafe.Sizeof），取最小值作为当前类型的对齐值。其偏移量必须为对齐值的整数倍
  • 结构体本身，对齐值必须为编译器默认对齐长度（#pragma pack(n)）或结构体的所有成员变量类型中的最大长度，取最大数的最小整数倍作为对齐值
  • 结合以上两点，可得知若编译器默认对齐长度（#pragma pack(n)）超过结构体内成员变量的类型最大长度时，默认对齐长度是没有任何意义的

换个说法就是：

  • 对于具体类型来说，对齐值=min(编译器默认对齐值，类型大小Sizeof长度)。也就是在默认设置的对齐值和类型的内存占用大小之间，取最小值为该类型的对齐值。我的电脑默认是8，所以最大值不会超过8.
  • struct在每个字段都内存对齐之后，其本身也要进行对齐，对齐值=min(默认对齐值，字段最大类型长度)。这条也很好理解，struct的所有字段中，最大的那个类型的长度以及默认对齐值之间，取最小的那个。

分析流程

1
2
3
4
5
6
7
type Part1 struct {
    a bool
    b int32
    c int8
    d int64
    e byte
}
成员变量 类型 偏移量 自身占用
a bool 0 1
字节对齐 无 1 3
b int32 4 4
c int8 8 1
字节对齐 无 9 7
d int64 16 8
e byte 24 1
字节对齐 无 25 7
总占用大小 - - 32
  • 第一个成员 a
    • 类型为 bool
    • 对齐值为 1 字节
    • 初始地址，偏移量为 0。占用了第 1 位
  • 第二个成员 b
    • 类型为 int32
    • 大小/对齐值为 4 字节
    • 根据规则 1，其偏移量必须为 4 的整数倍。确定偏移量为 4，因此 2-4 位为 Padding。而当前数值从第 5 位开始填充，到第 8 位。如下：axxx|bbbb
  • 第三个成员 c
    • 类型为 int8
    • 大小/对齐值为 1 字节
    • 根据规则1，其偏移量必须为 1 的整数倍。当前偏移量为 8。不需要额外对齐，填充 1 个字节到第 9 位。如下：axxx|bbbb|c…
  • 第四个成员 d
    • 类型为 int64
    • 大小/对齐值为 8 字节
    • 根据规则 1，其偏移量必须为 8 的整数倍。确定偏移量为 16，因此 9-16 位为 Padding。而当前数值从第 17 位开始写入，到第 24 位。如下：axxx|bbbb|cxxx|xxxx|dddd|dddd
  • 第五个成员 e
    • 类型为 byte
    • 大小/对齐值为 1 字节
    • 根据规则 1，其偏移量必须为 1 的整数倍。当前偏移量为 24。不需要额外对齐，填充 1 个字节到第 25 位。如下：axxx|bbbb|cxxx|xxxx|dddd|dddd|e…

整体对齐：

在每个成员变量进行对齐后，根据规则 2，整个结构体本身也要进行字节对齐，因为可发现它可能并不是 2^n，不是偶数倍。显然不符合对齐的规则

根据规则 2，可得出对齐值为 8。现在的偏移量为 25，不是 8 的整倍数。因此确定偏移量为 32。对结构体进行对齐

结果：

Part1 内存布局：axxx|bbbb|cxxx|xxxx|dddd|dddd|exxx|xxxx

其中xxx表示为 “内存空洞”。

内存空洞可能会存在一些随机数据，可能会对用unsafe包直接操作内存的处理产生影响

推论字段顺序可改变结构体大小

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
type Part1 struct {
    a bool
    b int32
    c int8
    d int64
    e byte
}

type Part2 struct {
    e byte
    c int8
    a bool
    b int32
    d int64
}

func main() {
    part1 := Part1{}
    part2 := Part2{}

    fmt.Printf("part1 size: %d, align: %d\n", unsafe.Sizeof(part1), unsafe.Alignof(part1))
    fmt.Printf("part2 size: %d, align: %d\n", unsafe.Sizeof(part2), unsafe.Alignof(part2))
}


// part1 size: 32, align: 8
// part2 size: 16, align: 8

分析过程和上面完全一样。

image-20210604170848857

根据上图，我们就明白了，在结构体编写中存在内存对齐的概念，而且我们应该小心，尽可能的避免因内存对齐导致结构体大小增大，在书写过程中应该让小字节的变量挨着。

示例：修改struct成员

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
package main

import (
	"fmt"
	"testing"
	"unsafe"
)

type V struct {
	i int32
	j int64
}

func (v V) GetI() {
	fmt.Printf("i=%d\n", v.i)
}
func (v V) GetJ() {
	fmt.Printf("j=%d\n", v.j)
}

func TestUnsafe2(t *testing.T) {
	// 定义指针类型变量
	var v *V = &V{199, 299}

	// 取得v的指针并转为*int32的值，对应结构体的i。
	var i *int32 = (*int32)(unsafe.Pointer(v))

	fmt.Println("指针地址：", i) // 指针地址： 0xc00000c180
	fmt.Println("指针uintptr值:", uintptr(unsafe.Pointer(i))) // 指针uintptr值: 824633770368
	*i = int32(98)

	// 根据v的基准地址加上偏移量进行指针运算，运算后的值为j的地址，使用unsafe.Pointer转为指针
	var j *int64 = (*int64)(
		unsafe.Pointer(
			uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Sizeof(int64(0))),
		),
	)

	*j = int64(763)

	v.GetI() // i=98
	v.GetJ() // j=763
}
  • 要修改struct字段的值，需要提前知道结构体V的成员布局，然后根据字段计算偏移量，以及考虑对齐值，最后通过指针运算得到成员指针，利用指针达到修改成员值得目的。
  • 由于结构体的成员在内存中的分配是一段连续的内存，因此结构体中第一个成员的地址就是这个结构体的地址，我们也可以认为是相对于这个结构体偏移了0。相同的，这个结构体中的任一成员都可以相对于这个结构体的偏移来计算出它在内存中的绝对地址。

具体来讲解下main方法的实现：

1
var v *V = &V{199, 299}

通过&来分配一段内存(并按类型初始化)，返回一个指针。所以v就是类型为V的一个指针。和new函数的作用类似。

1
var i *int32 = (*int32)(unsafe.Pointer(v))

将指针v转成通用指针，再转成int32指针类型。这里就看到了unsafe.Pointer的作用了，您不能直接将v转成int32类型的指针，那样将会panic，但是unsafe.Pointer是可以转为任何指针。

刚才说了v的地址其实就是它的第一个成员的地址，所以这个i就很显然指向了v的成员i，通过给i赋值就相当于给v.i赋值了，但是别忘了i只是个指针，要赋值得解引用。

1
*i = int32(98)

现在已经成功的改变了v的私有成员i的值。

但是对于v.j来说，怎么来得到它在内存中的地址呢？其实我们可以获取它相对于v的偏移量(unsafe.Sizeof可以为我们做这个事)，但上面的代码并没有这样去实现。各位别急，一步步来。

1
2
3
4
5
var j *int64 = (*int64)(
  unsafe.Pointer(
    uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Sizeof(int64(0))),
  ),
)

其实我们已经知道v是有两个成员的，包括i和j，并且在定义中，i位于j的前面，而i是int32类型，也就是说i占4个字节。所以j是相对于v偏移了4个字节。您可以用uintptr(4)或uintptr(unsafe.Sizeof(int64(0)))来做这个事。unsafe.Sizeof方法用来得到一个值应该占用多少个字节空间。注意这里跟C的用法不一样，C是直接传入类型，而Go 语言是传入值。

之所以转成uintptr类型是因为需要做指针运算。v的地址加上j相对于v的偏移地址，也就得到了v.j在内存中的绝对地址，然后通过unsafe.Pointer转为指针，别忘了j的类型是int64，所以现在的j就是一个指向v.j的指针，接下来给它赋值：

1
*j = int64(763)

另外，我们可以看到两种地址表示上的差异：

1
2
指针地址： 0xc00000c180
指针uintptr值: 824633770368

示例：修改struct成员2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
package main

import (
    "fmt"
    "unsafe"
)

func main() {
    s := struct {
        a byte
        b byte
        c byte
        d int64
    }{0, 0, 0, 0}

    // 将结构体指针转换为通用指针
    p := unsafe.Pointer(&s)
    // 保存结构体的地址备用（偏移量为 0）
    up0 := uintptr(p)
    // 将通用指针转换为 byte 型指针
    pb := (*byte)(p)
    // 给转换后的指针赋值
    *pb = 10
    // 结构体内容跟着改变
    fmt.Println(s)

    // 偏移到第 2 个字段
    up := up0 + unsafe.Offsetof(s.b)
    // 将偏移后的地址转换为通用指针
    p = unsafe.Pointer(up)
    // 将通用指针转换为 byte 型指针
    pb = (*byte)(p)
    // 给转换后的指针赋值
    *pb = 20
    // 结构体内容跟着改变
    fmt.Println(s)

    // 偏移到第 3 个字段
    up = up0 + unsafe.Offsetof(s.c)
    // 将偏移后的地址转换为通用指针
    p = unsafe.Pointer(up)
    // 将通用指针转换为 byte 型指针
    pb = (*byte)(p)
    // 给转换后的指针赋值
    *pb = 30
    // 结构体内容跟着改变
    fmt.Println(s)

    // 偏移到第 4 个字段
    up = up0 + unsafe.Offsetof(s.d)
    // 将偏移后的地址转换为通用指针
    p = unsafe.Pointer(up)
    // 将通用指针转换为 int64 型指针
    pi := (*int64)(p)
    // 给转换后的指针赋值
    *pi = 40
    // 结构体内容跟着改变
    fmt.Println(s)
}

示例：struct对齐值

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
package main

import (
    "fmt"
    "unsafe"
)

type V struct {
    b byte
    i int32
    j int64
}

func (v V) GetI() {
    fmt.Printf("i=%d\n", v.i)
}
func (v V) GetJ() {
    fmt.Printf("j=%d\n", v.j)
}

func main() {
    // 定义指针类型变量
    var v *V = new(V)

    // v的长度
    fmt.Printf("size=%d\n", unsafe.Sizeof(*v)) // size=16
  
    // 取得v的指针考虑对齐值计算偏移量，然后转为*int32的值，对应结构体的i。
    var i *int32 = (*int32)(
    	unsafe.Pointer(
      	uintptr(unsafe.Pointer(v)) + uintptr(4*unsafe.Sizeof(byte(0)))
      )
    )

    fmt.Println("指针地址：", i) // 指针地址： 0xc000050084
    fmt.Println("指针uintptr值:", uintptr(unsafe.Pointer(i))) // 指针uintptr值: 824634048644
    *i = int32(98)

    // 根据v的基准地址加上偏移量进行指针运算，运算后的值为j的地址，使用unsafe.Pointer转为指针
    var j *int64 = (*int64)(
    	unsafe.Pointer(
      	uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Sizeof(int64(0)))
      )
    )

    *j = int64(763)
    fmt.Println("指针uintptr值:", uintptr(unsafe.Pointer(&v.b))) // 指针uintptr值: 824634048640
    fmt.Println("指针uintptr值:", uintptr(unsafe.Pointer(&v.i))) // 指针uintptr值: 824634048644
    fmt.Println("指针uintptr值:", uintptr(unsafe.Pointer(&v.j))) // 指针uintptr值: 824634048648
    v.GetI() // i=98
    v.GetJ() // j=763
}

新结构体的长度为size=16，好像跟我们想像的不一致。我们计算一下：b是byte类型，占1个字节；i是int32类型，占4个字节；j是int64类型，占8个字节，1+4+8=13。这是怎么回事呢？

这是因为发生了对齐。在struct中，它的对齐值是它的成员中的最大对齐值。

每个成员类型都有它的对齐值，可以用unsafe.Alignof方法来计算，比如unsafe.Alignof(v.b)就可以得到b的对齐值为1 。但这个对齐值是其值类型的长度或引用的地址长度（32位或者64位），和其在结构体中的size不是简单相加的问题。经过在64位机器上测试，发现地址（uintptr）如下：

1
2
3
unsafe.Pointer(b): %s 824634048640
unsafe.Pointer(i): %s 824634048644
unsafe.Pointer(j): %s 824634048648

可以初步推断，也经过测试验证，取i值使用uintptr(4*unsafe.Sizeof(byte(0)))是准确的。至于size其实也和对齐值有关，也不是简单相加每个字段的长度。

unsafe.Offsetof 可以在实际中使用，如果改变私有的字段，需要程序员认真考虑后，按照上面的方法仔细确认好对齐值再进行操作。

示例：配合reflect

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
package main

import (
    "fmt"
    "reflect"
    "strings"
    "unsafe"
)

func main() {
    // 创建一个 strings 包中的 Reader 对象
    // 它有三个私有字段：s string、i int64、prevRune int
    sr := strings.NewReader("abcdef")
    // 此时 sr 中的成员是无法修改的
    fmt.Println(sr)
    // 但是我们可以通过 unsafe 来进行修改
    // 先将其转换为通用指针
    p := unsafe.Pointer(sr)
    // 获取结构体地址
    up0 := uintptr(p)
    // 确定要修改的字段（这里不能用 unsafe.Offsetof 获取偏移量，因为是私有字段）
    if sf, ok := reflect.TypeOf(*sr).FieldByName("i"); ok {
        // 偏移到指定字段的地址
        up := up0 + sf.Offset
        // 转换为通用指针
        p = unsafe.Pointer(up)
        // 转换为相应类型的指针
        pi := (*int64)(p)
        // 对指针所指向的内容进行修改
        *pi = 3 // 修改索引
    }
    // 看看修改结果
    fmt.Println(sr)
    // 看看读出的是什么
    b, err := sr.ReadByte()
    fmt.Printf("%c, %v\n", b, err)
}