Bases 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 réside en mémoire. Les pointeurs sont fondamentaux en Go et essentiels pour une manipulation efficace des 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 de pointeur ou accéder à la valeur à 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 retourne un pointeur. L'opérateur *, lorsqu'il est utilisé sur un pointeur, signifie « valeur à » et est appelé 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 (la variable d'origine a été modifiée)

Le type pointeur s'écrit *T où T est le type pointé. Un pointeur vers un int a pour type *int.

var p *int      // déclare un pointeur vers un 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 (runtime panic), assurez-vous donc toujours que les pointeurs sont initialisés avant utilisation.

Défi

Facile

Construisons un simple échangeur de valeurs qui dé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 en paramètres. Cette fonction doit échanger les valeurs vers lesquelles ces pointeurs pointent — après l'avoir appelée, chaque variable doit contenir la valeur d'origine de l'autre. La fonction ne retourne rien ; elle modifie les valeurs directement 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 le changement.

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, avec 10 et 25, votre sortie devrait ê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, et l'opérateur * à l'intérieur de la fonction pour accéder aux valeurs réelles et les modifier.

Aide-mémoire

Un pointeur est une variable qui stocke l'adresse mémoire d'une autre variable. Utilisez l'opérateur & pour obtenir l'adresse d'une variable, et l'opérateur * pour déclarer un type de 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 à » et est appelé déréférencement.

Vous pouvez modifier la valeur d'origine via le pointeur :

x := 10
p := &x

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

Le type de pointeur s'écrit *T où T est le type pointé :

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

La valeur zéro d'un pointeur est nil. Tenter de déréférencer un pointeur nil provoque une erreur d'exécution (runtime panic).

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)
}