空结构片的地址

Question

我有一个关于empty struct的基本问题，试图在尝试获取两个切片的后备数组元素的地址时得到以下不同的输出：

a := make([]struct{}, 10)
b := make([]struct{}, 20)
fmt.Println("&a == &b", &a == &b)
fmt.Println("&a[0] == &b[0]", &a[0] == &b[0])

上面的代码片段返回 ：

&a == &b false
&a[0] == &b[0] true

但是，请考虑以下略有变化的代码段：

a := make([]struct{}, 10)
b := make([]struct{}, 20)
fmt.Println(a[0], &a[0])
fmt.Println("&a == &b", &a == &b)
fmt.Println("&a[0] == &b[0]", &a[0] == &b[0])

上面的代码片段返回 ：

{} &{}
&a == &b false
&a[0] == &b[0] false

有人可以解释上述差异的原因吗？ 谢谢！

[跟进]进行以下修改：

package main

import "fmt"

type S struct{}

func (s *S) addr() { fmt.Printf("%p\n", s) }

func main() {
    a := make([]S, 10)
    b := make([]S, 20)
    fmt.Println(a[0], &a[0])
    fmt.Println("&a == &b", &a == &b)
    fmt.Println("&a[0] == &b[0]", &a[0] == &b[0])
    //a[0].addr()
    //b[0].addr()
}

仍返回相同的输出：

{} &{}
&a == &b false
&a[0] == &b[0] false

尽管取消注释方法调用，但返回 ：

{} &{}
&a == &b false
&a[0] == &b[0] true
0x19583c // ==> [depends upon env]
0x19583c // ==> [depends upon env]

Answer 1

一个空结构基本上是：几乎没有。 大小为0：

var s struct{}
fmt.Println(unsafe.Sizeof(s))

返回0 。

现在，为什么两个空结构的地址有时相同而有时却不同，这取决于内部结构。 我们唯一可以得到的线索是从规范 ：

如果结构或数组类型不包含大小大于零的字段（或元素），则其大小为零。 两个不同的零大小变量在内存中可能具有相同的地址。

另请注意以下代码，将第一个打印移到最后一个：

fmt.Println("&a == &b", &a == &b)
fmt.Println("&a[0] == &b[0]", &a[0] == &b[0])
fmt.Println(a[0], &a[0])

输出：

&a == &b false
&a[0] == &b[0] false
{} &{}

或与您的第二种情况相同。 基本上，这表明编译器选择使用其他地址。 给定“可能在内存中具有相同的地址”，您不应依赖于相等性，因为确切的行为取决于go内部结构，并且随时可能更改。

为了进一步阅读，我推荐这篇关于空结构的优秀文章 。

Answer 2

在深入研究之前，请了解根据规范，程序对于大小为零的值产生的地址是否相等或不同，都是正确的，因为规范仅声明它们可以相同，但不要求它们是相同的。相同。

规格：尺寸和对齐方式保证：

如果结构或数组类型不包含大小大于零的字段（或元素），则其大小为零。 两个不同的零大小变量在内存中可能具有相同的地址。

因此，您所体验的是实现细节。 有关决策的更多细节和因素，以下解释仅对您的具体示例有效并足够：

在您的第一个示例中，切片的后备数组的地址仅在main()函数内使用，它们不会逸出到堆中。 您打印的只是地址比较的结果。 这些只是bool值，不包括地址值。 因此，编译器选择对a和b的后备数组使用相同的地址。

在您的第二个示例中，后备数组的地址（更具体地说是后备数组的某些元素的地址）在main()函数外部使用，它们被传递到fmt.Println()函数中并在内部使用，因为您也打印这些地址。

我们可以通过将-gcflags '-m'参数传递给Go工具来“证明”这一点，要求它打印转义分析的结果。

在第一个示例中，将代码保存在play.go ，运行go run -gcflags '-m' play.go命令，输出为：

