go - 为什么我得到 j 0 而不是 777

Question

package main

import (
    "fmt"
    "unsafe"
)

type V struct {
    i int32
    j int64
}

func (v *V) PrintI() {
    fmt.Println(v.i)
}
func (v *V) PrintJ() {
    fmt.Println(v.j)
}

func main() {
    v := new(V)
    iPointer := (*int32)(unsafe.Pointer(v))
    *iPointer = int32(666)
    v.PrintI()
    jPointer := (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Sizeof(int32(0)))))
    *jPointer = int64(777)
    v.PrintJ()
}

我从 [ https://studygolang.com/articles/1414] 获得示例代码，我想不通为什么我总是得到j的值为0。

Answer 1

TL;DR:使用 unsafe.Offsetof() 而不是 unsafe.Sizeof()。参见 Purpose of memory alignment获取更多信息。

结构中的字段(甚至变量)不一定立即出现 在内存中一个接一个。这是可能的，由于如何存在差距 数据类型对齐。这种对齐方式因单词大小和 数据类型的大小。

在您的示例中，您尝试使用指针算法访问 v.j 将 v.i 的大小(即 4 个字节)添加到 v.i 的指针。这将 碰巧在 32 位系统上工作正常，因为那里的字长是 4 个字节 下一个字段 v.j 将在内存中对齐到 4 个字节。尝试一下 在执行程序之前设置环境变量 GOARCH=386 (386 是 32 位架构)。

虽然在 64 位系统上，v.j 将在内存中对齐到 8 个字节，以便 处理器可以一次从内存中获取整个 8 字节字段。如果它是 没有对齐到 8 个字节(字的大小)，它需要两次提取才能得到 整个值，因为它将存储在两个不同的词中。结果，&v.i + 4 字节处的值不是起点 v.j 的。相反，它指向一个未分配给任何字段的内存区域，因此 v.j 实际上没有被修改。

不过，正确的做法是让 Go 为您提供位置信息 v.j 使用 unsafe.Offsetof(v.j) 在内存中启动。然后您可以存储一个 该位置的 int64 值。

这里是您的代码的一个略微修改版本，用于演示该问题。它 打印结构中每个字节的十六进制值。

// Slightly modified original code to print all the bytes in the struct
package main

import (
    "fmt"
    "unsafe"
)

type V struct {
    i int32
    j int64
}

func (v *V) PrintI() {
    fmt.Println(v.i)
}
func (v *V) PrintJ() {
    fmt.Println(v.j)
}

// PrintStruct prints every byte in the struct individually
func (v *V) PrintStruct() {
    for i := uintptr(0); i < unsafe.Sizeof(*v); i++ {
        b := (*byte)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + i))
        fmt.Printf("%2d %02x\n", i, *b)
    }
}

func main() {
    v := new(V)
    iPointer := (*int32)(unsafe.Pointer(v))
    // Use hex values so they're easy to see in the output
    *iPointer = int32(0x01020304) // 4 bytes
    jPointer := (*int64)(unsafe.Pointer(uintptr(unsafe.Pointer(v)) + uintptr(unsafe.Sizeof(int32(0)))))
    *jPointer = int64(0x08090A0B0C0D0E0F) // 8 bytes

    fmt.Println("Assign using offset Sizeof")
    v.PrintStruct()
    fmt.Println("")

    v = new(V)
    v.i = 0x01020304
    v.j = 0x08090A0B0C0D0E0F
    fmt.Println("Assign directly to the fields")
    v.PrintStruct()
}

这是我在以小端顺序存储数据的 64 位机器上运行时得到的输出:

Assign using offset Sizeof
 0 04
 1 03
 2 02
 3 01
 4 0f
 5 0e
 6 0d
 7 0c
 8 0b
 9 0a
10 09
11 08
12 00
13 00
14 00
15 00

Assign directly to the fields
 0 04
 1 03
 2 02
 3 01
 4 c0
 5 00
 6 00
 7 00
 8 0f
 9 0e
10 0d
11 0c
12 0b
13 0a
14 09
15 08

注意值是如何分配给不同的(不正确的)位置的 使用尝试将值存储在大小的偏移量时的内存 int32。将 unsafe.Sizeof(int32(0)) 更改为 unsafe.Offsetof(v.j) 并且 应该会给你正确的结果。