Aller - Pointeurs

Les pointeurs de Go sont faciles et amusants à apprendre. Certaines tâches de programmation Go sont exécutées plus facilement avec des pointeurs, et d'autres tâches, telles que l'appel par référence, ne peuvent pas être effectuées sans l'utilisation de pointeurs. Il devient donc nécessaire d'apprendre les pointeurs pour devenir un programmeur Go parfait.

Comme vous le savez, chaque variable est un emplacement de mémoire et chaque emplacement de mémoire a son adresse définie, accessible à l'aide de l'opérateur perluète (&), qui indique une adresse en mémoire. Prenons l'exemple suivant, qui affichera l'adresse des variables définies -

package main

import "fmt"

func main() {
   var a int = 10   
   fmt.Printf("Address of a variable: %x\n", &a  )
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Address of a variable: 10328000

Vous avez donc compris ce qu'est l'adresse mémoire et comment y accéder. Voyons maintenant ce que sont les pointeurs.

Que sont les pointeurs?

UNE pointerest une variable dont la valeur est l'adresse d'une autre variable, c'est-à-dire l'adresse directe de l'emplacement mémoire. Comme toute variable ou constante, vous devez déclarer un pointeur avant de pouvoir l'utiliser pour stocker une adresse de variable. La forme générale d'une déclaration de variable de pointeur est -

var var_name *var-type

Ici, typeest le type de base du pointeur; il doit s'agir d'un type de données C valide etvar-nameest le nom de la variable du pointeur. L'astérisque * que vous avez utilisé pour déclarer un pointeur est le même astérisque que vous utilisez pour la multiplication. Cependant, dans cette instruction, l'astérisque est utilisé pour désigner une variable comme pointeur. Voici la déclaration de pointeur valide -

var ip *int        /* pointer to an integer */
var fp *float32    /* pointer to a float */

Le type de données réel de la valeur de tous les pointeurs, qu'il soit entier, flottant ou autre, est le même, un long nombre hexadécimal qui représente une adresse mémoire. La seule différence entre les pointeurs de différents types de données est le type de données de la variable ou de la constante vers laquelle pointe le pointeur.

Comment utiliser les pointeurs?

Il y a quelques opérations importantes, que nous effectuons fréquemment avec des pointeurs: (a) nous définissons des variables de pointeur, (b) assignons l'adresse d'une variable à un pointeur, et (c) accédons à la valeur à l'adresse stockée dans la variable de pointeur .

Toutes ces opérations sont effectuées à l'aide de l'opérateur unaire * qui renvoie la valeur de la variable située à l'adresse spécifiée par son opérande. L'exemple suivant montre comment effectuer ces opérations -

package main

import "fmt"

func main() {
   var a int = 20   /* actual variable declaration */
   var ip *int      /* pointer variable declaration */

   ip = &a  /* store address of a in pointer variable*/

   fmt.Printf("Address of a variable: %x\n", &a  )

   /* address stored in pointer variable */
   fmt.Printf("Address stored in ip variable: %x\n", ip )

   /* access the value using the pointer */
   fmt.Printf("Value of *ip variable: %d\n", *ip )
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

Address of var variable: 10328000
Address stored in ip variable: 10328000
Value of *ip variable: 20

Aucun pointeur en Go

Le compilateur Go attribue une valeur Nil à une variable de pointeur au cas où vous n'auriez pas d'adresse exacte à attribuer. Cela se fait au moment de la déclaration des variables. Un pointeur qui est attribué à zéro est appelé unnil aiguille.

Le pointeur nil est une constante avec une valeur de zéro définie dans plusieurs bibliothèques standard. Considérez le programme suivant -

package main

import "fmt"

func main() {
   var  ptr *int

   fmt.Printf("The value of ptr is : %x\n", ptr  )
}

Lorsque le code ci-dessus est compilé et exécuté, il produit le résultat suivant -

The value of ptr is 0

Sur la plupart des systèmes d'exploitation, les programmes ne sont pas autorisés à accéder à la mémoire à l'adresse 0 car cette mémoire est réservée par le système d'exploitation. Cependant, l'adresse mémoire 0 a une signification particulière; il signale que le pointeur n'est pas destiné à pointer vers un emplacement mémoire accessible. Mais par convention, si un pointeur contient la valeur nil (zéro), il est supposé ne pointer vers rien.

Pour rechercher un pointeur nul, vous pouvez utiliser une instruction if comme suit -

if(ptr != nil)     /* succeeds if p is not nil */
if(ptr == nil)    /* succeeds if p is null */

Go Pointers en détail

Les pointeurs ont des concepts nombreux mais simples et ils sont très importants pour la programmation Go. Les concepts de pointeurs suivants devraient être clairs pour un programmeur Go -

Sr.Non	Concept et description
1	Go - Tableau de pointeurs Vous pouvez définir des tableaux pour contenir un certain nombre de pointeurs.
2	Aller - Pointeur vers pointeur Aller vous permet d'avoir un pointeur sur un pointeur et ainsi de suite.
3	Passer des pointeurs vers des fonctions dans Go Le passage d'un argument par référence ou par adresse permet tous deux de modifier l'argument passé dans la fonction appelante par la fonction appelée.