Go Academy · Lezione

Che cosa sono i puntatori?

Operatore di indirizzo, dereferenziazione e puntatori nil

Che cosa sono i puntatori? è una lezione Go Academy gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Go Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Go Academy include 4 lezioni in totale.

Indirizzi di memoria

Ogni variabile risiede a un indirizzo di memoria. Un puntatore memorizza quell'indirizzo. In Go, i puntatori sono tipizzati: un *int contiene l'indirizzo di un int.

Operatore address-of &

Utilizzi & per ottenere l'indirizzo di una variabile:

package main
import "fmt"

func main() {
    x := 42
    p := &x
    fmt.Println(p)  // 0xc000... (address)
    fmt.Println(*p) // 42 (value at address)
}

Dereferenziazione *

Utilizzi * per leggere o scrivere il valore all'indirizzo del puntatore:

package main
import "fmt"

func main() {
    n := 10
    p := &n
    *p = 99
    fmt.Println(n) // 99
}

Puntatori nil

Il valore zero di un puntatore è nil. La dereferenziazione di un puntatore nil causa un panic:

package main
import "fmt"

func main() {
    var p *int
    fmt.Println(p)        // <nil>
    fmt.Println(p == nil) // true
    // *p = 1 — PANIC
}

Tipi di puntatore

Ogni tipo di puntatore è specifico rispetto a ciò a cui punta:

package main
import "fmt"

func main() {
    i := 1
    s := "hello"
    pi := &i   // *int
    ps := &s   // *string
    fmt.Printf("%T %T\n", pi, ps) // *int *string
}

Controllo di nil prima dell'uso

Controlli sempre che il puntatore non sia nil prima di dereferenziarlo quando proviene dall'esterno del codice:

package main
import "fmt"

func printInt(p *int) {
    if p == nil {
        fmt.Println("nil pointer")
        return
    }
    fmt.Println(*p)
}

func main() {
    v := 7
    printInt(&v)
    printInt(nil)
}

Puntatori a struct

L'accesso ai campi di una struct tramite un puntatore utilizza la stessa notazione con il punto: Go esegue automaticamente la dereferenziazione:

package main
import "fmt"

type Point struct{ X, Y int }

func main() {
    p := &Point{1, 2}
    p.X = 10         // same as (*p).X = 10
    fmt.Println(*p)  // {10 2}
}

Confronto tra puntatori

Due puntatori sono uguali quando puntano alla stessa variabile (allo stesso indirizzo) oppure sono entrambi nil:

package main
import "fmt"

func main() {
    a := 1
    p1 := &a
    p2 := &a
    p3 := new(int)
    *p3 = 1
    fmt.Println(p1 == p2) // true  — same address
    fmt.Println(p1 == p3) // false — different address
}

Stack e heap

Il compilatore di Go decide se una variabile risiede nello stack o nell'heap tramite la escape analysis. Quando si prende l'indirizzo di una variabile locale e lo si restituisce, Go la sposta automaticamente nell'heap: non è necessario gestire questo processo manualmente.

Quando NON utilizzare i puntatori

Non tutto richiede un puntatore:

I tipi valore piccoli (int, bool, struct piccole) sono più economici da copiare che da dereferenziare
I dati immutabili condivisi tra goroutine sono sicuri come valori
Utilizzi principalmente i puntatori per le modifiche o per le struct grandi

Verifica rapida

Che cosa restituisce l'operatore &?

Riepilogo: puntatori

Punti chiave:

&v ottiene l'indirizzo; *p lo dereferenzia
Il valore zero è nil: controlli sempre prima di dereferenziare
Go esegue automaticamente la dereferenziazione nell'accesso ai campi tramite puntatori a struct
L'escape analysis gestisce automaticamente stack e heap

Traccia per l'esercizio

Scriva una funzione swap(a, b *int) che scambi i valori di due interi utilizzando i puntatori. La chiami da main e stampi i valori prima e dopo.

Domande Frequenti

La lezione «Che cosa sono i puntatori?» è gratuita?

Sì — il testo completo di «Che cosa sono i puntatori?» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Go Academy, passa a CoddyKit PRO. Il corso Go Academy include 4 lezioni in totale.

Cosa imparerò in «Che cosa sono i puntatori?»?

Operatore di indirizzo, dereferenziazione e puntatori nil Eserciti Go Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Go Academy?

Non è richiesta alcuna esperienza precedente. Go Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.

Quanto tempo richiede la lezione «Che cosa sono i puntatori?»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Go Academy?

Sì. Ogni lezione Go Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

← Torna a Go Academy