Notions de base des pointeurs en Go

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy. Leçon 19 sur 107.

Un pointeur est une variable qui stocke l’adresse mémoire d’une autre variable. Au lieu de contenir directement une valeur, il contient l’emplacement où cette valeur se trouve en mémoire. Les pointeurs sont fondamentaux en Go et essentiels pour manipuler efficacement les données.

Pour créer un pointeur, utilisez l’opérateur & pour obtenir l’adresse d’une variable, et l’opérateur * pour déclarer un type pointeur ou accéder à la valeur située à cette adresse.

x := 42
p := &x  // p contient l'adresse mémoire de x

fmt.Println(p)  // 0xc000018030 (adresse mémoire)
fmt.Println(*p) // 42 (valeur à cette adresse)

L’opérateur & signifie « adresse de » et renvoie un pointeur. L’opérateur *, lorsqu’il est utilisé sur un pointeur, signifie « valeur à l’adresse » et s’appelle le déréférencement. Vous pouvez également modifier la valeur d’origine via le pointeur.

x := 10
p := &x

*p = 25         // modifier la valeur via le pointeur
fmt.Println(x)  // 25 (variable originale modifiée)

Le type pointeur s’écrit *T, où T est le type pointé. Un pointeur vers un int est de type *int.

var p *int      // déclare un pointeur vers int
x := 100
p = &x          // p pointe maintenant vers x

La valeur zéro d’un pointeur est nil, ce qui signifie qu’il ne pointe vers rien. Tenter de déréférencer un pointeur nil provoque une panique à l’exécution ; assurez-vous donc toujours que les pointeurs sont initialisés avant de les utiliser.

Défi

Facile

Construisons un échangeur de valeurs simple qui montre la puissance des pointeurs pour modifier des variables via leurs adresses mémoire.

Vous organiserez votre code sur deux fichiers :

swap.go : créez une fonction appelée SwapValues qui prend deux pointeurs *int comme paramètres. Cette fonction doit échanger les valeurs vers lesquelles ces pointeurs pointent : après son appel, chaque variable doit contenir la valeur originale de l’autre. La fonction ne renvoie rien ; elle modifie directement les valeurs via les pointeurs.
main.go : lisez deux entiers depuis l’entrée, stockez-les dans des variables, puis utilisez votre fonction SwapValues pour échanger leurs valeurs. Affichez les deux valeurs avant et après l’échange pour montrer la modification.

Les entrées suivantes seront fournies :

Ligne 1 : premier entier
Ligne 2 : deuxième entier

Format de sortie :

Before: a=[first] b=[second]
After: a=[first] b=[second]

Par exemple, pour les valeurs 10 et 25, votre sortie doit être :

Before: a=10 b=25
After: a=25 b=10

N’oubliez pas d’utiliser l’opérateur & lors du passage de vos variables à la fonction, ainsi que l’opérateur * à l’intérieur de la fonction pour accéder aux valeurs réelles et les modifier.

Essayez vous-même

package main

import "fmt"

func main() {
	// Lire deux entiers depuis l'entrée
	var a, b int
	fmt.Scanln(&a)
	fmt.Scanln(&b)

	// Afficher les valeurs avant l'échange
	fmt.Printf("Before: a=%d b=%d\n", a, b)

	// TODO : Appeler la fonction SwapValues avec des pointeurs vers a et b
	// N'oubliez pas d'utiliser l'opérateur & pour passer les adresses

	// Afficher les valeurs après l'échange
	fmt.Printf("After: a=%d b=%d\n", a, b)
}