У меня есть основной вопрос по empty struct s, и я пытаюсь понять следующие различные выходные данные, которые я получаю при попытке получить адрес элементов резервных массивов для двух фрагментов:
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
Может кто-нибудь объяснить причину указанной выше разницы? Спасибо!
[Follow Up] Внесение следующих изменений:
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]
2 ответа
Прежде чем углубляться, знайте, что согласно спецификации программа является правильной независимо от того, дает ли она одинаковые или разные адреса для значений, имеющих нулевой размер, поскольку в спецификации только указано, что они могут быть одинаковыми, но не требует, чтобы они были одинаковыми.
Спецификация: Гарантия размера и выравнивания:
Тип структуры или массива имеет нулевой размер, если он не содержит полей (или элементов, соответственно), размер которых больше нуля. Две разные переменные нулевого размера могут иметь один и тот же адрес в памяти.
Итак, вы испытываете детали реализации. Есть больше деталей и факторов для принятых решений, следующее объяснение действительно и достаточно только для ваших конкретных примеров:
В вашем первом примере адреса поддерживающих массивов для ваших фрагментов используются только внутри функции main(), они не уходят в кучу. То, что вы печатаете, - это только результат сравнения адресов. Это просто значения bool, они не включают значения адреса. Таким образом, компилятор предпочитает использовать один и тот же адрес для массива поддержки a и b.
В вашем втором примере адреса поддерживающих массивов (точнее, адреса некоторых элементов поддерживающих массивов) используются вне функции main(), они передаются и используются внутри {{ X1}}, потому что вы также распечатываете эти адреса.
Мы можем «доказать» это, передав параметры -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.
Пустая структура - это практически ничего. Размер 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 и может измениться в любое время.
Для дальнейшего чтения я бы порекомендовал эту отличную статью о пустой структуре .
Похожие вопросы
Новые вопросы
pointers
Тип данных, который «указывает» на другое значение, хранящееся в памяти. Переменная-указатель содержит адрес памяти некоторой другой сущности (переменная или функция или другая сущность). Этот тег следует использовать для вопросов, связанных с использованием указателей, а не ссылок. Наиболее распространенными языками программирования, использующими указатели, являются C, C ++, Go и языки ассемблера. Используйте определенный языковой тег. Другими полезными тегами являются метод, функция, структура и т. Д., Описывающие использование указателя.
En Español