Jak fungují ukazatele v Go?

Question

Accepted Answer

**Ukazatel** obsahuje **paměťovou adresu** hodnoty, nikoli samotnou hodnotu. Go má ukazatele (jako C), ale udržuje je jednoduché a bezpečné — bez aritmetiky ukazatelů, a garbage collector spravuje paměť. Používají se k efektivnímu sdílení a úpravě dat.

## Dva operátory: & a *

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

`&` získá adresu proměnné; `*` (na ukazateli) přistoupí k hodnotě, na kterou ukazuje, nebo ji nastaví.

## Proč na ukazatele záleží: modifikace prostřednictvím funkcí

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

Protože Go předává argumenty **podle hodnoty** (kopie), funkce může upravit data volajícího pouze v případě, že obdrží **ukazatel** na ně. Toto je hlavní důvod pro použití ukazatelů.

## Ukazatele se strukturami (velmi běžné)

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

Přijímače ukazatelů jsou způsob, jak metody mění svou strukturu, a předávání ukazatelů na struktury se vyhýbá kopírování velkých struktur.

## Nulový ukazatel a nulová hodnota

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

Dereferování ukazatele `nil` způsobí paniku — běžná chyba za běhu, kterou je třeba chránit.

## Co nemají ukazatele Go (bezpečnost)

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

## Proč to má význam

Ukazatele jsou v Go nezbytné ze dvou hlavních důvodů: **modifikace** dat volajícího (protože Go předává podle hodnoty, jen ukazatel umožní funkci změnit originál) a **efektivita** (předání ukazatele se vyhýbá kopírování velkých struktur).

Jsou zásadní pro metody s příjímači ukazatelů (standardní způsob mutace struktur) a objevují se v celém idiomatic Go.

Rozvlnění `&`/`*`, sémantiky hodna-vs-ukazatel, paniky nulového ukazatele a toho, že ukazatele Go jsou záměrně *bezpečné* (bez aritmetiky, spravovane GC) — zaměřené na sdílení/mutaci spíše než na manipulaci paměti stylem C — je základní znalostí pro psaní správného a efektivního Go a častým zdrojem nejasností pro nováčky a v rozhovorech.