Imbrication de struct

Fait partie de la section Object Oriented Programming du Journey C de Coddy — leçon 28 sur 61.

Dans les langages orientés objet comme le C++ ou le Java, l'héritage permet à une classe d'acquérir les propriétés d'une classe parente. Le C ne possède pas d'héritage intégré, mais nous pouvons le simuler en utilisant une technique appelée composition — placer une struct à l'intérieur d'une autre.

L'idée est simple : si un Child a besoin de toutes les propriétés d'un Parent, nous intégrons la struct Parent en tant que membre de Child.

typedef struct {
    int id;
    char name[50];
} Parent;

typedef struct {
    Parent parent;  // Structure imbriquée
    int grade;
} Child;

Ici, Child contient tout ce que Parent possède, plus son propre champ grade. C'est de la composition — l'enfant « a un » parent plutôt qu'il « est un » parent, mais l'effet est similaire à l'héritage.

Pour accéder aux membres du parent via une instance enfant, vous utilisez l'opérateur point deux fois :

Child c;
c.parent.id = 101;
c.parent.name[0] = 'A';
c.grade = 5;

Ce modèle constitue le fondement de la création de hiérarchies de types en C. En imbriquant une struct de base comme premier membre, nous débloquons des techniques puissantes que nous explorerons dans les prochaines leçons.

Défi

Facile

Construisons un système simple de gestion des employés qui démontre l'imbrication de structures—le fondement de l'héritage en C.

Vous allez créer une hiérarchie où un Employee contient une Person. Cela reflète le fonctionnement de l'héritage : un employé "est une" personne avec des informations supplémentaires liées au travail. En imbriquant la structure Person à l'intérieur de Employee, vous obtenez toutes les propriétés de la personne plus les champs spécifiques à l'employé.

Vous organiserez votre code sur trois fichiers :

types.h : Définissez les deux structures ici avec des gardes d'inclusion. Tout d'abord, créez une structure Person avec deux champs : name (un tableau de 50 caractères) et age (un entier). Ensuite, définissez une structure Employee qui imbrique Person comme premier membre et ajoute un champ employee_id (un entier).
types.c : Implémentez une fonction appelée print_employee qui prend un pointeur vers un Employee et affiche ses informations. Accédez aux données de la personne imbriquée en utilisant la syntaxe chaînée point/flèche que vous avez apprise.
main.c : Créez une variable Employee, remplissez tous ses champs (y compris le nom et l'âge de la personne imbriquée), et utilisez votre fonction d'affichage pour présenter les informations.

Vous recevrez trois entrées : le nom de l'employé (une chaîne de caractères), son âge (un entier) et son ID d'employé (un entier).

Votre fonction print_employee doit afficher les informations de l'employé dans ce format :

Employee: Alice
Age: 28
ID: 1001

Où Alice est le nom, 28 est l'âge, et 1001 est l'ID de l'employé provenant de vos entrées.

N'oubliez pas d'accéder aux membres de la structure imbriquée via le membre parent—par exemple, pour atteindre le nom, vous naviguerez d'abord par le membre person.

Aide-mémoire

Le C ne possède pas d'héritage intégré, mais vous pouvez le simuler en utilisant la composition — l'imbrication d'une structure à l'intérieur d'une autre.

Pour créer une relation parent-enfant, imbriquez la structure parente en tant que membre de la structure enfant :

typedef struct {
    int id;
    char name[50];
} Parent;

typedef struct {
    Parent parent;  // Embedded struct
    int grade;
} Child;

La structure enfant contient toutes les propriétés du parent, plus ses propres champs supplémentaires. Cela représente une relation de type « a un » (has a).

Pour accéder aux membres de la structure imbriquée, utilisez l'opérateur point deux fois :

Child c;
c.parent.id = 101;
c.parent.name[0] = 'A';
c.grade = 5;

Lorsque vous travaillez avec des pointeurs, utilisez l'opérateur flèche pour accéder aux membres de la structure imbriquée :

Child *ptr = &c;
ptr->parent.id = 101;
ptr->grade = 5;

L'imbrication de la structure de base en tant que premier membre est un modèle courant qui permet des techniques avancées pour construire des hiérarchies de types en C.

Essayez vous-même

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

int main() {
    // Lire l'entrée
    char name[50];
    int age;
    int employee_id;
    
    fgets(name, 50, stdin);
    name[strcspn(name, "\n")] = '\0';  // Supprimer le saut de ligne
    scanf("%d", &age);
    scanf("%d", &employee_id);
    
    // TODO: Créer une variable Employee
    
    // TODO: Remplir le nom et l'âge de la personne imbriquée
    // Hint: Utiliser strcpy pour le nom, accéder avec employee.person.name
    
    // TODO: Définir l'employee_id
    
    // TODO: Appeler print_employee avec un pointeur vers votre employee
    
    return 0;
}