Come funzionano i puntatori in Go?

Question

Accepted Answer

Un **puntatore** contiene l'**indirizzo di memoria** di un valore piuttosto che il valore stesso. Go ha puntatori (come C) ma li mantiene semplici e sicuri — niente aritmetica dei puntatori, e il garbage collector gestisce la memoria. Vengono utilizzati per condividere e modificare i dati in modo efficiente.

## I due operatori: & e *

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

`&` prende l'indirizzo di una variabile; `*` (su un puntatore) accede o imposta il valore a cui punta.

## Perché è importante: modificare tramite funzioni

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

Poiché Go passa gli argomenti **per valore** (copie), una funzione può modificare i dati del chiamante solo se riceve un **puntatore** ad essi. Questo è il motivo principale per utilizzare i puntatori.

## Puntatori con struct (molto comune)

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

I ricevitori di puntatore sono il modo in cui i metodi mutano il loro struct, e passare puntatori a struct evita di copiare struct grandi.

## Il puntatore nil e il valore zero

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

Dereferenziare un puntatore `nil` causa un panic — un errore di runtime comune da cui guardarsi.

## Ciò che i puntatori di Go NON hanno (sicurezza)

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

## Perché è importante

I puntatori sono essenziali in Go per due scopi principali: **modificare** i dati del chiamante (poiché Go passa per valore, solo un puntatore consente a una funzione di cambiare l'originale) e **efficienza** (passare un puntatore evita di copiare struct grandi).

Sono fondamentali per i metodi con ricevitori di puntatore (il modo standard per mutare struct) e appaiono in tutto Go idiomatico.

Comprendere `&`/`*`, la semantica valore-vs-puntatore, il panic del puntatore nil, e che i puntatori di Go sono deliberatamente *sicuri* (niente aritmetica, gestiti da GC) — concentrati sulla condivisione/mutazione piuttosto che sulla manipolazione della memoria nello stile C — è una conoscenza fondamentale per scrivere Go corretto ed efficiente ed è un punto di confusione frequente per i nuovi arrivati e nei colloqui.