Hoe werken pointers in Go?

Question

Accepted Answer

Een **pointer** houdt het **geheugenadres** van een waarde vast in plaats van de waarde zelf. Go heeft pointers (zoals C) maar houdt ze eenvoudig en veilig — geen pointer-rekenkunde, en de garbage collector beheert het geheugen. Ze worden gebruikt om gegevens efficiënt te delen en aan te passen.

## De twee operators: & en *

```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
```

`&` neemt het adres van een variabele; `*` (op een pointer) opent of stelt de waarde waarnaar het wijst in.

## Waarom het belangrijk is: wijzigen via functies

```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
```

Omdat Go argumenten **by value** doorgegeven (kopieën), kan een functie de gegevens van de aanroeper alleen wijzigen als deze een **pointer** ervan ontvangt. Dit is de primaire reden om pointers te gebruiken.

## Pointers met structs (zeer algemeen)

```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 zijn hoe methoden hun struct muteren, en het doorgeven van struct pointers voorkomt het kopiëren van grote structs.

## De nil pointer en 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
```

Het derefereren van een `nil` pointer veroorzaakt een panic — een veelvoorkomende runtime-fout om tegen te beveiligen.

## Wat Go pointers NIET hebben (veiligheid)

```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
```

## Waarom het belangrijk is

Pointers zijn essentieel in Go voor twee hoofddoeleinden: **wijzigen** van gegevens van een aanroeper (omdat Go by value doorgeeft, alleen een pointer laat een functie het origineel wijzigen) en **efficiëntie** (het doorgeven van een pointer voorkomt het kopiëren van grote structs).

Ze zijn fundamenteel voor methoden met pointer receivers (de standaardmanier om structs te muteren) en verschijnen overal in idiomatische Go.

Begrip van `&`/`*`, value-versus-pointer semantiek, de nil-pointer panic, en dat Go pointers opzettelijk *veilig* zijn (geen rekenkunde, GC-beheerd) — gericht op delen/mutatie in plaats van C-stijl geheugenmanipulatie — is kernkennis voor het schrijven van correcte, efficiënte Go en een frequent verwarrend punt voor nieuwkomers en in interviews.