空结构切片的地址

时间:2018-01-01 19:44:14

标签: pointers go slice

我在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])

以上代码段returns

&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])

以上代码段returns

{} &{}
&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

但是,取消注释方法调用returns

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

2 个答案:

答案 0 :(得分:2)

空结构基本上是:几乎没有。它的大小为0:

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

返回0

现在,至于为什么两个空结构的地址有时相同而有时不相同,这取决于内部结构。 我们可以获得的唯一线索来自the spec

  

如果结构或数组类型不包含任何字段(或   元素,分别),大小大于零。二   不同的零大小变量在内存中可能具有相同的地址。

还请注意以下代码,第一个打印件移到最后:

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
{} &{}

或者与第二种情况相同。 基本上,这表明编译器选择使用不同的地址。鉴于“可能在内存中可能具有相同的地址”,您不应该依赖于相等,因为确切的行为取决于内部结构并且可能随时发生变化。

如需进一步阅读,我建议this excellent article on the empty struct

答案 1 :(得分:2)

在深入了解之前,要知道根据规范,程序是正确的,无论它是否为具有零大小的值产生相同或不同的地址,因为规范仅表明它们可能是同样的,但不要求它们是相同的。

Spec: Size and alignment guarantees:

  

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

所以您体验的是实现细节。决策有更多细节和因素,以下解释仅对您的具体示例有效且充分:

在您的第一个示例中,切片的支持数组的地址仅在main()函数内使用,它们不会转义到堆。您打印的内容只是地址比较的结果。这些只是bool值,它们不包含地址值。因此,编译器选择对ab的后备数组使用相同的地址。

在您的第二个示例中,支持数组的地址(更具体地说是支持数组的某些元素的地址)在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不同的地址。 1}}' S

让我们"证明"这进一步。让我们修改你的第二个例子,得到第三个变量c,其地址也不会被打印,让我们将bc进行比较:

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 }}