main.go

package main

import "fmt"

func main() {
	f1 := &Foo{}
	f2 := &Foo{}
	fmt.Printf("%p = %p\n", f1, f2)

	b1 := &Bar{}
	b2 := &Bar{}
	fmt.Printf("%p != %p\n", b1, b2)
}

type Foo struct{}

type Bar struct{ Field string }

run.txt

$ go run main.go
0x1157c08 = 0x1157c08
0xc42000e1e0 != 0xc42000e1f0

WTH? Why wouldn't the pointers be different in both cases?

Foo, the empty struct, consumes 0 bytes in memory, so their offsets are the same (offset += Foo{} in pointer arithmetic is still offset). But Bar has a field, so it has a slight offset.

This is a subtle difference between pointers and references. Pointers are just numbers; if you have 2 pointers, they'll have different memory addresses, no matter what they point to, and even if they point to the same value or an empty struct; but the empty struct values themselves have the same address in memory, thus their reference is the same offset.

(Edit: As you pointed out on Twitter, the spec leaves it up to the implementation. It's still worth pointing out to that "equal" is not necessarily synonymous with "same", and I still get a headache thinking about it carefully.)

@mholt yeah, the spec seems to leave it open to the implementation. The latter seems to return a single fixed address for all 0-sized allocations:

	if size == 0 {
		return unsafe.Pointer(&zerobase)
	}

See:

• https://twitter.com/KevinBowrin/status/1053006970066628608
• https://golang.org/src/runtime/malloc.go