Puntatore del linguaggio Go

Un puntatore in Go è una variabile che memorizza l'indirizzo di memoria di un'altra variabile. I puntatori in Golang sono anche noti come variabili speciali.VariabileUtilizzato per memorizzare alcuni dati in un indirizzo di memoria specifico del sistema. Trovare sempre l'indirizzo di memoria in formato esadecimale (iniziale con 0x, come 0xFFAAF ecc.).

Il ruolo del puntatore?
Per comprendere questo tipo di puntatore, dobbiamo prima comprendere il concetto di variabile. Una variabile è un nome assegnato a una posizione di archiviazione dati. Per accedere ai dati memorizzati, abbiamo bisogno dell'indirizzo di archiviazione specifico. Ricordare manualmente tutti gli indirizzi di memoria (in formato esadecimale) è un onere, ecco perché utilizziamo le variabili per memorizzare dati e possiamo accedere ai dati tramite il nome della variabile.
Golang permette anche di salvare numeri esadecimali nelle variabili utilizzando espressioni letterali, ossia, da0xIl numero iniziale è un numero esadecimale.

Esempio:Nel seguente programma, memorizzeremo numeri esadecimali nelle variabili. Ma come potete vedere, il tipo dei valori èinte salvato come decimale, o si può direintIl valore decimale del tipo è memorizzato. Tuttavia, il punto principale di questo esempio è che memorizziamo valori esadecimali (considerati come indirizzi di memoria), ma non sono puntatori perché non puntano a nessun altro indirizzo di memoria di un'altra variabile. È semplicemente una variabile definita dall'utente. Pertanto, è necessario utilizzare i puntatori.

// Archiviazione valore esadecimale
package main
import "fmt"
func main() {
　　　　// Archiviazione esadecimale
　　　　// Valore nella variabile
　　　　x := 0xFF
　　　　y := 0x9C
　　　　// Visualizzazione dei valori
　　　　fmt.Printf("Il tipo della variabile x è %T\n", x)
　　　　fmt.Printf("Il valore esadecimale di x è %X\n", x)
　　　　fmt.Printf("Il valore decimale di x è %v\n", x)
　　　　fmt.Printf("Il tipo della variabile y è %T\n", y)
　　　　fmt.Printf("Il valore esadecimale di y è %X\n", y)
　　　　fmt.Printf("Il valore decimale di y è %v\n", y)
}

Output:

Il tipo della variabile x è int
Il valore esadecimale di x è FF
Il valore decimale di x è 255
Il tipo della variabile y è int
Il valore esadecimale di y è 9C
Il valore decimale di y è 156

Un puntatore è una variabile speciale che non solo viene utilizzata per memorizzare l'indirizzo di memoria di altre variabili, ma anche per puntare a una posizione nella memoria e fornire un metodo per trovare il valore memorizzato in quella posizione nella memoria. È noto come variabile di tipo speciale perché quasi viene dichiarata come variabile, ma con*（Operatore di dereferimento）。

Dichiarazione e inizializzazione dei puntatori

Prima di iniziare, utilizzeremo due operatori importanti nei puntatori:

Operatore * noto anche come operatore di dereferimento, utilizzato per dichiarare variabili puntatore e accedere ai valori memorizzati all'indirizzo di memoria.

Operatore & Chiamato operatore di indirizzo, utilizzato per restituire l'indirizzo della variabile o accedere all'indirizzo della variabile tramite un puntatore.

Dichiarare un puntatore:

var pointer_name *Data_Type

Esempio:Di seguito è riportato un puntatore di tipo stringa, che può memorizzare soloStringaL'indirizzo della memoria del variabile.

var s *string

Inizializzazione del puntatore:Per questo, devi utilizzare l'operatore di indirizzo per inizializzare il puntatore con l'indirizzo della memoria di un altro variabile, come nell'esempio seguente:

//Dichiarazione della variabile comune
var a = 45
//Inizializzare il puntatore s
//Indirizzo della memoria della variabile a
var s *int = &a

//Programma Golang per illustrare la dichiarazione
//E l'inizializzazione del puntatore
package main
import "fmt"
func main() {
　　　　//Definire una variabile comune
　　　　var x int = 5748
　　　　//Dichiarazione del puntatore
　　　　var p *int
　　　　//Inizializzare il puntatore
　　　　p = &x
　　　　//Mostra il risultato
　　　　fmt.Println("Il valore memorizzato in x = ", x)
　　　　fmt.Println("L'indirizzo della memoria di x = ", &x)
　　　　fmt.Println("Il valore memorizzato nella variabile p = ", p)
}

Output:

Il valore memorizzato in x = 5748
L'indirizzo della memoria di x = 0xc000066090
Il valore memorizzato nella variabile p = 0xc000066090

Cosa importante:

• Il valore predefinito o il valore zero del puntatore è sempre nil. O puoi dire che il puntatore non inizializzato avrà sempre un valore nil.

  Esempio

  //Valore nil del puntatore
  package main
  import "fmt"
  func main() {
  　　　　//Definire il puntatore
  　　　　var s *int
  　　　　//Mostra il risultato
  　　　　fmt.Println("s = ", s)
  }

  Output:

  s = nil

• La dichiarazione e l'inizializzazione del puntatore possono essere completate in una riga.

  var s *int = &a

• Se si desidera specificare contemporaneamente il tipo di dati e la dichiarazione del puntatore, il puntatore sarà in grado di gestire l'indirizzo della memoria del tipo di dati specificato. Ad esempio, se si utilizza un puntatore di tipo stringa, l'indirizzo del variabile fornito al puntatore sarà solo il tipo di dati variabile stringa e non altri tipi.

