Understanding Pointers in Go: Reference Types and Receivers Explained

In Go, understanding pointers is essential if you want to work effectively with functions, methods, and memory-efficient code. Unlike some other languages, Go’s approach to pointers is clean and straightforward—there’s no pointer arithmetic, and most things can be done without overly complex syntax.

This article will help you understand:

What pointers are in Go and how they work
Using pointers in functions
Method receivers: value vs pointer
Choosing between value or pointer receiver
Common mistakes with pointers
Best practices for using pointers effectively

What is a Pointer?

A pointer is a variable that stores the memory address of another variable. You use the & operator to get the address and * to access the value at that address.

func main() {
    x := 10
    p := &x
    fmt.Println(*p) // 10
}

Here, p is a pointer to x. *p accesses the value stored at the address.

Pointers and Functions

When passing variables to functions, Go uses value semantics—meaning it passes a copy. If you want the function to modify the original variable, pass a pointer.

func update(val *int) {
    *val = 100
}

func main() {
    x := 10
    update(&x)
    fmt.Println(x) // 100
}

This is useful when working with large structs or when you need to update the caller's data.

Pointer Receivers in Methods

In Go, methods can be defined with either value receivers or pointer receivers. Pointer receivers allow methods to modify the actual object.

type Person struct {
    Name string
    Age  int
}

func (p *Person) GrowUp() {
    p.Age++
}

func main() {
    person := Person{"Alice", 20}
    person.GrowUp()
    fmt.Println(person.Age) // 21
}

If GrowUp() used a value receiver (i.e., func (p Person)), the change would not persist outside the method.

Value vs Pointer Receiver

Go allows both styles, but here's when to choose each:

Value receiver: small structs, method does not modify data
Pointer receiver: large structs, method needs to modify state

func (p Person) ValueGreet() {
    fmt.Println("Hello,", p.Name)
}

func (p *Person) PointerUpdate(name string) {
    p.Name = name
}

Go is Smart: Automatic Conversion

Go is smart enough to let you call pointer receiver methods on value types and vice versa—it will automatically add or remove the & for you:

person := Person{"Bob", 30}
person.GrowUp() // Works even though GrowUp has a pointer receiver

Common Mistakes

Forgetting to pass &x when a function expects *int
Trying to use *x when x is not a pointer
Not understanding that value receiver methods work on copies

Best Practices

Use pointer receivers when your method modifies the struct or for performance
Keep your struct small when using value receivers
Avoid unnecessary pointer complexity—Go is designed to make things simple

Conclusion

Pointers in Go are powerful, but not difficult. They let you control memory usage, update values across scopes, and create efficient, flexible methods. Understanding pointers will make you a better Go developer—especially when working with structs, interfaces, and large systems.

Now that you understand pointers, you're ready to dive deeper into Go's concurrency model and start using goroutines and channels. But don’t forget — great power comes with great responsibility, even in Go!

Happy coding!

buanacoding