Come molti altri linguaggi, Go ha i puntatori.
Se è la prima volta che hai a che fare con i puntatori, possono sembrare un po' misteriosi, ma una volta che ci prendi l'abitudine diventano piuttosto semplici.
Sono una parte fondamentale di Go, quindi prenditi un po' di tempo per capirli davvero.
Prima di addentrarci nei dettagli, vale la pena capire a cosa servono i puntatori.
I puntatori sono un modo per condividere la memoria con altre parti del nostro programma, e questo è utile per due motivi principali:
- Quando abbiamo grandi quantità di dati, creare copie da passare tra le funzioni è molto inefficiente.
Passando invece la posizione di memoria in cui i dati sono memorizzati, possiamo ridurre drasticamente l'impronta di risorse dei nostri programmi.
- Passando i puntatori tra le funzioni, possiamo accedere e modificare direttamente l'unica copia dei dati: in questo modo, le modifiche fatte da una funzione sono immediatamente visibili alle altre parti del programma quando la funzione termina.
Variabili e memoria
Diciamo che abbiamo una normale variabile di tipo intero a:
var a int
Quando dichiariamo una variabile, Go deve trovare un posto in memoria dove memorizzarne il valore.
Questo aspetto è in gran parte astratto per noi: quando dobbiamo recuperare il valore memorizzato in quella zona di memoria, possiamo semplicemente riferirci a essa usando il nome della variabile.
Per esempio, quando scriviamo a + 2, in pratica recuperiamo il valore memorizzato nella memoria associata alla variabile a e vi aggiungiamo 2.
Allo stesso modo, quando dobbiamo cambiare il valore nella zona di memoria di a, possiamo usare il nome della variabile per fare un'assegnazione:
a = 3
La zona di memoria associata ad a ora memorizzerà il valore 3.
Puntatori
Mentre le variabili ci permettono di riferirci ai valori in memoria, a volte è utile conoscere l'indirizzo di memoria verso cui punta la variabile. I puntatori contengono gli indirizzi di memoria di quei valori.
Dichiari una variabile di tipo puntatore anteponendo un asterisco al tipo sottostante:
var p *int // 'p' contains the memory address of an integer
Qui dichiariamo una variabile p di tipo «puntatore a int» (*int).
Questo significa che p conterrà l'indirizzo di memoria di un intero.
Il valore zero dei puntatori è nil, perché un puntatore nil non contiene alcun indirizzo di memoria.
Ottenere un puntatore a una variabile
Per trovare l'indirizzo di memoria del valore di una variabile, possiamo usare l'operatore &.
Per esempio, se vogliamo trovare e memorizzare l'indirizzo di memoria della variabile a nel puntatore p, possiamo fare così:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
Accedere al valore tramite un puntatore (dereferenziazione)
Quando abbiamo un puntatore, potremmo voler conoscere il valore memorizzato nell'indirizzo di memoria che il puntatore rappresenta.
Possiamo farlo usando l'operatore *:
var a int
a = 2
var p *int
p = &a // the variable 'p' contains the memory address of 'a'
var b int
b = *p // b == 2
L'operazione *p recupera il valore memorizzato all'indirizzo di memoria contenuto in p.
Questa operazione viene spesso chiamata «dereferenziazione».
Possiamo anche usare l'operatore di dereferenziazione per assegnare un nuovo valore all'indirizzo di memoria a cui il puntatore fa riferimento:
var a int // declare int variable 'a'
a = 2 // assign 'a' the value of 2
var pa *int
pa = &a // 'pa' now contains to the memory address of 'a'
*pa = *pa + 2 // increment by 2 the value at memory address 'pa'
fmt.Println(a) // Output: 4
// 'a' will have the new value that was changed via the pointer!
Assegnare a *pa cambierà il valore memorizzato all'indirizzo di memoria contenuto in pa.
Dato che pa contiene l'indirizzo di memoria di a, assegnando a *pa stiamo di fatto cambiando il valore di a!
Un avvertimento, però: controlla sempre che un puntatore non sia nil prima di dereferenziarlo.
Dereferenziare un puntatore nil farà andare in crash il programma a runtime!
var p *int // p is nil initially
fmt.Println(*p)
// panic: runtime error: invalid memory address or nil pointer dereference
Puntatori a struct
Finora abbiamo visto solo puntatori a valori primitivi.
Possiamo anche creare puntatori a struct:
type Person struct {
Name string
Age int
}
var peter Person
peter = Person{Name: "Peter", Age: 22}
var p *Person
p = &peter
Avremmo anche potuto creare una nuova Person e memorizzare subito un puntatore a essa:
var p *Person
p = &Person{Name: "Peter", Age: 22}
Quando abbiamo un puntatore a una struct, non serve dereferenziare il puntatore prima di accedere a uno dei campi:
var p *Person
p = &Person{Name: "Peter", Age: 22}
fmt.Println(p.Name) // Output: "Peter"
// Go automatically dereferences 'p' to allow
// access to the 'Name' field
Le slice e le map sono già puntatori
Le slice e le map sono tipi speciali, perché nella loro implementazione hanno già dei puntatori.
Questo significa che, il più delle volte, non abbiamo bisogno di creare puntatori per questi tipi per condividere l'indirizzo di memoria dei loro valori.
Immaginiamo di avere una funzione che incrementa il valore di una chiave in una map:
func incrementPeterAge(m map[string]int) {
m["Peter"] += 1
}
Se creiamo una map e chiamiamo questa funzione, le modifiche che la funzione ha fatto alla map rimangono dopo che la funzione è terminata.
È un comportamento simile a quello che otterremmo usando un puntatore, ma nota come in questo esempio non stiamo usando alcun riferimento, alcuna dereferenziazione o altra parte della sintassi dei puntatori:
ages := map[string]int{
"Peter": 21
}
incrementPeterAge(ages)
fmt.Println(ages)
// Output: map[Peter:22]
// The changes the function 'incrementPeterAge' made to the map are visible after the function ends!
Lo stesso vale quando modifichiamo un elemento esistente in una slice.
Tuttavia, le azioni che restituiscono una nuova slice, come append, sono un caso a parte e potrebbero non modificare la slice al di fuori della funzione.
Questo dipende da come funzionano le slice internamente, ma non lo tratteremo in dettaglio in questo esercizio, perché è un argomento più avanzato.
Se sei davvero curioso, puoi leggere di più al riguardo in Go Blog: Mechanics of 'append'
Esercizio di apprendimento
