Pointeurs vers des structs

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

Lorsque vous travaillez avec des structures, vous utiliserez souvent des pointeurs pour éviter de copier de grandes structures de données et pour modifier la structure originale. Un pointeur vers une structure contient l'adresse mémoire de cette instance de structure.

Vous pouvez créer un pointeur vers une struct en utilisant l'opérateur & sur une struct existante, ou en utilisant l'opérateur d'adresse directement avec un littéral de struct.

type Person struct {
    Name string
    Age  int
}

p := Person{Name: "Alice", Age: 30}
ptr := &p  // pointeur vers une struct existante

// Ou créer directement
ptr2 := &Person{Name: "Bob", Age: 25}

Go fournit un raccourci pratique lors de l'accès aux champs d'une structure via un pointeur. Au lieu d'écrire (*ptr).Name, vous pouvez simplement écrire ptr.Name. Go déréférence automatiquement le pointeur pour vous.

ptr := &Person{Name: "Alice", Age: 30}

// Les deux fonctionnent de manière identique
fmt.Println((*ptr).Name)  // déréférencement explicite
fmt.Println(ptr.Name)     // déréférencement automatique

Ce déréférencement automatique s'applique également lors de la modification des champs. Les modifications via le pointeur affectent le struct d'origine.

p := Person{Name: "Alice", Age: 30}
ptr := &p

ptr.Age = 31           // modifie l'original
fmt.Println(p.Age)     // 31

Les pointeurs vers des structs sont essentiels dans les modèles de POO de Go. Ils permettent aux méthodes de modifier l'état du récepteur, permettent de passer efficacement de grandes structs aux fonctions et constituent la base de la construction de structures de données liées comme les arbres et les listes.

Défi

Facile

Construisons un système de compte bancaire qui démontre comment les pointeurs de structures vous permettent de modifier les données originales de manière efficace. Vous allez créer un compte qui peut être mis à jour via des opérations sur les pointeurs.

Vous organiserez votre code sur deux fichiers :

account.go : Définissez une structure BankAccount avec les champs Owner (string), Balance (float64) et AccountNumber (string). Créez une fonction nommée NewAccount qui prend un nom de propriétaire et un numéro de compte en paramètres et retourne un pointeur vers un nouveau BankAccount avec un solde initial de 0. Créez également une fonction Deposit qui prend un pointeur *BankAccount et un montant, puis ajoute ce montant au solde du compte via le pointeur.
main.go : Lisez les informations du compte depuis l'entrée, créez un compte en utilisant votre fonction constructeur (qui retourne un pointeur), effectuez un dépôt en utilisant le pointeur, et affichez les détails du compte pour confirmer que le solde a été modifié.

Les entrées suivantes seront fournies :

Ligne 1 : Nom du propriétaire
Ligne 2 : Numéro de compte
Ligne 3 : Montant du dépôt (float)

Format de sortie :

Account: [AccountNumber]
Owner: [Owner]
Balance: [Balance]

Par exemple, pour John Smith, ACC-12345, et 500.50, votre sortie devrait être :

Account: ACC-12345
Owner: John Smith
Balance: 500.50

N'oubliez pas que votre fonction NewAccount doit retourner *BankAccount en utilisant l'opérateur &, et votre fonction Deposit peut modifier le solde directement via le pointeur en utilisant le déréférencement automatique de Go (par exemple, account.Balance au lieu de (*account).Balance).

Aide-mémoire

Un pointeur vers une struct contient l'adresse mémoire d'une instance de struct. Créez des pointeurs de struct en utilisant l'opérateur & :

type Person struct {
    Name string
    Age  int
}

p := Person{Name: "Alice", Age: 30}
ptr := &p  // pointer to existing struct

// Or create directly
ptr2 := &Person{Name: "Bob", Age: 25}

Go propose un déréférencement automatique lors de l'accès aux champs d'une struct via un pointeur. Au lieu de (*ptr).Name, vous pouvez écrire ptr.Name :

ptr := &Person{Name: "Alice", Age: 30}

// Both work identically
fmt.Println((*ptr).Name)  // explicit dereference
fmt.Println(ptr.Name)     // automatic dereference

Les modifications effectuées via un pointeur affectent la struct d'origine :

p := Person{Name: "Alice", Age: 30}
ptr := &p

ptr.Age = 31           // modifies original
fmt.Println(p.Age)     // 31

Les pointeurs de struct permettent aux méthodes de modifier l'état du receveur, permettent le passage efficace de grandes structs aux fonctions et constituent le fondement des structures de données liées.

Essayez vous-même

package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

func main() {
	reader := bufio.NewReader(os.Stdin)
	
	// Lire le nom du propriétaire
	ownerName, _ := reader.ReadString('\n')
	ownerName = strings.TrimSpace(ownerName)
	
	// Lire le numéro de compte
	accountNumber, _ := reader.ReadString('\n')
	accountNumber = strings.TrimSpace(accountNumber)
	
	// Lire le montant du dépôt
	amountStr, _ := reader.ReadString('\n')
	amountStr = strings.TrimSpace(amountStr)
	amount, _ := strconv.ParseFloat(amountStr, 64)
	
	// TODO : Créer un nouveau compte en utilisant la fonction NewAccount (renvoie un pointeur)
	
	// TODO : Effectuer un dépôt en utilisant la fonction Deposit avec le pointeur du compte
	
	// TODO : Afficher les détails du compte dans le format requis :
	// Account: [AccountNumber]
	// Owner: [Owner]
	// Balance: [Balance]
}