Héritage multiple

Décembre 2016

Héritage multiple

Pour représenter le monde réel, l’héritage simple (une seule classe de base directe) est insuffisant. Il est souvent nécessaire de composer une classe en lui faisant hériter de tout ou partie des membres de plusieurs classes mères. L’héritage multiple doit être utilisé à bon escient. En effet, le programme se complique à mesure du développement de la hiérarchie des classes et le débogage des méthodes d’objets dérivés peut être difficile.

Imaginons le cas, par exemple, d’une classe Cherubin qui hérite des deux classes Enfant et Oiseau. Le code 7.7 illustre la syntaxe de cet héritage double. Pour simplifier sa lecture, ce code ne contient pas les constructeurs et destructeurs obligatoires.

Code 7.7 : syntaxe de l’héritage multiple

#include <iostream> 
using namespace std; 

 class Enfant  //classe dérivée 
{ 
public: 
   void Marcher(); //il marche 
   void Rire();    //il rit 
protected: 
private: 
}; 

class Oiseau 
{ 
public: 
   void Chanter(); //il chante 
   void Voler();   //il vole 
}; 

//la classe Cherubin hérite d’Enfant et de Oiseau :  
class Cherubin : public Enfant, public Oiseau  
{ 
};


Imaginons maintenant que les deux classes Enfant et Oiseau possèdent la même classe de base Creature. On obtient la hiérarchie de classes présentée à la figure 7.3.

Figure 7.3 : exemple de hiérarchie de classes avec héritage multiple.

Le code 7.8 présente l’implémentation de cette hiérarchie en C++, toujours sans les constructeurs et destructeurs.

Code 7.8 : implémentation de deux niveaux d’héritage multiple

#include <iostream> 
using namespace std; 

class Creature 
{ 
public: 
   Creature():age(3){} 
   void Dormir(){}  
   int LireAge() const { return age; } 
private:  
   int age; 
};  

class Enfant : public Creature 
{ 
public: 
   void Marcher(){} 
   void Rire(){} 
protected: 
private: 
}; 

class Oiseau : public Creature 
{ 
public: 
   void Chanter(){} 
   void Voler(){} 
}; 

class Cherubin : public Enfant, public Oiseau 
{ 

}; 

int main() 
{ 
   Cherubin g; 
   cout << g.LireAge(); // ambigu ! 
   return 0; 
}


Si vous compilez ce code, le compilateur renverra un message d’erreur analogue au message suivant :

Cherubin::LireAge est ambigu 
pourrait être ‘LireAge’ de la classe de base ‘Creature’ de la classe de base ‘Enfant’ de la classe ‘Cherubin’ 
ou la fonction ‘LireAge’ de la classe de base ‘Creature’ de la classe de base ‘Oiseau’ de la classe ‘Cherubin’


Le problème est que Cherubin hérite deux fois des membres publics de Creature : en héritant du « sous-objet » Creature de la classe Enfant et en héritant du « sous-objet » Creature de la classe Oiseau.
Le code 7.9 présente la solution à ce problème : l’héritage virtuel.

Le texte original de cette fiche pratique est extrait de
«Tout sur le C++» (Christine EBERHARDT, Collection
CommentCaMarche.net, Dunod, 2009)

A voir également :

Ce document intitulé «  Héritage multiple  » issu de CommentCaMarche (www.commentcamarche.net) est mis à disposition sous les termes de la licence Creative Commons. Vous pouvez copier, modifier des copies de cette page, dans les conditions fixées par la licence, tant que cette note apparaît clairement.