Pointers

Understand memory addresses, learn when to pass by pointer instead of value, and write mutation-safe functions.

8 min readProgramming Foundations (Go)Code

Address and Dereference

Every variable is stored at a memory address. The address-of operator & gives you that address. The dereference operator * reads the value at an address. Together they are the foundation of pointer semantics.

Goaddress-of-and-dereference.go

16 linesLn 1, Col 1Go

`&x` reads as 'the address of x'. `*p` reads as 'the value pointed to by p'. Writing `*p = 100` changes the variable that `p` points at, which is `x`.

Pointer Types

A pointer type is written *T — a pointer to a value of type T. The zero value for any pointer type is nil, which means 'pointing at nothing'.

Gopointer-types-in-function-signatures.go

28 linesLn 1, Col 1Go

Passing `*Config` to a function avoids copying the entire struct. For large structs this matters for performance. `new(T)` is equivalent to `tmp := T{}; &tmp` — it allocates a zero-value T and returns a pointer.

Mutation Through Pointers

When you pass a pointer to a function, the function can modify the original value. This is the only way to have a function change a caller's variable (other than returning the new value).

Gomodify-vs-copy.go

24 linesLn 1, Col 1Go

If a function needs to change its caller's variable, it must receive a pointer. If it only needs to read the value, pass by value is cleaner and prevents accidental mutation.

nil Pointers

A nil pointer does not point to any memory. Dereferencing a nil pointer (reading or writing through it) causes a runtime panic. Always check whether a pointer is nil before dereferencing it.

Gosafe-nil-checks.go

30 linesLn 1, Col 1Go

The `for n != nil` pattern safely traverses a linked list regardless of its length. Nil-checking before use is the fundamental defensive pattern for all pointer types.

When to Use Pointers

Not every type needs a pointer. Go gives you a clear rule of thumb: use a pointer when you need mutation or when copying would be expensive or semantically wrong.

Use pointer when	Use value when
Function must modify the caller's variable	Function only needs to read
Struct is large and copying is expensive	Struct is small (a few fields)
Shared ownership across goroutines	Single-owner, local use
Method must modify the receiver	Method only reads the receiver
Type has a nil state that represents 'absent'	Value is always present

Slices and maps already have pointer semantics

Slices and maps are already reference types — you do not need *[]T or *map[K]V to share them between functions. A *[]T is occasionally used when a function needs to append to a slice and have the caller see the new header, but this is uncommon. For most collection types, just pass the slice or map directly.

Mark this lesson complete to store local progress and unlock a cleaner resume path the next time you visit.

Stage 1 · Code

Methods, Interfaces & Errors