Kako delujejo kazalci v Go-u?

Question

Accepted Answer

**Kazalec** drži **naslov v pomnilniku** vrednosti, namesto vrednosti same. Go ima kazalce (kot C), vendar jih drži preproste in varne — brez aritmetike kazalcev, in zbirač smeti upravlja s pomnilnikom. Uporabljajo se za učinkovito deljenje in spreminjanje podatkov.

## Dva operatorja: & in *

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

`&` vzame naslov spremenljivke; `*` (na kazalcu) dostopa ali nastavi vrednost, na katero kazalec kaže.

## Zakaj so kazalci pomembni: spreminjanje prek funkcij

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

Ker Go prosledi argumente **po vrednosti** (kopije), funkcija lahko spremeni podatke klicatelja samo, če prejme **kazalec** nanje. To je primarni razlog za uporabo kazalcev.

## Kazalci s strukturami (zelo pogosto)

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

Sprejemalniki kazalcev so način, kako metode mutirajajo svojo strukturo, in prosledi strukturnih kazalcev se izogne kopiranju velikih struktur.

## Nič-kazalec in ničelna vrednost

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

Dereferenciranje `nil` kazalca povzroči paniko — pogosto runtime napako, ki se je je treba varovanje.

## Kaj kazalci v Go-u NIMAJO (varnost)

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

## Zakaj je to pomembno

Kazalci so bistveni v Go-u za dva glavna namena: **spreminjanje** podatkov klicatelja (ker Go prosledi po vrednosti, samo kazalec omogoči funkciji spreminjanje originala) in **učinkovitost** (prosledi kazalca se izogne kopiranju velikih struktur).

So temeljni za metode s sprejemalniki kazalcev (standardni način za mutiranje struktur) in se pojavljajo po vsem idiomatičnem Go-u.

Razumevanje `&`/`*`, semantike vrednosti-ali-kazalca, paniki ničelnega kazalca in da so kazalci Go-a namerno *varni* (brez aritmetike, upravljani z GC) — osredotočeni na deljenje/mutacijo namesto manipulacije pomnilnika v slogu C — je temeljno znanje za pisanje pravilnega in učinkovitega Go-a in pogost vir zmede za novince in pri intervjujih.