Pointeur du langage Go

Un pointeur en langage de programmation Go est une variable utilisée pour stocker l'adresse mémoire d'une autre variable. Les pointeurs en Golang sont également appelés variables spéciales.VariableUtilisé pour stocker des données à une adresse mémoire spécifique dans le système. Toutes les adresses mémoire sont toujours trouvées en format hexadécimal (commençant par 0x, comme 0xFFAAF, etc.).

Quel est le rôle du pointeur ?
Pour comprendre ce pointeur, nous devons d'abord comprendre le concept de variable. Une variable est un nom attribué à un emplacement de stockage de données réel. Pour accéder aux données stockées, nous avons besoin de l'adresse de cet emplacement de stockage spécifique. Se souvenir manuellement de toutes les adresses mémoire (au format hexadécimal) est un coût, c'est pourquoi nous utilisons des variables pour stocker des données et pouvons accéder aux variables uniquement en utilisant leur nom.
Golang permet également d'utiliser des expressions littérales pour stocker des nombres hexadécimaux dans des variables, c'est-à-dire, à partir de0xLe nombre commence par un nombre hexadécimal.

Exemple :Dans le programme suivant, nous stockons un nombre hexadécimal dans une variable. Mais vous pouvez voir que le type de la valeur estintet est sauvegardée en décimal, ou autrement ditintLa valeur décimale du type est en cours de stockage. Cependant, le point principal de cet exemple est que nous stockons une valeur hexadécimale (considérée comme une adresse mémoire), mais ce n'est pas un pointeur, car il ne pointe pas vers une autre position mémoire de toute autre variable. C'est simplement une variable définie par l'utilisateur. Par conséquent, il faut utiliser un pointeur.

//La valeur hexadécimale stockée
package main
import "fmt"
func main() {
　　　　//Stockée en hexadécimal
　　　　//La valeur dans la variable
　　　　x := 0xFF
　　　　y := 0x9C
　　　　//　Affichage de la valeur
　　　　fmt.Printf("Le type de la variable x est %T\n", x)
　　　　fmt.Printf("La valeur hexadécimale de x est %X\n", x)
　　　　fmt.Printf("La valeur décimale de x est %v\n", x)
　　　　fmt.Printf("Le type de la variable y est %T\n", y)
　　　　fmt.Printf("La valeur hexadécimale de y est %X\n", y)
　　　　fmt.Printf("La valeur décimale de y est %v\n", y)
}

Sortie :

Le type de variable x est  int
La valeur hexadécimale de x est  FF
La valeur décimale de x est　255
Le type de variable y est  int
La valeur hexadécimale de y est　9C
La valeur décimale de y est　156

Un pointeur est un type de variable spécial, qui non seulement est utilisé pour stocker l'adresse mémoire d'autres variables, mais également pour pointer vers une position mémoire et fournir une méthode pour rechercher la valeur stockée à cette position mémoire. Il est généralement appelé un type spécial de variable, car il est presque déclaré comme une variable, mais avec*（déréférence opérateur).

Déclaration et initialisation de pointeur

Avant de commencer, nous utiliserons deux opérateurs importants dans les pointeurs, à savoir

*Opérateur Also called dereference operator, used to declare pointer variables and access the value stored at the address.

＆opérateur Appelé opérateur d'adresse, utilisé pour retourner l'adresse d'une variable ou pour accéder à l'adresse de pointeur de la variable.

Déclarer un pointeur:

var pointer_name　*Data_Type

Exemple :Voici un pointeur de type chaîne, qui ne peut stocker queChaîneL'adresse mémoire d'une variable.

var s　*string

Initialisation de pointeur :Pour cela, vous devez utiliser l'opérateur d'adresse pour initialiser le pointeur avec l'adresse mémoire d'une autre variable, comme dans l'exemple suivant :

//Déclaration de variable normale
var a =　45
//Initialiser le pointeur s
//L'adresse mémoire de la variable a
var s　*int = &a

//　Un programme Go pour démontrer la déclaration
//et l'initialisation de pointeur
package main
import "fmt"
func main() {
　　　　//Définir une variable normale
　　　　var x int =　5748
　　　　//Déclaration de pointeur
　　　　var p　*int
　　　　//Initialiser un pointeur
　　　　p = &x
　　　　//Résultat affiché
　　　　fmt.Println("La valeur stockée dans x = ",  x)
　　　　fmt.Println("L'adresse mémoire de x = ",  &x)
　　　　fmt.Println("La valeur stockée dans la variable p = ",  p)
}

Sortie :

La valeur stockée dans x =　　5748
L'adresse mémoire de x = 0xc000066090
La valeur stockée dans la variable p = 0xc000066090

Remarque importante :

• La valeur par défaut ou zéro d'un pointeur est toujours nil. Ou, vous pouvez dire que le pointeur non initialisé aura toujours une valeur nil.

  Exemple

  //La valeur nil d'un pointeur
  package main
  import "fmt"
  func main() {
  　　　　//Définir un pointeur
  　　　　var s　*int
  　　　　//　Résultat affiché
  　　　　fmt.Println("s = ",  s)
  }

  Sortie :

  s =  <nil>

• La déclaration et l'initialisation des pointeurs peuvent être effectuées en une seule ligne.

  var s　*int = &a

• Si vous souhaitez spécifier à la fois le type de données et la déclaration de pointeur, le pointeur pourra gérer l'adresse mémoire du type de données spécifié. Par exemple, si vous utilisez un pointeur de type chaîne, l'adresse de la variable fournie au pointeur ne sera que de type de données chaîne, et non d'autres types.

