Pointers in Go

What is a Pointer?

In Go, a pointer is a variable that** stores the memory address** of another variable. Instead of holding a value directly, it points to the location where the value is stored.

Syntax

var x int = 10
var p *int = &x // p is a pointer to x

• &x: address-of operator — gets the memory address of variable x.
• *p: dereference operator — gets the value from the address p is pointing to.

Why Use Pointers?

• To share data across function calls without copying.
• To modify variables inside functions.
• To build data structures like linked lists, trees, etc.
• To optimize memory usage and performance by avoiding unnecessary copies.

Declaring and Using Pointers

var a int = 42
var p *int = &a

fmt.Println("Value of a:", a)   // 42
fmt.Println("Address of a:", &a)
fmt.Println("Value of p:", p)   // address of a
fmt.Println("Value at p:", *p)  // 42

Pointer Zero Value
The zero value of a pointer is nil.

var p *int
fmt.Println(p) // <nil>

Always check for nil before dereferencing a pointer:

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

Passing Pointers to Functions

By Value (copy)

func increment(n int) {
    n++
}

This won't affect the original value.

By Pointer (reference)

func incrementPtr(n *int) {
    *n++
}

x := 5
incrementPtr(&x)
fmt.Println(x) // 6

Returning Pointers from Functions
It's safe to return pointers to local variables in Go — the compiler allocates them on the heap if necessary.

func createPointer() *int {
    x := 100
    return &x
}

Structs and Pointers

Value Receiver

type User struct {
    Name string
}

func (u User) Update(name string) {
    u.Name = name // Doesn't affect the original
}

Pointer Receiver

func (u *User) Update(name string) {
    u.Name = name // Modifies the original
}

Calling pointer receivers on values (and vice versa)
Go automatically converts between values and pointers when calling methods:

u := User{}
u.Update("Alice") // works even if Update expects *User

Pointers and Arrays/Slices
Arrays are value types

func modifyArray(arr [3]int) {
    arr[0] = 100
}

Won't affect original array.

Use a pointer to modify array

func modifyArrayPtr(arr *[3]int) {
    arr[0] = 100
}

Slices behave like pointers internally
You can modify slice contents without using explicit pointers:

func modifySlice(s []int) {
    s[0] = 100 // modifies original slice
}

Pointers to Pointers
Go supports pointers to pointers, but they’re rarely needed in idiomatic Go.

var x int = 10
var p *int = &x
var pp **int = &p

fmt.Println(**pp) // 10

Interface and Pointer Subtleties
Value vs Pointer receivers in interfaces

type Printer interface {
    Print()
}

type Data struct{}

func (d Data) Print()    { fmt.Println("Value") }
func (d *Data) Print()   { fmt.Println("Pointer") }

func main() {
    var d Data
    var p Printer = &d // works
    // var q Printer = d // doesn't work if only pointer receiver is defined
}

Always ensure your receiver type matches your intended interface use.

Pointers and new Keyword
new(Type) allocates zeroed storage and returns a pointer.

p := new(int) // *int, initialized to 0
*p = 10

Equivalent to:

var x int
p := &x

Pointers and Garbage Collection
Go has garbage collection. You don’t need to free memory manually. Once a pointer is no longer referenced, Go will reclaim the memory.

Best Practices

• Use pointers to avoid copying large structs.
• Use pointer receivers if your method modifies the receiver or avoids copying.
• Avoid pointer-to-interface — use interfaces directly.
• Be careful with nil — always check before dereferencing.
• Prefer slices, maps, and channels over manual pointer-heavy code when possible.
• Avoid using pointers with basic types (like int, bool) unless necessary.

Common Mistakes

Pointer Comparison

a := 100
b := 100
p1 := &a
p2 := &a
p3 := &b

fmt.Println(p1 == p2) // true
fmt.Println(p1 == p3) // false

Pointers are equal if they point to the same memory address.

Example: Swap Function

func swap(a, b *int) {
    *a, *b = *b, *a
}

x, y := 1, 2
swap(&x, &y)
fmt.Println(x, y) // 2, 1