Memory layout of arrays in Go?

Question

My code is below. When I check the address of the values it is stored as 280 288 290 298. Why is it stored in this pattern?

package main
    
import "fmt"

func main() {
    const a = 1111111111111111111
    test := [7]int{a, 1, 33333,4,6,7,7}

    fmt.Println(&test[0])
    fmt.Println(&test[1])
    fmt.Println(&test[2])
    fmt.Println(&test[3])
    fmt.Println(&test[4])
    fmt.Println(&test[5])
    fmt.Println(&test[6])
}

output :

0xc00000e280
0xc00000e288
0xc00000e290
0xc00000e298
0xc00000e2a0
0xc00000e2a8
0xc00000e2b0

The addresses are in hex, so the "pattern" is just contiguous 8-byte addresses. `8+8 == 0x10` — Peter Cordes, Jul 03 '22 at 08:21

blackgreen · Accepted Answer · 2022-07-03T11:18:40.273

Unsurprisingly, Go arrays are laid out contiguously in memory. Then since Go types are statically sized, the address of the nth item is equal to the address of the 0th element plus a byte offset equal to the size of the type of the item.

This can be roughly formalized as (pseudo code):

addr_n = addr_0 + (n * size_of(item))

And in Go code, using unsafe.Add (since Go 1.17):

func main() {
    const a = 1111111111111111111
    x := [7]int{a, 1, 33333, 4, 6, 7, 7}

    unsafePointer := unsafe.Pointer(&x[0])
    for i := range x {
        step := unsafe.Sizeof(int(0))
        addr_n := unsafe.Add(unsafePointer, int(step)*i)
        fmt.Printf("addr: %p, val: %d\n", addr_n, *(*int)(addr_n))
    }
}

Which prints:

addr: 0xc000102000, val: 1111111111111111111
addr: 0xc000102008, val: 1
addr: 0xc000102010, val: 33333
addr: 0xc000102018, val: 4
addr: 0xc000102020, val: 6
addr: 0xc000102028, val: 7
addr: 0xc000102030, val: 7

^{In case it wasn't already crystal clear, the hex number is the memory address. This is how pointers are usually formatted by the fmt package.}

However note that the size of int in particular is platform-dependent, hence in the snippet above you can't just add 8. To make it deterministic, you can use unsafe.Sizeof(int(0)).

Playground: https://go.dev/play/p/4hu8efVed96

Memory layout of arrays in Go?

1 Answers1