La règle du premier membre

Fait partie de la section Programmation Orientée Objet du Journey C de Coddy. Leçon 29 sur 61.

Lorsque vous intégrez une structure en tant que premier membre d’une autre structure, quelque chose de puissant se produit : l’adresse mémoire de la structure externe est identique à l’adresse mémoire de son premier membre. Cela est garanti par la norme C.

Considérons notre exemple précédent :

typedef struct {
    int id;
} Parent;

typedef struct {
    Parent parent;  // Premier membre
    int grade;
} Child;

Lorsque tu crées une variable Child, le membre Parent se trouve tout au début de la mémoire de Child. Cela signifie qu’un pointeur vers Child pointe vers exactement la même adresse qu’un pointeur vers son membre Parent.

Child c;
Child* child_ptr = &c;
Parent* parent_ptr = (Parent*)child_ptr;  // Cast sûr !

Les deux pointeurs contiennent la même adresse. Cela vous permet de transmettre un Child* à toute fonction qui attend un Parent* :

void print_id(Parent* p) {
    printf("ID: %d\n", p->id);
}

// Dans main :
Child c;
c.parent.id = 42;
print_id((Parent*)&c);  // Fonctionne parfaitement

Cette technique est le fondement de l’héritage en C. Une fonction écrite pour le type de base peut fonctionner sur n’importe quel type dérivé, tant que la base est intégrée en premier. La conversion est sûre, car les organisations de la mémoire s’alignent parfaitement.

Défi

Facile

Explorons la règle du premier membre en construisant une hiérarchie animale simple. Vous allez créer une structure de base Animal et une structure dérivée Dog, puis démontrer comment un pointeur vers Dog peut être converti en toute sécurité en pointeur vers Animal.

L’idée clé que vous allez appliquer est la suivante : lorsque Animal est le premier membre de Dog, les deux structures partagent la même adresse mémoire de départ. Cela signifie que vous pouvez transmettre un Dog* à toute fonction qui attend un Animal* en convertissant le pointeur.

Vous allez organiser votre code sur trois fichiers :

animal.h : définissez les deux structures avec des gardes d’inclusion. Votre structure Animal doit posséder un seul champ : legs (un entier représentant le nombre de pattes). Votre structure Dog doit intégrer Animal comme son premier membre et ajouter un champ name (un tableau de caractères de 50 caractères). Déclarez également une fonction print_animal qui prend un paramètre Animal*.
animal.c : implémentez la fonction print_animal. Cette fonction travaille avec le type de base. Elle ne connaît que Animal et affiche le nombre de pattes de l’animal.
main.c : créez une variable Dog et renseignez ses champs (à la fois le nombre de pattes de l’animal intégré et le nom du chien). Montrez ensuite la règle du premier membre en convertissant votre Dog* en Animal* et en le transmettant à print_animal. Affichez également le nom du chien séparément afin de présenter l’ensemble du résultat.

Vous recevrez deux entrées : le nom du chien (une chaîne) et le nombre de pattes (un entier).

Votre sortie devrait ressembler à ceci :

Dog: Buddy
Legs: 4

Où Buddy est le nom du chien et 4 est le nombre de pattes. Affichez d’abord le nom du chien depuis main.c, puis appelez print_animal avec le pointeur converti pour afficher le nombre de pattes.

Cela montre comment une fonction écrite pour le type de base (Animal) peut fonctionner parfaitement avec un type dérivé (Dog) grâce à la conversion de pointeurs : le fondement de l’héritage en C.

Essayez vous-même

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

int main() {
    // Lire l'entrée
    char name[50];
    int legs;
    scanf("%s", name);
    scanf("%d", &legs);
    
    // TODO: Créer une variable Dog
    
    // TODO: Définir le nom du chien avec strcpy
    
    // TODO: Définir le nombre de pattes (accès via l'Animal embarqué)
    
    // TODO: Afficher le nom du chien au format : "Dog: <name>"
    
    // TODO: Convertir Dog* en Animal* et appeler print_animal
    // Ceci démontre la règle du premier membre !
    
    return 0;
}