Hvordan fungerer pointers i Go?

Question

Accepted Answer

En **pointer** indeholder **hukommelsesadressen** på en værdi i stedet for værdien selv. Go har pointers (som C), men holder dem enkle og sikre — ingen pointer-aritmetik, og garbage collector håndterer hukommelsen. De bruges til effektivt at dele og ændre data.

## De to operatorer: & og *

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

`&` tager adressen på en variabel; `*` (på en pointer) får adgang til eller indstiller den værdi, som den peger på.

## Hvorfor pointers betyder noget: ændring via funktioner

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

Da Go sender argumenter **efter værdi** (kopier), kan en funktion kun ændre kalderens data, hvis den modtager en **pointer** til det. Dette er den vigtigste grund til at bruge pointers.

## Pointers med structs (meget almindeligt)

```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-modtagere er, hvordan metoder muterer deres struct, og at sende struct-pointers undgår kopiering af store structs.

## Nil-pointeren og nulværdien

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

At dereference en `nil` pointer forårsager panik — en almindelig runtime-fejl at beskytte mod.

## Hvad Go-pointers IKKE har (sikkerhed)

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

## Hvorfor det betyder noget

Pointers er væsentlige i Go til to vigtige formål: **ændring** af kalderens data (da Go sender efter værdi, lader kun en pointer en funktion ændre originalen) og **effektivitet** (at sende en pointer undgår kopiering af store structs).

De er grundlæggende for metoder med pointer-modtagere (standardmåden at mutere structs på) og vises hele vejen gennem idiomatisk Go.

At forstå `&`/`*`, værdi-vs-pointer-semantik, nil-pointer-panik, og at Go-pointers er bevidst *sikre* (ingen aritmetik, GC-administreret) — fokuseret på deling/mutation i stedet for C-stil hukommelsesmanipulation — er kernekendskab for at skrive korrekt, effektiv Go og et hyppigt forvirringsmål for nybegyndere og i interviews.