• Pour surmonter ce problème, vous pouvez utiliserla clé varLe concept d'inference de type. Il n'est pas nécessaire de spécifier le type de données pendant la déclaration. Le type d'une variable pointeur peut également être déterminé par le compilateur comme une variable ordinaire. Ici, nous ne utiliserons pas*L'opérateur. Lorsque nous utilisons l'adresse d'une autre variable pour initialiser une variable, elle est déterminée internement par le compilateur.

  Exemple

  //　Programme en Golang pour démontrer
  //Pour faire la déduction de type
  //Variable de pointeur
  package main
  import "fmt"
  func main() {
  　　　　//Utilisation du mot-clé var
  　　　　//Nous n'avons pas défini
  　　　　//Tous les types de variables
  　　　　var y =　458
  　　　　//Utilisation de la variable de pointeur
  　　　　//　Le mot-clé var, sans spécifier
  　　　　//Type
  　　　　var p = &y
  　　　　fmt.Println("La valeur stockée dans y vaut = ", y)
  　　　　fmt.Println("L'adresse de y vaut = ", &y)
  　　　　fmt.Println("La valeur stockée dans la variable de pointeur p vaut = ", p)
  }

  Sortie :

  La valeur stockée dans y vaut =　　458
  L'adresse de y vaut = 0xc0000120a8
  La valeur stockée dans la variable de pointeur p vaut = 0xc0000120a8

• Vous pouvez également utiliserAbréviation （:=）La syntaxe pour déclarer et initialiser une variable de pointeur. Si nous utilisons＆（adresse）Si l'opérateur passe l'adresse d'une variable à un opérateur, le compilateur détermine internement que la variable est un pointeur.

  Exemple

  //　Programme en Golang pour démontrer
  //Utiliser la syntaxe abrégée dans
  //Variable de pointeur
  package main
  import "fmt"
  func main() {
  　　　　//Déclarer en utilisant l'opérateur :=
  　　　　//Et initialiser la variable
  　　　　y :=　458
  　　　　//En utilisant une variable de pointeur
  　　　　//Allouée par :=
  　　　　//L'adresse de la variable y
  　　　　p := &y
  　　　　fmt.Println("La valeur stockée dans y vaut = ", y)
  　　　　fmt.Println("L'adresse de y vaut = ", &y)
  　　　　fmt.Println("La valeur stockée dans la variable de pointeur p vaut = ", p)
  }

  Sortie :

  La valeur stockée dans y vaut =　　458
  L'adresse de y vaut = 0xc000066090
  La valeur stockée dans la variable de pointeur p vaut = 0xc000066090

Désréférencement du pointeur

Il est bien connu que,*L'opérateur est également appelé opérateur de désréférencement. Il n'est pas seulement utilisé pour déclarer une variable de pointeur, mais aussi pour accéder à la valeur stockée dans la variable pointée, et est généralement appeléIndirect ou désréférencement。*L'opérateur est également appelé valeur à l'adresse。Pour mieux comprendre ce concept, posons un exemple :

//　Exemple de programme en Golang
//Le concept de désréférencement du pointeur
package main
import "fmt"
func main() {
　　　　//Utilisation du mot-clé var
　　　　//Nous n'avons pas défini
　　　　//Tous les types de variables
　　　　var y =　458
　　　　//Utilisation de la variable de pointeur
　　　　//　Le mot-clé var, sans spécifier
　　　　//Type
　　　　var p = &y
　　　　fmt.Println("La valeur stockée dans y vaut = ", y)
　　　　fmt.Println("L'adresse de y vaut = ", &y)
　　　　fmt.Println("La valeur stockée dans la variable de pointeur p vaut = ", p)
　　　　//C'est l'opération de désréférencement du pointeur
　　　　//Utilisé avant le pointeur*Opérateur
　　　　//Les variables pour accéder aux valeurs stockées
　　　　//Pointe vers la variable qu'elle pointe
　　　　fmt.Println("La valeur stockée dans y vaut (*p) = "　*p)
}

Sortie :

La valeur stockée dans y vaut =　　458
L'adresse de y vaut = 0xc0000120a8
La valeur stockée dans la variable de pointeur p vaut = 0xc0000120a8
La valeur stockée dans y vaut (*p) =　　458

Vous pouvez également modifier la valeur du pointeur ou l'emplacement en mémoire, au lieu d'allouer une nouvelle valeur à la variable.

package main
import "fmt"
func main() {
　　　　//Utilisation du mot-clé var
　　　　//Nous n'avons pas défini
　　　　//Le type de la variable n'est pas spécifié
　　　　var y =　458
　　　　//Utilisation de la variable de pointeur
　　　　//　Le mot-clé var, sans spécifier de type
　　　　var p = &y
　　　　fmt.Println("La valeur stockée avant modification dans y vaut = ", y)
　　　　fmt.Println("L'adresse de y vaut = ", &y)
　　　　fmt.Println("La valeur stockée dans la variable de pointeur p vaut = ", p)
　　　　//C'est l'opération de désréférencement du pointeur
　　　　//Utilisé avant le pointeur*Opérateur
　　　　//Les variables pour accéder aux valeurs stockées
　　　　//Pointe vers la variable qu'elle pointe
　　　　fmt.Println("La valeur stockée avant modification dans y(*La valeur dans p) vaut = "　*p)
　　　　//Modification de la valeur de y par affectation
　　　　//La nouvelle valeur du pointeur
　　　　*p =　500
　　　　fmt.Println("La valeur stockée après modification dans y(*La valeur dans p) vaut = ", y)
}

Sortie :

La valeur stockée avant modification dans y vaut =　　458
L'adresse de y vaut = 0xc0000120a8
La valeur stockée dans la variable de pointeur p vaut = 0xc0000120a8
La valeur stockée avant modification dans y(*p) valeur　　458
La valeur stockée après modification dans y(*p) valeur　　500