🧠 Print the memory address of a variable in Go

introduction pointer slice

In Go, to print the memory address of a variable, struct, array, slice, map, or any other structure, you need to generate a pointer to the value with the address operator & and use the fmt.Println() function (or any other print function from the fmt package) to write the value address to the standard output. If you want to put the address as part of the text, you can use the %p format verb in the fmt.Printf() function.

Example 1: Print the address of a variable

// variable
i := 32
fmt.Println(&i)

// pointer to the variable
p := &i
fmt.Println(p)

Output:

0xc00001c088
0xc00001c088

Example 2: Format the address of a variable

// variable
i := 32
fmt.Printf("Address of i=%d:\t%p\n", i, &i)

// pointer to the variable
p := &i
fmt.Printf("Address of p=&i=%d:\t%p\n", *p, p)

Output:

Address of i=32:        0xc00001c088
Address of p=&i=32:     0xc00001c088

Example 3: Format addresses of various Go data structures: array, slice, struct, struct field, and map

package main

import "fmt"

type A struct {
    Number int
    Text   string
}

func main() {
    // array
    arr := [3]int{1, 2, 3}
    fmt.Printf("Address of array = %v: %p\n", arr, &arr)

    // slice
    slice := []int{1, 2, 3}
    fmt.Printf("Address of slice = %v: %p\n", slice, &slice)

    // struct
    structInstance := A{Number: 23, Text: "abc"}
    fmt.Printf("Address of struct = %+v: %p\n", structInstance, &structInstance)

    // struct field
    fmt.Printf("Address of struct field = %s: %p\n", structInstance.Text, &structInstance.Text)

    // map
    mapInstance := map[int]int{
        0: 1,
    }
    fmt.Printf("Address of map = %v: %p\n", mapInstance, &mapInstance)
}

Output:

Address of array = [1 2 3]: 0xc0000b4000
Address of slice = [1 2 3]: 0xc0000a4018
Address of struct = {Number:23 Text:abc}: 0xc0000a4048
Address of struct field = abc: 0xc0000a4050
Address of map = map[0:1]: 0xc0000aa020

As you may know, map index expressions are not addressable, so it is not possible to print the address of a map value with a specific key.

In Example 1 and Example 2, we created a new pointer p of type *int and assigned to it the address of variable i. Then, we printed the value of the pointer p with fmt.Println(p), which is the address of the variable i. Since the pointer itself is a value, we can also print the address of that value using fmt.Println(&p). Compare outputs of printing the address of the variable i, the value of p, and the pointer of p:

// get the address of a variable
i := 32
fmt.Printf("Address of i=%d: %p\n", i, &i)

// get the address the pointer points to
p := &i
fmt.Printf("Address of p=&i=%d: %p\n", *p, p)

// get the address of pointer
fmt.Printf("Address of pointer p=&i=%d: %p\n", *p, &p)

Output:

Address of i=32: 0xc00001c088
Address of p=&i=32: 0xc00001c088
Address of pointer p=&i=32: 0xc00000e030

The diagram below shows the relationship between variables and pointers in memory.

Variable vs pointer in memory

Slices are values, so to print the address of a slice, you need to use the address operator &, just as you would for normal variables. But the verb %p also has a special meaning for slices. Quoting the documentation of the fmt package:

%p	address of 0th element in base 16 notation, with leading 0x

To print the address of the 0th element of the slice, which is equivalent to the address of the slice underlying array, you just need to use the %p format with the slice value argument. See the code below to compare the address of an example array, the address of a slice created by “slicing” the array, and the address of the 0th element of the slice (the address of the underlying array).

// print address of array
arr := [3]int{1, 2, 3}
fmt.Printf("Address of arr: %p\n", &arr)

// print address of slice
// "slicing" the array
slice := arr[:]
fmt.Printf("Address of slice: %p\n", &slice)

// print address of the slice underlying array
fmt.Printf("Address of the slice underlying array: %p\n", slice)

// print address of 0th element of the slice
fmt.Printf("Address of 0th element of the slice: %p\n", &slice[0])

Output:

Address of arr: 0xc000014120
Address of slice: 0xc00000c030
Address of the slice underlying array: 0xc000014120
Address of 0th element of the slice: 0xc000014120

To print the address without leading 0x, use the formatting pointer verb with the # flag: %#p.

// print address of array
arr := [3]int{1, 2, 3}
fmt.Printf("Address of arr: %#p\n", &arr)

Output:

Address of arr: c000014120

Assign an address to a string

To get the address of a variable and assign it to string, use fmt.Sprintf() function:

arr := [3]int{1, 2, 3}
addr := fmt.Sprintf("%p", &arr)
fmt.Println(addr)

Output:

0xc0000b4000

🖨️ Convert string to []byte or []byte to string in Go

Learn the difference between a string and a byte slice
introduction strings slice

🏟️ Capacity and length of a slice in Go

Learn what is the difference between length and capacity of a slice
introduction slice array

🕵️ Solve 'cannot take address of XXX' error in Go

Learn how to take the address of a literal, map value, or function return value
introduction pointer errors