Wie funktionieren Pointer in Go?

Question

Accepted Answer

Ein **Pointer** speichert die **Speicheradresse** eines Wertes, nicht den Wert selbst. Go hat Pointer (wie C), hält sie aber einfach und sicher — keine Pointer-Arithmetik, und der Garbage Collector verwaltet den Speicher. Sie werden verwendet, um Daten effizient zu teilen und zu ändern.

## Die zwei Operatoren: & und *

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

`&` nimmt die Adresse einer Variablen; `*` (auf einem Pointer) greift auf den Wert zu, auf den er zeigt, oder setzt ihn.

## Warum Pointer wichtig sind: Änderungen über Funktionen

```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 Argumente **nach Wert** (Kopien) übergibt, kann eine Funktion die Daten des Aufrufers nur ändern, wenn sie einen **Pointer** darauf erhält. Dies ist der Hauptgrund für die Verwendung von Pointern.

## Pointer mit Structs (sehr häufig)

```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-Receiver sind die Möglichkeit, wie Methoden ihre Struct ändern, und das Übergeben von Struct-Pointern vermeidet das Kopieren großer Structs.

## Der Null-Pointer und der Null-Wert

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

Das Dereferenzieren eines `nil` Pointers führt zu Panik — ein häufiger Laufzeitfehler, gegen den man schützen muss.

## Was Go-Pointer NICHT haben (Sicherheit)

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

## Warum es wichtig ist

Pointer sind in Go für zwei Hauptzwecke unerlässlich: **Änderung** der Daten des Aufrufers (da Go nach Wert übergibt, lässt nur ein Pointer eine Funktion das Original ändern) und **Effizienz** (Übergabe eines Pointers vermeidet das Kopieren großer Structs).

Sie sind grundlegend für Methoden mit Pointer-Receivern (der Standard-Weg, um Structs zu ändern) und erscheinen überall in idiomatischem Go.

Das Verständnis von `&`/`*`, Wert-vs-Pointer-Semantik, Null-Pointer-Panik und die Tatsache, dass Go-Pointer absichtlich *sicher* sind (keine Arithmetik, GC-verwaltet) — konzentriert auf Sharing/Mutation statt C-artiger Speichermanipulation — ist Kernwissen für das Schreiben von korrektem, effizientem Go und ein häufiger Verwirrungspunkt für Anfänger und in Interviews.