./play.go:10:14: "&a == &b" escapes to heap
./play.go:10:29: &a == &b escapes to heap
./play.go:11:14: "&a[0] == &b[0]" escapes to heap
./play.go:11:38: &a[0] == &b[0] escapes to heap
./play.go:8:11: main make([]struct {}, 10) does not escape
./play.go:9:11: main make([]struct {}, 20) does not escape
./play.go:10:26: main &a does not escape
./play.go:10:32: main &b does not escape
./play.go:10:13: main ... argument does not escape
./play.go:11:32: main &a[0] does not escape
./play.go:11:41: main &b[0] does not escape
./play.go:11:13: main ... argument does not escape
&a == &b false
&a[0] == &b[0] true

我们可以看到，地址不会逃脱。

使用第二个示例运行go run -gcflags '-m' play.go ，输出为：

./play.go:10:15: a[0] escapes to heap
./play.go:10:20: &a[0] escapes to heap
./play.go:10:20: &a[0] escapes to heap
./play.go:8:11: make([]struct {}, 10) escapes to heap
./play.go:11:14: "&a == &b" escapes to heap
./play.go:11:29: &a == &b escapes to heap
./play.go:12:14: "&a[0] == &b[0]" escapes to heap
./play.go:12:38: &a[0] == &b[0] escapes to heap
./play.go:9:11: main make([]struct {}, 20) does not escape
./play.go:10:13: main ... argument does not escape
./play.go:11:26: main &a does not escape
./play.go:11:32: main &b does not escape
./play.go:11:13: main ... argument does not escape
./play.go:12:32: main &a[0] does not escape
./play.go:12:41: main &b[0] does not escape
./play.go:12:13: main ... argument does not escape
{} &{}
&a == &b false
&a[0] == &b[0] false

正如可以看到， a[0] &a[0]逃逸到堆，所以背衬阵列a动态分配，并且因此将具有比的不同的地址b的。

让我们进一步“证明”这一点。 让我们修改第二个示例，以使第三个变量c的地址也不会被打印出来，然后将b与c进行比较：

a := make([]struct{}, 10)
b := make([]struct{}, 20)
c := make([]struct{}, 30)
fmt.Println(a[0], &a[0])
fmt.Println("&a == &b", &a == &b)
fmt.Println("&a[0] == &b[0]", &a[0] == &b[0])
fmt.Println("&b == &c", &b == &c)
fmt.Println("&b[0] == &c[0]", &b[0] == &c[0])

在此运行go run -gcflags '-m' play.go ，输出为：

./play.go:11:15: a[0] escapes to heap
./play.go:11:20: &a[0] escapes to heap
./play.go:11:20: &a[0] escapes to heap
./play.go:8:11: make([]struct {}, 10) escapes to heap
./play.go:12:14: "&a == &b" escapes to heap
./play.go:12:29: &a == &b escapes to heap
./play.go:13:14: "&a[0] == &b[0]" escapes to heap
./play.go:13:38: &a[0] == &b[0] escapes to heap
./play.go:14:14: "&b == &c" escapes to heap
./play.go:14:29: &b == &c escapes to heap
./play.go:15:14: "&b[0] == &c[0]" escapes to heap
./play.go:15:38: &b[0] == &c[0] escapes to heap
./play.go:9:11: main make([]struct {}, 20) does not escape
./play.go:10:11: main make([]struct {}, 30) does not escape
./play.go:11:13: main ... argument does not escape
./play.go:12:26: main &a does not escape
./play.go:12:32: main &b does not escape
./play.go:12:13: main ... argument does not escape
./play.go:13:32: main &a[0] does not escape
./play.go:13:41: main &b[0] does not escape
./play.go:13:13: main ... argument does not escape
./play.go:14:26: main &b does not escape
./play.go:14:32: main &c does not escape
./play.go:14:13: main ... argument does not escape
./play.go:15:32: main &b[0] does not escape
./play.go:15:41: main &c[0] does not escape
./play.go:15:13: main ... argument does not escape
{} &{}
&a == &b false
&a[0] == &b[0] false
&b == &c false
&b[0] == &c[0] true

由于只有&a[0]被印刷，但不&b[0]也不&c[0]从而&a[0] == &b[0]将是false ，但&b[0] == &c[0]将是true 。