Pointers

Introduction

By default, Go passes arguments to functions by value — meaning a copy is made. For small values like an int or a bool, that's cheap and usually exactly what you want. But sometimes you need a function to modify the caller's original data, or you want to avoid the cost of copying a large struct on every call. Pointers solve both problems by letting you work with a value's memory address directly.

What Is a Pointer?

A pointer is a variable that stores the memory address of another variable, rather than a value itself. A pointer to a value of type T has the type *T. Pointers let you refer to "the same variable" from multiple places, instead of working with separate copies.

package main

import "fmt"

func main() {
	age := 30
	var agePointer *int = &age

	fmt.Println("value of age:", age)
	fmt.Println("address of age:", agePointer)
	fmt.Println("value via pointer:", *agePointer)
}

The exact address printed (0xc0000140a0) will differ every time you run the program — memory addresses are assigned dynamically. What matters is the pattern: & gets an address, and * follows it back to the value.

The & and * Operators

The & (address-of) operator produces a pointer to a variable. The * (dereference) operator, when applied to a pointer, gives you back the value it points to — and can also be used to modify that original value.

package main

import "fmt"

func main() {
	score := 100
	scorePointer := &score

	fmt.Println("before:", score)

	*scorePointer = 150 // modifies the original "score" through the pointer

	fmt.Println("after:", score)
}

Why Use Pointers: Mutating Without Copying

Passing a value to a function normally passes a copy — changes inside the function never affect the caller's variable. Passing a pointer instead lets the function reach back and modify the original.

package main

import "fmt"

// By value: has no effect on the caller's variable.
func incrementByValue(n int) {
	n++
}

// By pointer: modifies the caller's original variable.
func incrementByPointer(n *int) {
	*n++
}

func main() {
	count := 10

	incrementByValue(count)
	fmt.Println("after incrementByValue:", count) // unchanged

	incrementByPointer(&count)
	fmt.Println("after incrementByPointer:", count) // changed
}

Pointers and Function Parameters

Pointers are also useful purely for efficiency: passing a pointer to a large struct copies only the (small, fixed-size) address, rather than copying the entire struct's data on every function call.

package main

import "fmt"

type Profile struct {
	Name  string
	Email string
	Bio   string // imagine this is a very large field
}

// Passing a pointer avoids copying the whole Profile struct.
func updateBio(p *Profile, newBio string) {
	p.Bio = newBio // Go automatically dereferences for field access
}

func main() {
	user := Profile{Name: "Dana", Email: "dana@example.com", Bio: "old bio"}

	updateBio(&user, "Go developer and open-source contributor")

	fmt.Println(user.Bio)
}

No Pointer Arithmetic

If you've used C or C++, you may be used to pointer arithmetic — adding an offset to a pointer to walk through memory, e.g. ptr + 1 to move to the next element. Go deliberately does not allow this. You cannot add, subtract, or compare pointers with arithmetic operators. This is a safety decision: pointer arithmetic is a major source of memory corruption bugs and security vulnerabilities in C-style languages, and Go's designers chose to eliminate that entire category of bugs.

package main

func main() {
	x := 5
	p := &x

	// The following line would NOT compile in Go:
	// p = p + 1  // invalid operation: p + 1 (mismatched types *int and untyped int)

	_ = p
}

If you need to walk through a sequence of values, use a slice and indexing instead — slices give you the safety of bounds-checked access without ever touching a raw memory address.

The Zero Value: nil

A pointer's zero value is nil, meaning it points to nothing. Dereferencing a nil pointer causes a runtime panic, so it's good practice to check for nil before dereferencing when a pointer might not have been initialized.

package main

import "fmt"

func safePrint(p *int) {
	if p == nil {
		fmt.Println("pointer is nil, nothing to print")
		return
	}
	fmt.Println("value:", *p)
}

func main() {
	var p *int // nil by default
	safePrint(p)

	x := 42
	safePrint(&x)
}

Common Mistakes

Best Practices

Frequently Asked Questions

Key Takeaways

Summary

Pointers give Go the ability to mutate shared state and avoid unnecessary copying, while Go's garbage collector and lack of pointer arithmetic keep them far safer than their C counterparts. With pointers under your belt, you're ready to learn about structs — the primary way Go groups related data together.