Pointers in Go

Memory Addresses

Value Addresses

What Are Pointers?

Go Pointer Types and Values

*int  // An unnamed pointer type whose base type is int.
**int // An unnamed pointer type whose base type is *int.

// Ptr is a named pointer type whose base type is int.
type Ptr *int
// PP is a named pointer type whose base type is Ptr.
type PP *Ptr

About the Word "Reference"

How to Get a Pointer Value and What Are Addressable Values?

1. The built-in new function can be used to allocate memory for a value of any type. new(T) will allocate memory for a T value (an anonymous variable) and return the address of the T value. The allocated value is a zero value of type T. The returned address is viewed as a pointer value of type *T.
2. We can also take the addresses of values which are addressable in Go. For an addressable value t of type T, we can use the expression &t to take the address of t, where & is the operator to take value addresses. The type of &t is viewed as *T.

Pointer Dereference

package main

import "fmt"

func main() {
	p0 := new(int)   // p0 points to a zero int value.
	fmt.Println(p0)  // (a hex address string)
	fmt.Println(*p0) // 0

	// x is a copy of the value at
	// the address stored in p0.
	x := *p0
	// Both take the address of x.
	// x, *p1 and *p2 represent the same value.
	p1, p2 := &x, &x
	fmt.Println(p1 == p2) // true
	fmt.Println(p0 == p1) // false
	p3 := &*p0 // <=> p3 := &(*p0) <=> p3 := p0
	// Now, p3 and p0 store the same address.
	fmt.Println(p0 == p3) // true
	*p0, *p1 = 123, 789
	fmt.Println(*p2, x, *p3) // 789 789 123

	fmt.Printf("%T, %T \n", *p0, x) // int, int
	fmt.Printf("%T, %T \n", p0, p1) // *int, *int
}

Why Do We Need Pointers?

package main

import "fmt"

func double(x int) {
	x += x
}

func main() {
	var a = 3
	double(a)
	fmt.Println(a) // 3
}

package main

import "fmt"

func double(x *int) {
	*x += *x
	x = nil // the line is just for explanation purpose
}

func main() {
	var a = 3
	double(&a)
	fmt.Println(a) // 6
	p := &a
	double(p)
	fmt.Println(a, p == nil) // 12 false
}

Return Pointers of Local Variables Is Safe in Go

func newInt() *int {
	a := 3
	return &a
}

Restrictions on Pointers in Go

Go pointer values don't support arithmetic operations

package main

import "fmt"

func main() {
	a := int64(5)
	p := &a

	// The following two lines don't compile.
	/*
	p++
	p = (&a) + 8
	*/

	*p++
	fmt.Println(*p, a)   // 6 6
	fmt.Println(p == &a) // true

	*&a++
	*&*&a++
	**&p++
	*&*p++
	fmt.Println(*p, a) // 10 10
}

A pointer value can't be converted to an arbitrary pointer type

1. The underlying types of type T1 and T2 are identical (ignoring struct tags), in particular if either T1 and T2 is a unnamed type and their underlying types are identical (considering struct tags), then the conversion can be implicit. Struct types and values will be explained in the next article.
2. Type T1 and T2 are both unnamed pointer types and the underlying types of their base types are identical (ignoring struct tags).

type MyInt int64
type Ta    *int64
type Tb    *MyInt

1. values of type *int64 can be implicitly converted to type Ta, and vice versa, for their underlying types are both *int64.
2. values of type *MyInt can be implicitly converted to type Tb, and vice versa, for their underlying types are both *MyInt.
3. values of type *MyInt can be explicitly converted to type *int64, and vice versa, for they are both unnamed and the underlying types of their base types are both int64.
4. values of type Ta can't be directly converted to type Tb, even if explicitly. However, by the just listed first three facts, a value pa of type Ta can be indirectly converted to type Tb by nesting three explicit conversions, Tb((*MyInt)((*int64)(pa))).

A pointer value can't be compared with values of an arbitrary pointer type

1. The types of the two Go pointers are identical.
2. One pointer value can be implicitly converted to the pointer type of the other. In other words, the underlying types of the two types must be identical and either of the two types of the two Go pointers is an unnamed type.
3. One and only one of the two pointers is represented with the bare (untyped) nil identifier.

package main

func main() {
	type MyInt int64
	type Ta    *int64
	type Tb    *MyInt

	// 4 nil pointers of different types.
	var pa0 Ta
	var pa1 *int64
	var pb0 Tb
	var pb1 *MyInt

	// The following 6 lines all compile okay.
	// The comparison results are all true.
	_ = pa0 == pa1
	_ = pb0 == pb1
	_ = pa0 == nil
	_ = pa1 == nil
	_ = pb0 == nil
	_ = pb1 == nil

	// None of the following 3 lines compile ok.
	/*
	_ = pa0 == pb0
	_ = pa1 == pb1
	_ = pa0 == Tb(nil)
	*/
}

A pointer value can't be assigned to pointer values of other pointer types

It's Possible to Break the Go Pointer Restrictions