Héritage simple et multiple
Modéliser les relations « est-un » avec l’héritage simple et maîtriser les pièges de l’héritage multiple
Héritage simple et multiple est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.
Qu'est-ce que l'héritage ?
L'héritage permet à une classe de réutiliser et d'étendre une autre classe. Il modélise les relations « est un ».
class Animal {
public:
void breathe() { std::cout << "breathing\n"; }
};
class Dog : public Animal {
public:
void bark() { std::cout << "Woof!\n"; }
};Héritage public
Utilisez public pour modéliser la relation « est un » : un Dog est un Animal. Les membres conservent leur niveau d'accès dans la classe dérivée.
Héritage protégé et privé
L'héritage protected et private modélise la relation « est implémenté en termes de » et est rarement utilisé. Préférez la composition dans ces situations.
Accéder aux membres de la classe de base
La classe dérivée peut utiliser directement tout membre public ou protégé de la classe de base.
Dog d;
d.breathe(); // inherited from Animal
d.bark(); // own memberOrdre de construction
Les constructeurs de la classe de base s'exécutent avant ceux de la classe dérivée. Utilisez la liste d'initialisation des membres pour transmettre des arguments à la classe de base.
class Pet : public Animal {
std::string name_;
public:
Pet(std::string n) : Animal(), name_(std::move(n)) {}
};Ordre de destruction
Les destructeurs s'exécutent dans l'ordre inverse : d'abord celui de la classe dérivée, puis celui de la classe de base. Rendez les destructeurs de base virtual si vous supprimez un objet via un pointeur vers la classe de base.
Héritage multiple
C++ permet à une classe d'hériter de plusieurs classes de base. Utilisez cette possibilité avec parcimonie : elle complique la conception.
class Printable { public: virtual void print() = 0; };
class Serializable { public: virtual std::string serialize() = 0; };
class Document : public Printable, public Serializable {
// implements both interfaces
};Le problème du diamant
Si deux classes de base partagent une base commune, la classe dérivée se retrouve avec deux copies de cette base. Résolvez ce problème avec l'héritage virtuel.
class A {};
class B : virtual public A {};
class C : virtual public A {};
class D : public B, public C {}; // D has ONE A, not twoCoût de l'héritage virtuel
Les classes de base virtuelles ajoutent un surcoût : un pointeur supplémentaire par objet et une indirection supplémentaire lors de chaque accès à un membre de la classe de base. Évitez-les lorsque c'est possible.
Composition ou héritage
Souvent, la composition « a un » est plus simple que l'héritage « est un ». Un Car possède un Engine : n'héritez pas de Car depuis Engine.
class Engine { /* ... */ };
class Car {
Engine engine_; // composition
};Héritage d'interface ou d'implémentation
Deux utilisations courantes :
- Interface — dériver d'une classe de base purement virtuelle pour respecter un contrat
- Implémentation — dériver pour réutiliser du code (CRTP, classes de composition)
Quand utiliser l'héritage
Utilisez l'héritage lorsque :
- il existe une véritable relation « est un »
- vous avez besoin du polymorphisme à l'exécution via des fonctions virtuelles
- la classe de base est conçue pour être dérivée
Vérification rapide
Quelle technique empêche d'avoir deux copies d'une classe de base commune en cas d'héritage multiple ?
Récapitulatif
L'héritage modélise les relations « est un » avec l'héritage public. L'héritage multiple est autorisé, mais le problème du diamant nécessite un héritage virtuel. Préférez la composition pour les relations « a un » et la réutilisation du code.
Questions Fréquemment Posées
La leçon « Héritage simple et multiple » est-elle gratuite ?
Oui — le texte complet de « Héritage simple et multiple » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « Héritage simple et multiple » ?
Modéliser les relations « est-un » avec l’héritage simple et maîtriser les pièges de l’héritage multiple Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer C++ Academy ?
Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « Héritage simple et multiple » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?
Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- Héritage simple et multiple
- Fonctions virtuelles et vtable
- Classes abstraites et méthodes virtuelles pures
- Héritage ou composition : compromis