Jak działają wskaźniki w Go?

Question

Accepted Answer

**Wskaźnik** przechowuje **adres w pamięci** wartości, a nie samą wartość. Go ma wskaźniki (jak C), ale utrzymuje je proste i bezpieczne — bez arytmetyki wskaźników, a garbage collector zajmuje się pamięcią. Używane są do wydajnego dzielenia się danymi i ich modyfikacji.

## Dwa operatory: & i *

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

`&` pobiera adres zmiennej; `*` (na wskaźniku) uzyskuje dostęp do wartości, na którą wskazuje, lub ją ustawia.

## Dlaczego to ważne: modyfikowanie poprzez funkcje

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

Ponieważ Go przekazuje argumenty **przez wartość** (kopie), funkcja może modyfikować dane wywołującego tylko wtedy, gdy otrzyma **wskaźnik** do nich. To główny powód do używania wskaźników.

## Wskaźniki ze strukturami (bardzo powszechne)

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

Odbiorniki wskaźników to sposób, w jaki metody mutują swoją strukturę, a przekazywanie wskaźników struktur unika kopiowania dużych struktur.

## Wskaźnik nil i wartość zerowa

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

Dereferencjowanie wskaźnika `nil` powoduje panic — typowy błąd czasu wykonania, przed którym należy się chronić.

## Czego wskaźniki w Go NIE mają (bezpieczeństwo)

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

## Dlaczego to ważne

Wskaźniki są niezbędne w Go dla dwóch głównych celów: **modyfikowania** danych wywołującego (ponieważ Go przekazuje przez wartość, tylko wskaźnik pozwala funkcji zmienić oryginalne dane) i **wydajności** (przekazanie wskaźnika unika kopiowania dużych struktur).

Są fundamentalne dla metod z odbiornikami wskaźników (standardowy sposób mutacji struktur) i pojawiają się wszędzie w idiomatycznym Go.

Rozumienie `&`/`*`, semantyki wartość-vs-wskaźnik, paniki ze wskaźnikiem nil oraz fakt, że wskaźniki w Go są celowo *bezpieczne* (bez arytmetyki, zarządzane przez GC) — ukierunkowane na dzielenie się/mutację, a nie na manipulację pamięcią w stylu C — jest fundamentową wiedzą do pisania poprawnego i wydajnego Go i jest częstym punktem zamieszania dla nowicjuszy i podczas rozmów kwalifikacyjnych.