Les Pointeurs en Go

Introduction aux Pointeurs

Les pointeurs en Go constituent un concept fondamental qui permet d'interagir directement avec la mémoire d'un programme. Un pointeur est capable de stocker l'adresse mémoire d'une variable. Cela peut s'avérer être un outil puissant pour accéder à la valeur se trouvant à cette adresse mémoire précise et pour la modifier.

Déclaration d'un Pointeur

Pour déclarer un pointeur en Go, il faut utiliser l'opérateur de déréférencement (*) avant le type de données. Cela signifie que la variable représente un pointeur vers ce type. Pour attribuer à ce pointeur l'adresse mémoire d'une autre variable, on utilise l'opérateur & :

var x int = 7
var ptr *int = &x
fmt.Println(ptr)

Le code ci-dessus affichera l'adresse mémoire à laquelle le pointeur fait référence, par exemple :

0xc000096068

Dans cet exemple, ptr est un pointeur d'entier (*int) qui mémorise l'adresse de la variable x.

Accéder aux Valeurs via un Pointeur

Pour obtenir la valeur située à l'adresse mémoire pointée par un pointeur, l'opérateur * est utilisé :

var x int = 7
var ptr *int = &x
fmt.Println(*ptr)

Le code ci-dessus affichera la valeur entreposée à l'adresse mémoire indiquée par ptr :

7

Modifier des Valeurs avec un Pointeur

Les pointeurs offrent aux développeurs la possibilité de modifier indirectement la valeur d'une variable par le biais de son adresse mémoire :

var x int = 7
var ptr *int = &x
*ptr = 10

Cette opération mettra à jour la valeur de la variable x à 10, puisque ptr désigne l'adresse mémoire de x :

10

Vérification des Pointeurs Nuls

En Go, les pointeurs sont initialisés automatiquement avec une valeur nulle (nil). Il est essentiel de vérifier si un pointeur est nul avant d'essayer d'accéder à la valeur qu'il pointe. Déréférencer un pointeur nul provoquera une panique à l'exécution, ce qui pourrait interrompre le programme :

var ptr *int
fmt.Println(ptr)

La sortie pour le code ci-dessus sera :

Exemple Complet

Voici un exemple détaillé qui déclare, initialise, accède et modifie les valeurs à travers des pointeurs en Go :

package main
import "fmt"

func main() {
    x := 7
    var ptr *int = &x
    fmt.Println("Valeur de x:", x)
    fmt.Println("Adresse mémoire de x:", ptr)
    fmt.Println("Valeur pointée par ptr:", *ptr)
    *ptr = 10
    fmt.Println("Nouvelle valeur de x:", x)
}

La sortie du code ci-dessus sera :

Valeur de x: 7
Adresse mémoire de x: 0xc00000a0f8
Valeur pointée par ptr: 7
Nouvelle valeur de x: 10