Go Academy · Leçon

Que sont les pointeurs ?

Opérateur d’adresse, déréférencement et pointeurs nil

Que sont les pointeurs ? est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Go Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Go Academy comprend 4 leçons au total.

Adresses mémoire

Chaque variable se trouve à une adresse mémoire. Un pointeur stocke cette adresse. Dans Go, les pointeurs sont typés : un *int contient l'adresse d'un int.

Opérateur d'obtention d'adresse &

Utilisez & pour obtenir l'adresse d'une variable :

package main
import "fmt"

func main() {
    x := 42
    p := &x
    fmt.Println(p)  // 0xc000... (address)
    fmt.Println(*p) // 42 (value at address)
}

Déréférencement *

Utilisez * pour lire ou écrire la valeur située à l'adresse du pointeur :

package main
import "fmt"

func main() {
    n := 10
    p := &n
    *p = 99
    fmt.Println(n) // 99
}

Pointeurs nuls

La valeur nulle d'un pointeur est nil. Déréférencer un pointeur nul provoque une panique :

package main
import "fmt"

func main() {
    var p *int
    fmt.Println(p)        // <nil>
    fmt.Println(p == nil) // true
    // *p = 1 — PANIC
}

Types de pointeurs

Chaque type de pointeur correspond précisément à ce vers quoi il pointe :

package main
import "fmt"

func main() {
    i := 1
    s := "hello"
    pi := &i   // *int
    ps := &s   // *string
    fmt.Printf("%T %T\n", pi, ps) // *int *string
}

Vérifier la valeur nulle avant utilisation

Vérifiez toujours qu'un pointeur reçu de l'extérieur de votre code n'est pas nul avant de le déréférencer :

package main
import "fmt"

func printInt(p *int) {
    if p == nil {
        fmt.Println("nil pointer")
        return
    }
    fmt.Println(*p)
}

func main() {
    v := 7
    printInt(&v)
    printInt(nil)
}

Pointeurs vers des structures

L'accès aux champs d'une structure via un pointeur utilise la même notation avec un point : Go déréférence automatiquement :

package main
import "fmt"

type Point struct{ X, Y int }

func main() {
    p := &Point{1, 2}
    p.X = 10         // same as (*p).X = 10
    fmt.Println(*p)  // {10 2}
}

Comparer des pointeurs

Deux pointeurs sont égaux lorsqu'ils pointent vers la même variable (la même adresse) ou lorsqu'ils sont tous les deux nuls :

package main
import "fmt"

func main() {
    a := 1
    p1 := &a
    p2 := &a
    p3 := new(int)
    *p3 = 1
    fmt.Println(p1 == p2) // true  — same address
    fmt.Println(p1 == p3) // false — different address
}

Pile et tas

Le compilateur de Go décide si une variable se trouve sur la pile ou dans le tas grâce à l'analyse d'échappement. Lorsque vous prenez l'adresse d'une variable locale et la renvoyez, Go la déplace automatiquement dans le tas : vous n'avez pas à gérer cela manuellement.

Quand NOT utiliser de pointeurs

Tout n'a pas besoin d'un pointeur :

Les types valeur de petite taille (int, bool, petites structures) coûtent moins cher à copier qu'à déréférencer
Les données immuables partagées entre les routines concurrentes peuvent être utilisées en toute sécurité comme des valeurs
Utilisez principalement les pointeurs pour les modifications ou les grandes structures

Vérification rapide

Que renvoie l'opérateur & ?

Récapitulatif : pointeurs

À retenir :

&v obtient l'adresse ; *p la déréférence
La valeur nulle est nil : vérifiez-la toujours avant de déréférencer
Go déréférence automatiquement l'accès aux champs d'une structure via un pointeur
L'analyse d'échappement gère automatiquement la pile et le tas

Exercice pratique

Écrivez une fonction swap(a, b *int) qui échange les valeurs de deux entiers à l'aide de pointeurs. Appelez-la depuis main et affichez les valeurs avant et après.

Questions Fréquemment Posées

La leçon « Que sont les pointeurs ? » est-elle gratuite ?

Oui — le texte complet de « Que sont les pointeurs ? » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Go Academy, passe à CoddyKit PRO. Le cours Go Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Que sont les pointeurs ? » ?

Opérateur d’adresse, déréférencement et pointeurs nil Tu pratiques Go Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Go Academy ?

Aucune expérience préalable n'est requise. Go Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.

Combien de temps prend la leçon « Que sont les pointeurs ? » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Go Academy ?

Oui. Chaque leçon Go Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Go Academy