Hogyan működnek a mutatók a Go-ban?

Question

Accepted Answer

A **mutató** egy érték **memóriacímét** tárolja magában az érték helyett. A Go-nak vannak mutatói (mint a C-ben), de egyszerűen és biztonságosan tartja őket — nincs mutatóaritmetika, és a garbage collector kezeli a memóriát. Az adatok hatékony megosztására és módosítására szolgálnak.

## A két operátor: & és *

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

A `&` egy változó címét veszi; a `*` (mutató esetén) hozzáfér a mutatott értékhez vagy beállítja azt.

## Miért fontosak a mutatók: módosítás függvényeken keresztül

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

Mivel a Go az argumentumokat **érték szerint** (másolatokként) adja át, a függvény csak akkor módosíthatja a hívó adatait, ha **mutatót** kap azokra. Ez az elsődleges oka a mutatók használatának.

## Mutatók strukturákkal (nagyon gyakori)

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

A pointer receiverek az a módszer, ahogyan a metódusok megváltoztatják a struktúrájukat, és a struktúra mutatóinak átadása elkerüli a nagy strukturák másolását.

## A nil mutató és a nulla érték

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

A `nil` mutató dereferencálása pánikot okoz — gyakori futásidejű hiba, amit meg kell előzni.

## Amit a Go mutatók NINCS (biztonság)

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

## Miért fontos

A mutatók a Go-ban két fő célra szükségesek: a **hívó adatainak módosítása** (mivel a Go érték szerint ad át, csak egy mutató engedi a függvénynek az eredeti módosítását) és a **hatékonyság** (mutató átadása elkerüli a nagy strukturák másolását).

Esszenciálisak a pointer receiverek metódusaihoz (a strukturák módosításának szabványos módja), és az idiomatikus Go-ban mindenütt megjelennek.

A `&`/`*`, az érték-vs-mutató szemantika, a nil-mutató pánik, és az, hogy a Go mutatók szándékosan *biztonságosak* (nincs aritmetika, GC által kezelt) — a C-stílusú memóriakezelés helyett a megosztásra/módosításra összpontosítva — alapvető tudás a helyes, hatékony Go írásához és a kezdőknek és interjúkban gyakori zavaros pont.