|
Les pointeurs dans Go sont un outil puissant pour gérer la mémoire et manipuler les données. Ils fournissent un moyen de référencer directement l’adresse mémoire d’une variable, permettant un accès et une manipulation efficaces des structures de données.
Qu'est-ce qu'un pointeur ?
En Go, un pointeur est une variable qui stocke l'adresse d'une autre variable. L'adresse est l'emplacement mémoire unique où la variable est stockée. Les pointeurs sont créés à l'aide de l'opérateur `&`, qui renvoie l'adresse d'une variable.
Par exemple, disons que nous avons une variable « numéro » de type « int ». Nous pouvons créer un pointeur vers `number` en utilisant l'opérateur `&` :
``` va
nombre :=10
pointeur :=&numéro
```
La variable « pointeur » stocke désormais l'adresse mémoire de la variable « numéro ».
Déréférencer un pointeur
Pour accéder à la valeur d'un pointeur, on peut utiliser l'opérateur `*`. L'opérateur `*` déréférence un pointeur, renvoyant la valeur stockée à l'adresse mémoire que contient le pointeur.
Dans notre exemple, nous pouvons déréférencer la variable `pointer` pour accéder à la valeur de la variable `number` :
``` va
numéro déréférencé :=*pointeur
```
La variable `dereferencedNumber` stocke désormais la valeur de la variable `number`, qui est 10.
Arithmétique des pointeurs
Les pointeurs peuvent également être utilisés pour effectuer des calculs arithmétiques. L'arithmétique du pointeur est le processus d'ajout ou de soustraction d'entiers à un pointeur pour modifier l'adresse mémoire à laquelle il fait référence.
Par exemple, disons que nous avons un tableau d'entiers appelé « arr » et que nous voulons parcourir les éléments du tableau. Nous pouvons utiliser l'opérateur `+` pour ajouter un entier à un pointeur afin de passer à l'élément suivant du tableau :
``` va
arr :=[5]int{1, 2, 3, 4, 5}
// Initialise un pointeur sur le premier élément du tableau
pointeur :=&arr[0]
// Parcourir le tableau en utilisant l'arithmétique du pointeur
pour je :=0; je
// Déréférencer le pointeur pour obtenir la valeur à l'index actuel
valeur :=*pointeur
// Imprimer la valeur
fmt.Println(valeur)
// Incrémente le pointeur pour passer à l'élément suivant du tableau
pointeur++
}
```
Dans cet exemple, le pointeur `pointer` est initialement défini sur l'adresse du premier élément du tableau. Ensuite, la boucle « for » parcourt le tableau, déréférençant le « pointeur » à chaque itération pour obtenir la valeur de l'élément actuel. Le « pointeur » est ensuite incrémenté pour passer à l'élément suivant du tableau.
Passer des pointeurs vers des fonctions
Les pointeurs peuvent être passés comme arguments aux fonctions. Cela permet aux fonctions de manipuler directement l'adresse mémoire des variables, plutôt que de créer une copie de la variable.
Par exemple, disons que nous avons une fonction appelée « incrément » qui incrémente la valeur d'un entier. Nous pouvons passer un pointeur sur un entier comme argument à la fonction `increment`, permettant à la fonction de modifier directement la valeur de l'entier :
``` va
incrément de fonction (ptr *int) {
// Déréférencer le pointeur pour obtenir la valeur à l'adresse mémoire
valeur :=*ptr
// Incrémente la valeur
valeur++
// Stocke la valeur incrémentée à l'adresse mémoire
*ptr =valeur
}
fonction main() {
// Crée une variable entière
nombre :=10
// Passe un pointeur vers la variable en argument à la fonction d'incrémentation
incrément (&numéro)
// Affiche la valeur incrémentée
fmt.Println(numéro) // Sortie :11
}
```
Dans cet exemple, la fonction `increment` prend un pointeur vers un entier comme argument. La fonction déréférence le pointeur pour obtenir la valeur à l'adresse mémoire, incrémente la valeur,
|
