Go Academy · Leçon

Pointeurs et fonctions

Passage par valeur ou passage par pointeur

Pointeurs et fonctions est une leçon Go Academy gratuite sur CoddyKit. Ceci est la leçon 2 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.

Passage par valeur

Go transmet tous les arguments de fonction par valeur : une copie est créée. Les modifications effectuées dans la fonction n'affectent pas l'original :

package main
import "fmt"

func increment(n int) { n++ }

func main() {
    x := 5
    increment(x)
    fmt.Println(x) // 5 — unchanged
}

Passage par pointeur

Transmettez un pointeur pour permettre à la fonction de modifier l'original :

package main
import "fmt"

func increment(n *int) { *n++ }

func main() {
    x := 5
    increment(&x)
    fmt.Println(x) // 6
}

Retourner des pointeurs

Les fonctions peuvent retourner des pointeurs vers des valeurs allouées sur le tas. L'analyse d'échappement de Go garantit la sécurité :

package main
import "fmt"

func newInt(v int) *int { return &v }

func main() {
    p := newInt(42)
    fmt.Println(*p) // 42
}

Efficacité avec les grandes structures

Transmettre une grande structure par pointeur évite une copie coûteuse :

package main
import "fmt"

type BigData struct{ Data [1024]int }

func process(d *BigData) { d.Data[0] = 99 }

func main() {
    bd := BigData{}
    process(&bd)
    fmt.Println(bd.Data[0]) // 99
}

Pointeur vers une interface

C'est rarement nécessaire : les interfaces contiennent déjà un pointeur en interne. Transmettre *interface{} est presque toujours incorrect :

package main
import "fmt"

type Stringer interface{ String() string }

func print(s Stringer) { fmt.Println(s.String()) }

// Pass interface directly, NOT *Stringer
type Name string
func (n Name) String() string { return string(n) }

func main() {
    print(Name("Alice"))
}

Paramètres facultatifs avec des pointeurs

Utilisez des paramètres pointeurs pour distinguer « non fourni » d'une valeur nulle :

package main
import "fmt"

func greet(name *string) {
    if name == nil {
        fmt.Println("Hello, stranger")
        return
    }
    fmt.Println("Hello,", *name)
}

func main() {
    s := "Alice"
    greet(&s)
    greet(nil)
}

Modification via des tranches

Les tranches contiennent déjà un pointeur interne ; vous n'avez donc souvent pas besoin de *[]T. Cependant, lorsque append réalloue la tranche, vous devez pointer vers la tranche elle-même :

package main
import "fmt"

func addItem(s *[]int, v int) { *s = append(*s, v) }

func main() {
    nums := []int{1, 2, 3}
    addItem(&nums, 4)
    fmt.Println(nums) // [1 2 3 4]
}

Aliasing de pointeurs

Plusieurs pointeurs vers la même variable créent un alias : une modification effectuée via un pointeur est visible par tous les autres :

package main
import "fmt"

func main() {
    x := 10
    a, b := &x, &x
    *a = 99
    fmt.Println(*b) // 99 — same memory
}

Éviter l'utilisation excessive des pointeurs

Utilisez des pointeurs uniquement lorsque c'est nécessaire :

Modification à l'intérieur d'une fonction
Grandes structures (>= environ 64 octets)
nil pour signifier « absent »

Utiliser trop de pointeurs augmente la pression exercée sur le ramasse-miettes et réduit la clarté du code.

Modèle de pointeur de fonction

Stockez des pointeurs de fonction dans une table associative pour créer des tables de dispatch :

package main
import "fmt"

func add(a, b int) int { return a + b }
func sub(a, b int) int { return a - b }

func main() {
    ops := map[string]func(int,int)int{
        "+": add, "-": sub,
    }
    fmt.Println(ops["+"](10, 3)) // 13
    fmt.Println(ops["-"](10, 3)) // 7
}

Vérification rapide

Comment permettre à une fonction de modifier une variable entière définie par l'appelant ?

Récapitulatif

Points essentiels :

Go utilise le passage par valeur : utilisez des pointeurs pour effectuer des modifications
Retournez des pointeurs depuis les constructeurs pour allouer sur le tas
Les tranches contiennent un pointeur interne, mais append peut nécessiter *[]T
Évitez l'utilisation excessive des pointeurs : préférez les valeurs pour les petits types

Exercice pratique

Écrivez une fonction normalize qui accepte *[]string et convertit toutes les chaînes en minuscules sur place à l'aide de strings.ToLower.

Questions Fréquemment Posées

La leçon « Pointeurs et fonctions » est-elle gratuite ?

Oui — le texte complet de « Pointeurs et fonctions » 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 « Pointeurs et fonctions » ?

Passage par valeur ou passage par pointeur 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 2 sur 4.

Combien de temps prend la leçon « Pointeurs et fonctions » ?

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