• Per superare i problemi sopra menzionati, è possibile utilizzarechiave varIl concetto di inferenza del tipo. Durante la dichiarazione non è necessario specificare il tipo di dati. Il tipo della variabile puntatore può anche essere determinato dal compilatore come una variabile comune. In questo esempio, non utilizzeremo l'operatore *. Quando inizializziamo una variabile con l'indirizzo di un altro variabile, essa sarà determinata internamente dal compilatore.

  Esempio

  //Programma Golang per illustrare
  //utilizzando l'inferenza del tipo
  //variabile puntatore
  package main
  import "fmt"
  func main() {
  　　　　//Usare la chiave var
  　　　　//Non abbiamo definito
  　　　　//Qualsiasi tipo di variabile con
  　　　　var y = 458
  　　　　//Usare il variabile puntatore
  　　　　//Chiave var, senza specificare
  　　　　//Tipo
  　　　　var p = &y
  　　　　fmt.Println("Il valore memorizzato in y = ", y)
  　　　　fmt.Println("L'indirizzo di y = ", &y)
  　　　　fmt.Println("Il valore memorizzato nel variabile puntatore p = ", p)
  }

  Output:

  Il valore memorizzato in y = 458
  L'indirizzo di y = 0xc0000120a8
  Il valore memorizzato nel variabile puntatore p = 0xc0000120a8

• Puoi anche usaresintassi abbreviata (: =)La sintassi per dichiarare e inizializzare una variabile puntatore. Se utilizziamo&(indirizzo)L'operatore passinga l'indirizzo della variabile a se stesso, il compilatore determinerà internamente che la variabile è una variabile puntatore.

  Esempio

  //Programma Golang per illustrare
  //utilizzando la sintassi di abbreviazione
  //variabile puntatore
  package main
  import "fmt"
  func main() {
  　　　　//Usare l'operatore := per la dichiarazione
  　　　　//Inizializzare il variabile
  　　　　y := 458
  　　　　//Usare un variabile puntatore
  　　　　//Assegnato tramite :=
  　　　　//Indirizzo del variabile y
  　　　　p := &y
  　　　　fmt.Println("Il valore memorizzato in y = ", y)
  　　　　fmt.Println("L'indirizzo di y = ", &y)
  　　　　fmt.Println("Il valore memorizzato nel variabile puntatore p = ", p)
  }

  Output:

  Il valore memorizzato in y = 458
  L'indirizzo di y = 0xc000066090
  Il valore memorizzato nel variabile puntatore p = 0xc000066090

De-referenziazione del puntatore

Noto a tutti, l'operatore * anche chiamato operatore di de-referenziazione. Non solo viene utilizzato per dichiarare il variabile puntatore, ma anche per accedere al valore memorizzato nel variabile puntatore, che di solito viene chiamatoIndiretto o de-referenziazione.L'operatore * anche chiamato valore all'indirizzoFacciamo un esempio per capire meglio questo concetto:

//Esempio di programma Go
//Il concetto di de-referenziazione
package main
import "fmt"
func main() {
　　　　//Usare la chiave var
　　　　//Non abbiamo definito
　　　　//Qualsiasi tipo di variabile con
　　　　var y = 458
　　　　//Usare il variabile puntatore
　　　　//Chiave var, senza specificare
　　　　//Tipo
　　　　var p = &y
　　　　fmt.Println("Il valore memorizzato in y = ", y)
　　　　fmt.Println("L'indirizzo di y = ", &y)
　　　　fmt.Println("Il valore memorizzato nel variabile puntatore p = ", p)
　　　　//Questo è il de-referenziazione del puntatore
　　　　//Usare l'operatore * prima del puntatore
　　　　//Il variabile accede al valore memorizzato
　　　　//Punta a un variabile
　　　　fmt.Println("Il valore memorizzato in y(*p) = ", *p)
}

Output:

Il valore memorizzato in y = 458
L'indirizzo di y = 0xc0000120a8
Il valore memorizzato nel variabile puntatore p = 0xc0000120a8
Il valore memorizzato in y(*p) = 458

Puoi anche modificare il valore del puntatore o la posizione nella memoria, invece di assegnare un nuovo valore al variabile.

package main
import "fmt"
func main() {
　　　　//Usare la chiave var
　　　　//Non abbiamo definito
　　　　//Non specificato il tipo del variabile
　　　　var y = 458
　　　　//Usare il variabile puntatore
　　　　//Chiave var, senza specificare il tipo
　　　　var p = &y
　　　　fmt.Println("Il valore memorizzato in y = ", y)
　　　　fmt.Println("L'indirizzo di y = ", &y)
　　　　fmt.Println("Il valore memorizzato nel variabile puntatore p = ", p)
　　　　//Questo è il de-referenziazione del puntatore
　　　　//Usare l'operatore * prima del puntatore
　　　　//Il variabile accede al valore memorizzato
　　　　//Punta a un variabile
　　　　fmt.Println("Il valore memorizzato in y(*p) prima della modifica = ", *p)
　　　　//Cambiare il valore di y
　　　　//Nuovo valore del puntatore
　　　　*p = 500
　　　　fmt.Println("Il valore memorizzato in y(*p) dopo la modifica = ", y)
}

Output:

Il valore memorizzato in y prima della modifica = 458
L'indirizzo di y = 0xc0000120a8
Il valore memorizzato nel variabile puntatore p = 0xc0000120a8
Il valore memorizzato in y(*p) prima della modifica = 458
Il valore memorizzato in y(*p) dopo la modifica = 500