Modèles d'héritage en C++ : Multiple, Multiniveau, Hiérarchique

Modèles d'héritage en C++ : Multiple, Multiniveau, Hiérarchique

Dans ce tutoriel, nous explorons les modèles d'héritage C++ — multiple, multiniveau et hiérarchique — avec des exemples de code pratiques.

L'héritage est une fonctionnalité fondamentale de la programmation orientée objet. Il permet aux développeurs de créer de nouvelles classes qui héritent des propriétés et du comportement de classes existantes.

Ci-dessous, nous examinons trois modèles d'héritage clés disponibles en C++.

---

Héritage multiniveau en C++

Dans une hiérarchie multiniveau, une classe dérive d'une autre classe dérivée. La chaîne continue jusqu'à ce qu'une classe de base soit atteinte.

class A {
    // Implémentation de la classe de base
};
class B : public A {
    // B hérite de A
};
class C : public B {
    // C hérite de B
};

Ici, B hérite de A, et C hérite de B, formant une chaîne d'héritage verticale.

Exemple 1 : Héritage multiniveau en C++

#include <iostream>
using namespace std;

class A {
public:
    void display() {
        cout << "Contenu de la classe de base." << endl;
    }
};

class B : public A {};

class C : public B {};

int main() {
    C obj;
    obj.display();
    return 0;
}

Sortie

Contenu de la classe de base.

Ce programme démontre qu'un objet de C peut invoquer display() défini dans la classe de base ultime A car aucune implémentation de redéfinition n'existe dans B ou C. Le compilateur résout l'appel en recherchant la chaîne d'héritage de la classe la plus dérivée vers le haut.

---

Héritage multiple en C++

C++ permet à une classe d'hériter de plus d'une classe de base. Par exemple, une ChauveSouris peut dériver à la fois de Mammifere et AnimalAile car une chauve-souris est simultanément un mammifère et une créature ailée.

Exemple 2 : Héritage multiple en C++

#include <iostream>
using namespace std;

class Mammifere {
public:
    Mammifere() {
        cout << "Les mammifères peuvent donner naissance directement." << endl;
    }
};

class AnimalAile {
public:
    AnimalAile() {
        cout << "Les animaux ailés peuvent battre des ailes." << endl;
    }
};

class ChauveSouris : public Mammifere, public AnimalAile {};

int main() {
    ChauveSouris b1;
    return 0;
}

Sortie

Les mammifères peuvent donner naissance directement.
Les animaux ailés peuvent battre des ailes.

Résolution d'ambiguïté dans l'héritage multiple

Quand deux classes de base fournissent une fonction avec le même nom, le compilateur ne peut pas décider laquelle invoquer, ce qui entraîne une erreur d'ambiguïté.

class Base1 {
public:
    void someFunction() { /* ... */ }
};

class Base2 {
public:
    void someFunction() { /* ... */ }
};

class Derived : public Base1, public Base2 {};

int main() {
    Derived obj;
    // obj.someFunction(); // Erreur : ambigu
}

Utilisez l'opérateur de résolution de portée pour spécifier la fonction de classe de base désirée :

int main() {
    Derived obj;
    obj.Base1::someFunction(); // Appelle l'implémentation de Base1
    obj.Base2::someFunction(); // Appelle l'implémentation de Base2
}

---

Héritage hiérarchique en C++

Dans l'héritage hiérarchique, plusieurs classes dérivées héritent d'une seule classe de base. Tous les attributs et comportements communs sont encapsulés dans la classe de base, tandis que chaque classe dérivée peut ajouter sa propre spécialisation.

Les exemples incluent Physique, Chimie et Biologie dérivant de Science ; et Chien, Chat, Cheval dérivant de Animal.

Syntaxe de l'héritage hiérarchique

class ClasseBase {
    // Contenu de la classe de base
};
class DeriveeUn : public ClasseBase {
    // Membres additionnels
};
class DeriveeDeux : public ClasseBase {
    // Membres additionnels
};
class DeriveeTrois : public ClasseBase {
    // Membres additionnels
};

Exemple 3 : Héritage hiérarchique en C++

// Programme C++ démontrant l'héritage hiérarchique
#include <iostream>
using namespace std;

// Classe de base
class Animal {
public:
    void info() {
        cout << "Je suis un animal." << endl;
    }
};

// Classe dérivée 1
class Chien : public Animal {
public:
    void aboyer() {
        cout << "Je suis un Chien. Woof woof." << endl;
    }
};

// Classe dérivée 2
class Chat : public Animal {
public:
    void miauler() {
        cout << "Je suis un Chat. Miaou." << endl;
    }
};

int main() {
    // Instance Chien
    Chien chien1;
    cout << "Classe Chien:" << endl;
    chien1.info();
    chien1.aboyer();
    
    // Instance Chat
    Chat chat1;
    cout << "\nClasse Chat:" << endl;
    chat1.info();
    chat1.miauler();
    return 0;
}

Sortie

Classe Chien:
Je suis un animal.
Je suis un Chien. Woof woof.
Classe Chat:
Je suis un animal.
Je suis un Chat. Miaou.

À la fois Chien et Chat héritent de la méthode info() de Animal, tandis que chaque classe introduit son propre comportement spécialisé.