How do pointers work in Go?

Question

IT Interview Practice · Accepted Answer

A **pointer** holds the **memory address** of a value rather than the value itself. Go has pointers (like C) but keeps them simple and safe — no pointer arithmetic, and the garbage collector handles memory. They're used to share and modify data efficiently.

## The two operators: & and *

```go
x := 42
p := &x          // & = "address of" → p is a *int (pointer to x)
fmt.Println(p)   // 0xc0000... (the address)
fmt.Println(*p)  // 42 — * = "dereference" (get the value at the address)

*p = 100         // change the value THROUGH the pointer
fmt.Println(x)   // 100 — x was modified via p
```

`&` takes the address of a variable; `*` (on a pointer) accesses or sets the value it points to.

## Why pointers matter: modifying via functions

```go
// ❌ value parameter — the function gets a COPY; changes don't affect the caller
func incrementValue(n int) { n++ }       // caller's variable unchanged

// ✅ pointer parameter — the function can modify the caller's variable
func incrementPointer(n *int) { *n++ }

x := 5
incrementValue(x)     // x still 5
incrementPointer(&x)  // x is now 6
```

Since Go passes arguments **by value** (copies), a function can only modify the caller's data if it receives a **pointer** to it. This is the primary reason to use pointers.

## Pointers with structs (very common)

```go
type Counter struct { count int }

// pointer receiver → method can modify the struct
func (c *Counter) Increment() { c.count++ }

c := &Counter{}      // a pointer to a Counter
c.Increment()        // modifies it (Go auto-dereferences: (*c).count++)
```

Pointer receivers are how methods mutate their struct, and passing struct pointers avoids copying large structs.

## The nil pointer and zero value

```go
var p *int           // zero value of a pointer is nil
fmt.Println(p)       // <nil>
*p = 5               // 💥 PANIC: nil pointer dereference (no value to point to)
if p != nil { *p = 5 }   // guard against nil
```

Dereferencing a `nil` pointer panics — a common runtime error to guard against.

## What Go pointers DON'T have (safety)

```text
✗ NO pointer arithmetic (can't do p++ to move through memory like C)
✗ NO manual free — garbage collector reclaims memory
→ Pointers are about sharing/modifying data, not low-level memory hacking
```

## Why it matters

Pointers are essential in Go for two main purposes: **modifying** a caller's data (since Go passes by value, only a pointer lets a function change the original) and **efficiency** (passing a pointer avoids copying large structs).

They're fundamental to methods with pointer receivers (the standard way to mutate structs) and appear throughout idiomatic Go.

Understanding `&`/`*`, value-vs-pointer semantics, the nil-pointer panic, and that Go pointers are deliberately *safe* (no arithmetic, GC-managed) — focused on sharing/mutation rather than C-style memory manipulation — is core knowledge for writing correct, efficient Go and a frequent point of confusion for newcomers and in interviews.

The two operators: & and *

Why pointers matter: modifying via functions

Pointers with structs (very common)

The nil pointer and zero value

What Go pointers DON'T have (safety)

Why it matters

Related questions