Pointeurs en Golang : & et *, new, nil et quand les utiliser

& et *

Un pointeur contient l'adresse mémoire d'une valeur. &x vous donne un pointeur vers x. *p suit le pointeur jusqu'à la valeur.

package main

import "fmt"

func main() {
	x := 10
	p := &x // p has type *int

	fmt.Println(*p) // read through the pointer: 10
	*p = 20         // write through the pointer
	fmt.Println(x)  // x changed: 20

	fmt.Printf("%T\n", p)
	fmt.Println(p != nil)
}

L'étoile a deux rôles. Dans un type (*int), elle signifie « pointeur vers int ». Dans une expression (*p), elle signifie « la valeur vers laquelle p pointe ». Afficher p lui-même montre une adresse comme 0xc000012345, qui change d'une exécution à l'autre.

Pourquoi les pointeurs existent : partager au lieu de copier

Go passe tout par valeur. Une fonction reçoit une copie de chaque argument, donc elle ne peut pas modifier la variable de l'appelant. Passer un pointeur copie l'adresse à la place, et les deux côtés atteignent la même valeur.

package main

import "fmt"

func doubleCopy(n int) {
	n *= 2
}

func doublePtr(n *int) {
	*n *= 2
}

func main() {
	v := 21
	doubleCopy(v)
	fmt.Println(v) // 21

	doublePtr(&v)
	fmt.Println(v) // 42
}

Go n'a pas de références au sens de C++. En Go, « passer par référence » signifie passer un pointeur par valeur.

Pointeurs vers des structs

Les pointeurs de structs sont les pointeurs les plus courants dans le code Go. L'accès aux champs déréférence automatiquement : p.Name signifie (*p).Name.

package main

import "fmt"

type Account struct {
	Owner   string
	Balance int
}

func (a *Account) Deposit(n int) {
	a.Balance += n // no explicit * needed
}

func main() {
	acc := &Account{Owner: "Ana"} // pointer to a new struct
	acc.Deposit(100)
	acc.Balance -= 30
	fmt.Println(acc.Owner, acc.Balance)

	same := acc
	same.Balance = 0
	fmt.Println(acc.Balance) // 0: both variables point at one Account
}

Les méthodes suivent la même logique : un receveur pointeur permet à la méthode de modifier la struct. La page sur les méthodes traite le choix entre receveur valeur et receveur pointeur.

new

new(T) alloue un T mis à zéro et renvoie son adresse. C'est la même chose que déclarer une variable et prendre son adresse.

p := new(int) // *int pointing at 0
var x int
q := &x           // same thing, two lines
a := new(Account) // same as &Account{}

En pratique, &T{...} est plus courant pour les structs parce qu'il permet de définir les champs dans la même expression. new est pratique pour des pointeurs vers des types de base. Ne le confondez pas avec make, qui construit des slices, maps et channels et les renvoie prêts à l'emploi, pas sous forme de pointeurs.

Renvoyer un pointeur vers une variable locale est sûr

En C, renvoyer l'adresse d'une variable locale est un bug. En Go, c'est du code ordinaire.

package main

import "fmt"

type Config struct {
	Port int
	Mode string
}

func defaultConfig() *Config {
	c := Config{Port: 8080, Mode: "dev"}
	return &c // c outlives the call, so it lives on the heap
}

func main() {
	cfg := defaultConfig()
	cfg.Mode = "prod"
	fmt.Printf("%+v\n", *cfg)
}

L'analyse d'échappement du compilateur décide si une valeur vit sur la pile ou sur le tas. Vous ne choisissez jamais, et vous ne libérez jamais la mémoire : le ramasse-miettes la récupère quand plus rien ne pointe dessus. go build -gcflags=-m affiche ces décisions si vous êtes curieux.

Pointeurs nil

La valeur zéro de tout type pointeur est nil. Déréférencer nil provoque un panic.

package main

import "fmt"

type Node struct {
	Val  int
	Next *Node
}

func main() {
	defer func() {
		fmt.Println("recovered:", recover())
	}()

	list := &Node{Val: 1, Next: &Node{Val: 2}}
	for n := list; n != nil; n = n.Next {
		fmt.Println(n.Val)
	}

	var missing *Node
	fmt.Println(missing == nil)
	fmt.Println(missing.Val) // panics
}

Sortie :

1
2
true
recovered: runtime error: invalid memory address or nil pointer dereference

Sans le recover, le programme planterait avec ce message et une trace de pile commençant par panic: runtime error: invalid memory address or nil pointer dereference et [signal SIGSEGV: segmentation violation ...]. Les sources habituelles :

• une variable pointeur ou un champ de struct jamais défini
• m[key] sur une map[string]*T pour une clé absente, qui renvoie nil
• une erreur ignorée : f, _ := os.Open(path) laisse f à nil en cas d'échec
• une méthode à receveur pointeur appelée sur un pointeur nil, qui lit ensuite un champ

Appeler une méthode sur un pointeur nil est en soi légal. Le panic ne se produit que lorsque la méthode touche les champs du receveur.

Quand utiliser un pointeur

Utilisez un pointeur quand :

• une fonction ou une méthode doit modifier la valeur de l'appelant
• la valeur est une grosse struct qui circule souvent
• le type ne doit pas être copié (il contient un sync.Mutex, ou il représente une ressource unique comme une connexion)
• vous devez exprimer « pas de valeur » avec nil, par exemple un champ facultatif dans une struct JSON (*int distingue « absent » de 0)

N'utilisez pas de pointeur quand :

• la valeur est petite et en lecture seule (time.Time, un Point)
• le type se comporte déjà comme une référence : les slices, maps, channels, fonctions et interfaces ont rarement besoin d'un * devant. Un *[]int ou un *map[string]int est presque toujours une erreur

Les pointeurs ne sont pas automatiquement plus rapides. Copier une petite struct ne coûte presque rien, et un pointeur peut forcer une allocation sur le tas et ajouter du travail au ramasse-miettes.

Pointeurs et variables de boucle

Prendre l'adresse d'une variable de boucle est sûr depuis Go 1.22, parce que chaque itération a sa propre variable :

package main

import "fmt"

func main() {
	var ptrs []*int
	for i := range 3 {
		ptrs = append(ptrs, &i)
	}
	for _, p := range ptrs {
		fmt.Print(*p, " ")
	}
	fmt.Println()
}

Ce code affiche 0 1 2. Avant Go 1.22 (qui a aussi introduit range 3), la même boucle écrite for i := 0; i < 3; i++ affichait 3 3 3, puisque les trois pointeurs partageaient une seule variable. Notez que &v dans for _, v := range items pointe vers une copie de l'élément, pas vers l'élément de la slice. Pour obtenir un pointeur vers l'élément lui-même, utilisez &items[i].

Erreurs courantes

• Déréférencer sans vérifier. Testez if p == nil partout où nil est possible.
• Un pointeur vers une valeur de range. &v pointe vers une copie ; utilisez &s[i].
• Des pointeurs vers des slices et des maps. Rarement nécessaires. Renvoyez plutôt la nouvelle slice.
• Garder &s[i] à travers un append. Si append réalloue, le pointeur fait toujours référence à l'ancien tableau et les écritures suivantes ne sont visibles nulle part.