Pointers without fear

What a pointer is

Every variable lives somewhere in memory, at an address. A pointer is a variable whose value is such an address. The type *int means "pointer to an int". Two operators do all the work: & (address of) and * (the value at).

x := 10
p := &x          // p holds the address of x; its type is *int
fmt.Println(*p)  // 10: read through the pointer
*p = 25          // change x through the pointer
fmt.Println(x)   // 25
fmt.Println(p)   // something like 0xc000012345 (an address)

Why use pointers?

1. To let a function change the caller's variable. Go passes arguments as copies, so without a pointer the function only changes its copy.
2. To avoid copying a large struct every time it is passed or returned.
3. To share one value between several parts of the program, for example one *Config or one *sql.DB.
4. To say "no value": a nil pointer can mean "not set", different from a zero value. For example *int can tell "0 runs" from "not played yet".

func addBonus(marks *int, bonus int) {
	*marks += bonus
}

func main() {
	m := 80
	addBonus(&m, 5)
	fmt.Println(m) // 85
}

nil pointers

The zero value of a pointer is nil: it points nowhere. Following a nil pointer crashes the program with "invalid memory address or nil pointer dereference". This is the most common Go crash. Check for nil when a pointer may be empty.

var p *int
fmt.Println(p == nil) // true
// fmt.Println(*p)    // panic: runtime error: invalid memory address or nil pointer dereference

if p != nil {
	fmt.Println(*p)
}

new, and returning pointers to local variables

n := new(int)     // allocates an int set to 0, returns *int
*n = 7

func newCounter() *int {
	c := 0
	return &c        // perfectly safe in Go
}

In practice you rarely call new. For structs, &Student{Name: "Asha"} is the common way to get a pointer to a new value.

What Go does NOT allow

• No pointer arithmetic: you cannot write p++ to move to the next address (except with the unsafe package, which normal code never needs).
• No manual free(): the garbage collector frees memory once no pointer refers to it.
• No dangling pointers to freed memory in normal Go code.

Pointers and slices, maps and channels

Slices, maps and channels already contain internal pointers to their data, so you almost never need *[]int or *map[string]int. Pass them as they are. (A function that appends to a slice should return the new slice, as you learned in module 3.)