Comment fonctionnent les pointeurs en Go ?

Question

Accepted Answer

Un **pointeur** contient l'**adresse mémoire** d'une valeur plutôt que la valeur elle-même. Go dispose de pointeurs (comme C) mais les garde simples et sûrs — pas d'arithmétique de pointeurs, et le garbage collector gère la mémoire. Ils sont utilisés pour partager et modifier les données efficacement.

## Les deux opérateurs : & et *

```go
x := 42
p := &x          // & = "address of" → p is a *int (pointer to x)
fmt.Println(p)   // 0xc0000... (the address)
fmt.Println(*p)  // 42 — * = "dereference" (get the value at the address)

*p = 100         // change the value THROUGH the pointer
fmt.Println(x)   // 100 — x was modified via p
```

`&` prend l'adresse d'une variable ; `*` (sur un pointeur) accède ou définit la valeur qu'il désigne.

## Pourquoi les pointeurs importent : modifier via des fonctions

```go
// ❌ value parameter — the function gets a COPY; changes don't affect the caller
func incrementValue(n int) { n++ }       // caller's variable unchanged

// ✅ pointer parameter — the function can modify the caller's variable
func incrementPointer(n *int) { *n++ }

x := 5
incrementValue(x)     // x still 5
incrementPointer(&x)  // x is now 6
```

Como Go transmet les arguments **par valeur** (copies), une fonction ne peut modifier les données de l'appelant que si elle reçoit un **pointeur** vers elles. C'est la raison principale d'utiliser des pointeurs.

## Pointeurs avec des structs (très courant)

```go
type Counter struct { count int }

// pointer receiver → method can modify the struct
func (c *Counter) Increment() { c.count++ }

c := &Counter{}      // a pointer to a Counter
c.Increment()        // modifies it (Go auto-dereferences: (*c).count++)
```

Les récepteurs pointeur sont la façon dont les méthodes mutent leur struct, et passer des pointeurs struct évite de copier de grands structs.

## Le pointeur nil et la valeur zéro

```go
var p *int           // zero value of a pointer is nil
fmt.Println(p)       // <nil>
*p = 5               // 💥 PANIC: nil pointer dereference (no value to point to)
if p != nil { *p = 5 }   // guard against nil
```

Dérférencer un pointeur `nil` provoque une panique — une erreur runtime courante à protéger.

## Ce que les pointeurs Go N'ONT PAS (sécurité)

```text
✗ NO pointer arithmetic (can't do p++ to move through memory like C)
✗ NO manual free — garbage collector reclaims memory
→ Pointers are about sharing/modifying data, not low-level memory hacking
```

## Pourquoi c'est important

Les pointeurs sont essentiels en Go pour deux raisons principales : **modifier** les données de l'appelant (puisque Go transmet par valeur, seul un pointeur permet à une fonction de changer l'original) et **efficacité** (passer un pointeur évite de copier de grands structs).

Ils sont fondamentaux pour les méthodes avec récepteurs pointeur (la façon standard de muter les structs) et apparaissent partout dans le Go idiomatique.

Comprendre `&`/`*`, la sémantique valeur-vs-pointeur, la panique du pointeur nil, et que les pointeurs Go sont délibérément *sûrs* (pas d'arithmétique, gérés par GC) — axés sur le partage/mutation plutôt que la manipulation mémoire de style C — est une connaissance fondamentale pour écrire du Go correct et efficace et un point de confusion fréquent pour les débutants et dans les entretiens.