Passage par valeur vs référence

Fait partie de la section Programmation Orientée Objet du Journey GO de Coddy — leçon 21 sur 107.

Go est un langage à passage par valeur. Lorsque vous passez une variable à une fonction, Go crée une copie de cette valeur. Cela signifie que les modifications à l'intérieur de la fonction n'affectent pas la variable d'origine.

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

func main() {
    x := 10
    double(x)
    fmt.Println(x)  // 10 (inchangé)
}

Il en va de même pour les structures. Passer une structure à une fonction copie tous ses champs, de sorte que les modifications effectuées à l'intérieur de la fonction sont perdues.

type Person struct {
    Name string
    Age  int
}

func birthday(p Person) {
    p.Age++
}

func main() {
    alice := Person{Name: "Alice", Age: 30}
    birthday(alice)
    fmt.Println(alice.Age)  // 30 (inchangé)
}

Pour modifier la valeur d'origine, passez plutôt un pointeur. Le pointeur lui-même est copié, mais il pointe toujours vers la même adresse mémoire, ce qui vous permet de modifier les données d'origine.

func birthday(p *Person) {
    p.Age++
}

func main() {
    alice := Person{Name: "Alice", Age: 30}
    birthday(&alice)
    fmt.Println(alice.Age)  // 31 (modifié !)
}

Utilisez des pointeurs lorsque vous avez besoin de modifier la valeur d'origine ou lors du passage de structures volumineuses pour éviter une copie coûteuse. Utilisez des valeurs lorsque vous souhaitez protéger les données d'origine contre des modifications involontaires.

Défi

Facile

Construisons un système de panier d'achat qui démontre la différence entre le passage de structures par valeur et par pointeur. Vous verrez par vous-même comment seuls les paramètres de type pointeur peuvent modifier les données originales.

Vous organiserez votre code sur deux fichiers :

cart.go : Définissez une structure CartItem avec les champs Name (string), Price (float64) et Quantity (int). Créez deux fonctions qui tentent de mettre à jour la quantité :
- UpdateQuantityByValue prend un CartItem (par valeur) et une nouvelle quantité, puis définit la quantité de l'article à la nouvelle valeur.
- UpdateQuantityByPointer prend un *CartItem (pointeur) et une nouvelle quantité, puis définit la quantité de l'article à la nouvelle valeur.
Créez également une méthode Total sur CartItem qui retourne le prix multiplié par la quantité.
main.go : Lisez les détails de l'article depuis l'entrée, créez un CartItem, puis démontrez les deux approches de mise à jour. Essayez d'abord de mettre à jour avec la fonction par valeur et affichez le résultat, puis mettez à jour avec la fonction par pointeur et affichez à nouveau le résultat.

Les entrées suivantes seront fournies :

Ligne 1 : Nom de l'article
Ligne 2 : Prix (float)
Ligne 3 : Quantité initiale (entier)
Ligne 4 : Nouvelle quantité à définir (entier)

Format de sortie :

Initial: [Name] x[Quantity] = $[Total]
After value update: [Name] x[Quantity] = $[Total]
After pointer update: [Name] x[Quantity] = $[Total]

Par exemple, avec Laptop, 999.99, 1, et 3, votre sortie devrait être :

Initial: Laptop x1 = $999.99
After value update: Laptop x1 = $999.99
After pointer update: Laptop x3 = $2999.97

Remarquez comment la quantité reste à 1 après la mise à jour par valeur (la fonction a modifié une copie), mais passe à 3 après la mise à jour par pointeur (la fonction a modifié l'original). Formatez les totaux avec deux décimales.

Aide-mémoire

Go est un langage à passage par valeur. Lorsque vous passez une variable à une fonction, Go crée une copie de cette valeur, de sorte que les modifications à l'intérieur de la fonction n'affectent pas la variable d'origine.

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

func main() {
    x := 10
    double(x)
    fmt.Println(x)  // 10 (inchangé)
}

La même chose s'applique aux structures (structs). Passer une structure à une fonction copie tous ses champs :

type Person struct {
    Name string
    Age  int
}

func birthday(p Person) {
    p.Age++
}

func main() {
    alice := Person{Name: "Alice", Age: 30}
    birthday(alice)
    fmt.Println(alice.Age)  // 30 (inchangé)
}

Pour modifier la valeur d'origine, passez un pointeur. Le pointeur lui-même est copié, mais il pointe toujours vers la même adresse mémoire :

func birthday(p *Person) {
    p.Age++
}

func main() {
    alice := Person{Name: "Alice", Age: 30}
    birthday(&alice)
    fmt.Println(alice.Age)  // 31 (modifié !)
}

Utilisez des pointeurs lorsque vous avez besoin de modifier la valeur d'origine ou lorsque vous passez de grandes structures pour éviter une copie coûteuse. Utilisez des valeurs lorsque vous souhaitez protéger les données d'origine contre des modifications involontaires.

Essayez vous-même

package main

import (
	"fmt"
)

func main() {
	// Lire l'entrée
	var name string
	var price float64
	var initialQty, newQty int

	fmt.Scanln(&name)
	fmt.Scanln(&price)
	fmt.Scanln(&initialQty)
	fmt.Scanln(&newQty)

	// TODO: Créer un CartItem avec les valeurs d'entrée

	// TODO: Afficher l'état initial en utilisant le format :
	// fmt.Printf("Initial: %s x%d = $%.2f\n", ...)

	// TODO: Essayer de mettre à jour la quantité en utilisant UpdateQuantityByValue
	// Ensuite, afficher le résultat (remarquez que la quantité ne changera pas)

	// TODO: Mettre à jour la quantité en utilisant UpdateQuantityByPointer
	// Ensuite, afficher le résultat (remarquez que la quantité changera)
}