Passage de pointeurs de structures

Fait partie de la section Logic & Flow du Journey C de Coddy — leçon 47 sur 63.

Bien que le passage de structures par valeur fonctionne bien pour la lecture de données, cela devient inefficace avec de grandes structures car toute la structure est copiée. Plus important encore, vous ne pouvez pas modifier la structure originale depuis l'intérieur de la fonction. C'est là que le passage de pointeurs vers des structures devient essentiel.

Lorsque vous passez un pointeur vers une struct au lieu de la struct elle-même, la fonction reçoit l'adresse mémoire de la struct originale. Cette approche offre deux avantages clés : elle est plus efficace (pas de copie) et permet à la fonction de modifier les données originales.

La syntaxe d'une fonction qui accepte un pointeur vers une structure est :

void functionName(struct StructureName *ptr) {
    // Corps de la fonction utilisant ptr->member
}

À l'intérieur de la fonction, vous utilisez l'opérateur flèche pour accéder aux membres de la struct et les modifier. Toute modification effectuée via le pointeur affectera directement la struct originale dans la fonction appelante, rendant cette approche idéale pour les fonctions qui doivent mettre à jour ou transformer les données de la struct.

Cette technique est fondamentale pour construire des programmes C efficaces qui manipulent des structures de données complexes, car elle combine la puissance des pointeurs avec l'organisation des structs.

Défi

Facile

Créez un programme C qui démontre le passage de pointeurs vers des structures à des fonctions pour une modification efficace des données. Votre programme doit :

Définir une struct nommée BankAccount avec les membres suivants :
- Un entier accountNumber pour stocker le numéro de compte
- Un tableau de caractères ownerName de taille 30 pour stocker le nom du propriétaire du compte
- Un flottant balance pour stocker le solde du compte
- Un entier transactionCount pour stocker le nombre de transactions
Écrire une fonction nommée depositMoney qui :
- Prend un pointeur vers une structure BankAccount et un montant flottant en paramètres
- Ajoute le montant au solde du compte en utilisant l'opérateur flèche
- Incrémente le compteur de transactions de 1
- Affiche "Deposit successful. New balance: %.2f\n"
Écrire une fonction nommée withdrawMoney qui :
- Prend un pointeur vers une structure BankAccount et un montant flottant en paramètres
- Vérifie si le montant du retrait est supérieur au solde actuel
- Si les fonds sont insuffisants, affiche "Insufficient funds. Current balance: %.2f\n"
- Si les fonds sont suffisants, soustrait le montant du solde, incrémente le compteur de transactions et affiche "Withdrawal successful. New balance: %.2f\n"
Écrire une fonction nommée displayAccount qui :
- Prend un pointeur vers une structure BankAccount en paramètre
- Affiche les informations du compte dans ce format exact :
  - "Account Information:\n"
  - "Account Number: %d\n"
  - "Owner: %s\n"
  - "Balance: %.2f\n"
  - "Transactions: %d\n"
Dans la fonction principale (main) :
- Créer une variable BankAccount nommée account
- Lire le numéro de compte, le nom du propriétaire et le solde initial à partir de l'entrée
- Initialiser le compteur de transactions à 0
- Appeler displayAccount pour afficher l'état initial du compte
- Lire un montant de dépôt et appeler depositMoney
- Lire un montant de retrait et appeler withdrawMoney
- Appeler displayAccount pour afficher l'état final du compte

Ce défi démontre la puissance du passage de pointeurs vers des structures à des fonctions. Contrairement au passage par valeur, les fonctions reçoivent l'adresse mémoire de la structure d'origine, ce qui leur permet de modifier directement les données originales. Cette approche est plus efficace (pas de copie) et permet aux fonctions de modifier de manière permanente les valeurs de la structure dans la fonction appelante.

Aide-mémoire

Lors du passage de structures par valeur, l'intégralité de la structure est copiée, ce qui est inefficace pour les grandes structures et empêche la modification des données originales. Passer des pointeurs vers des structures résout ces deux problèmes en passant l'adresse mémoire à la place.

Syntaxe de fonction pour accepter un pointeur vers une structure :

void functionName(struct StructureName *ptr) {
    // Corps de la fonction utilisant ptr->member
}

À l'intérieur de la fonction, utilisez l'opérateur flèche (->) pour accéder aux membres de la structure et les modifier via le pointeur. Toute modification effectuée affectera directement la structure originale dans la fonction appelante.

Cette approche offre deux avantages clés :

Plus efficace (pas de copie de l'intégralité de la structure)
Permet aux fonctions de modifier les données de la structure originale

Essayez vous-même

#include <stdio.h>
#include <string.h>

// TODO: Définir la structure BankAccount ici

// TODO: Écrire la fonction depositMoney ici

// TODO: Écrire la fonction withdrawMoney ici

// TODO: Écrire la fonction displayAccount ici

int main() {
    // Lire l'entrée
    int accountNum;
    char ownerName[30];
    float initialBalance;
    float depositAmount;
    float withdrawAmount;
    
    scanf("%d", &accountNum);
    scanf("%s", ownerName);
    scanf("%f", &initialBalance);
    scanf("%f", &depositAmount);
    scanf("%f", &withdrawAmount);
    
    // TODO: Créer la variable BankAccount et l'initialiser
    
    // TODO: Appeler displayAccount pour afficher l'état initial
    
    // TODO: Appeler depositMoney avec le montant du dépôt
    
    // TODO: Appeler withdrawMoney avec le montant du retrait
    
    // TODO: Appeler displayAccount pour afficher l'état final
    
    return 0;
}

Testez-vous

Cette leçon comprend un petit quiz. Commencez la leçon pour y répondre et suivre votre progression.

Toutes les leçons de Logic & Flow

2Pointeurs et Tableaux

Noms de tableaux comme pointeurs Éléments de tableau - Pointeurs Arithmétique des pointeurs Comparaison de pointeurs Récapitulatif : Parcours de tableau par pointeur

5Pointeurs et fonctions

Passage par valeur Passage de pointeurs aux fonctions Modifier des variables via des pointeurs Un exemple classique : Swap Passage de tableaux aux fonctions Récapitulatif : Pointeurs comme arguments de fonction

8Structures et Pointeurs

Pointeurs vers des structures L'opérateur flèche (->)Passage de structures par valeurPassage de pointeurs de structuresAllocation dynamique de structures Récap : Modifier une structure - Ptr

11Défis de révision finale

Récap : Concaténation dynamique de chaînes Récap : Tableau de structs Récap : Compteur de fréquence des mots