Kako pointeri funkcioniraju u Go?

Question

Accepted Answer

**Pointer** sadrži **memorijsku adresu** vrijednosti umjesto same vrijednosti. Go ima pointere (kao C) ali ih čuva jednostavnima i sigurnima — bez aritmetike pokazivača, a garbage collector upravlja memorijom. Koriste se za učinkovito dijeljenje i izmjenu podataka.

## Dva operatora: & 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
```

`&` uzima adresu varijable; `*` (na pointeru) pristupa ili postavlja vrijednost na koju ukazuje.

## Zašto pointeri bitni: izmjena preko funkcija

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

Budući da Go prosleđuje argumente **po vrijednosti** (kopije), funkcija može modificirati podatke pozivajućeg samo ako primi **pointer** na njih. Ovo je primarni razlog za korištenje pointera.

## Pointeri sa structima (vrlo česti)

```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 receivers su način na koji metode mutiraju svoju structu, a prosleđivanje struktur pointera izbjegava kopiranje velikih struktura.

## Nil pointer i nula vrijednost

```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` pointera uzrokuje paniku — česta runtime greška od koje se trebate čuvati.

## Što Go pointeri NEMAJU (sigurnost)

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

## Zašto je to važno

Pointeri su bitni u Go-u za dva glavna svrhe: **mijenjanje** podataka pozivajućeg (budući da Go prosleđuje po vrijednosti, samo pointer omogućava funkciji da promijeni original) i **učinkovitost** (prosleđivanje pointera izbjegava kopiranje velikih struktura).

Fundamentalni su za metode sa pointer receiverima (standardni način mutiranja struktura) i pojavljuju se svugdje u idiomatskom Go-u.

Razumijevanje `&`/`*`, value-vs-pointer semantike, nil-pointer panike, i da su Go pointeri namjerno *sigurni* (bez aritmetike, upravlja GC) — fokusirani na dijeljenje/mutaciju umjesto C-stilske manipulacije memorijom — temeljno je znanje za pisanje ispravnog, učinkovitog Go-a i česta točka zbunjenosti za početnike i u intervjuima.