Puntatori in Golang: & e *, new, nil e quando usarli

& e *

Un puntatore contiene l'indirizzo di memoria di un valore. &x ti dà un puntatore a x. *p segue il puntatore fino al valore.

package main

import "fmt"

func main() {
	x := 10
	p := &x // p has type *int

	fmt.Println(*p) // read through the pointer: 10
	*p = 20         // write through the pointer
	fmt.Println(x)  // x changed: 20

	fmt.Printf("%T\n", p)
	fmt.Println(p != nil)
}

L'asterisco ha due ruoli. In un tipo (*int) significa "puntatore a int". In un'espressione (*p) significa "il valore a cui punta p". Stampare p da solo mostra un indirizzo come 0xc000012345, che cambia da un'esecuzione all'altra.

Perché esistono i puntatori: condividere invece di copiare

Go passa tutto per valore. Una funzione riceve una copia di ogni argomento, quindi non può cambiare la variabile di chi la chiama. Passare un puntatore copia invece l'indirizzo, ed entrambe le parti raggiungono lo stesso valore.

package main

import "fmt"

func doubleCopy(n int) {
	n *= 2
}

func doublePtr(n *int) {
	*n *= 2
}

func main() {
	v := 21
	doubleCopy(v)
	fmt.Println(v) // 21

	doublePtr(&v)
	fmt.Println(v) // 42
}

Go non ha riferimenti nel senso del C++. In Go "passare per riferimento" significa passare un puntatore per valore.

Puntatori a struct

I puntatori a struct sono i puntatori più comuni nel codice Go. L'accesso ai campi dereferenzia in automatico: p.Name significa (*p).Name.

package main

import "fmt"

type Account struct {
	Owner   string
	Balance int
}

func (a *Account) Deposit(n int) {
	a.Balance += n // no explicit * needed
}

func main() {
	acc := &Account{Owner: "Ana"} // pointer to a new struct
	acc.Deposit(100)
	acc.Balance -= 30
	fmt.Println(acc.Owner, acc.Balance)

	same := acc
	same.Balance = 0
	fmt.Println(acc.Balance) // 0: both variables point at one Account
}

I metodi seguono la stessa logica: un receiver puntatore permette al metodo di cambiare la struct. La pagina sui metodi tratta la scelta tra receiver valore e receiver puntatore.

new

new(T) alloca un T azzerato e restituisce il suo indirizzo. È come dichiarare una variabile e prenderne l'indirizzo.

p := new(int) // *int pointing at 0
var x int
q := &x           // same thing, two lines
a := new(Account) // same as &Account{}

In pratica per le struct è più comune &T{...}, perché permette di impostare i campi nella stessa espressione. new è comodo per i puntatori a tipi di base. Non confonderlo con make, che costruisce slice, map e channel e li restituisce pronti all'uso, non come puntatori.

Restituire un puntatore a una variabile locale è sicuro

In C, restituire l'indirizzo di una variabile locale è un bug. In Go è codice normale.

package main

import "fmt"

type Config struct {
	Port int
	Mode string
}

func defaultConfig() *Config {
	c := Config{Port: 8080, Mode: "dev"}
	return &c // c outlives the call, so it lives on the heap
}

func main() {
	cfg := defaultConfig()
	cfg.Mode = "prod"
	fmt.Printf("%+v\n", *cfg)
}

L'escape analysis del compilatore decide se un valore vive sullo stack o sull'heap. Non scegli mai tu, e non liberi mai la memoria: il garbage collector la recupera quando niente vi punta più. go build -gcflags=-m stampa queste decisioni, se sei curioso.

Puntatori nil

Lo zero value di qualsiasi tipo puntatore è nil. Dereferenziare nil va in panic.

package main

import "fmt"

type Node struct {
	Val  int
	Next *Node
}

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	list := &Node{Val: 1, Next: &Node{Val: 2}}
	for n := list; n != nil; n = n.Next {
		fmt.Println(n.Val)
	}

	var missing *Node
	fmt.Println(missing == nil)
	fmt.Println(missing.Val) // panics
}

Output:

1
2
true
recovered: runtime error: invalid memory address or nil pointer dereference

Senza il recover, il programma crasherebbe con quel messaggio e uno stack trace che inizia con panic: runtime error: invalid memory address or nil pointer dereference e [signal SIGSEGV: segmentation violation ...]. Le fonti abituali:

• una variabile puntatore o un campo di una struct mai impostati
• m[key] su una map[string]*T per una chiave mancante, che restituisce nil
• ignorare un errore: f, _ := os.Open(path) lascia f a nil in caso di fallimento
• un metodo con receiver puntatore chiamato su un puntatore nil, che poi legge un campo

Chiamare un metodo su un puntatore nil è di per sé permesso. Il panic avviene solo quando il metodo tocca i campi del receiver.

Quando usare un puntatore

Usa un puntatore quando:

• una funzione o un metodo deve cambiare il valore di chi chiama
• il valore è una struct grande e viene passato in giro spesso
• il tipo non deve essere copiato (contiene un sync.Mutex, o rappresenta una risorsa unica come una connessione)
• ti serve esprimere "nessun valore" con nil, per esempio un campo facoltativo in una struct JSON (*int distingue "assente" da 0)

Non usare un puntatore quando:

• il valore è piccolo e di sola lettura (time.Time, un Point)
• il tipo si comporta già come un riferimento: slice, map, channel, funzioni e interface raramente hanno bisogno di un * davanti. Un *[]int o una *map[string]int sono quasi sempre un errore

I puntatori non sono automaticamente più veloci. Copiare una struct piccola costa poco, e un puntatore può forzare un'allocazione sull'heap e aggiungere lavoro al garbage collector.

Puntatori e variabili del ciclo

Prendere l'indirizzo di una variabile del ciclo è sicuro da Go 1.22, perché ogni iterazione ha la sua variabile:

package main

import "fmt"

func main() {
	var ptrs []*int
	for i := range 3 {
		ptrs = append(ptrs, &i)
	}
	for _, p := range ptrs {
		fmt.Print(*p, " ")
	}
	fmt.Println()
}

Stampa 0 1 2. Prima di Go 1.22 (che ha introdotto anche range 3), lo stesso ciclo scritto come for i := 0; i < 3; i++ stampava 3 3 3, perché tutti e tre i puntatori condividevano una sola variabile. Nota che &v in for _, v := range items punta a una copia dell'elemento, non all'elemento nella slice. Per avere un puntatore all'elemento stesso, usa &items[i].

Errori comuni

• Dereferenziare senza controllare. Controlla if p == nil ovunque nil sia possibile.
• Puntatore al valore di un range. &v punta a una copia; usa &s[i].
• Puntatori a slice e map. Servono raramente. Restituisci invece la nuova slice.
• Tenere &s[i] attraverso un append. Se append rialloca, il puntatore fa ancora riferimento al vecchio array e le scritture successive finiscono in un posto che nessuno vede.