Un problème lié à l'héritage multiple est celui de la duplication : on peut être amené à hériter plusieurs fois de la même classe. D'ailleurs, en héritant d'une classe, on ne sait pas forcément quels sont tous les ancêtres de cette classe (le principe de l'encapsulation suppose que l'on peut développer les classes en connaissant uniquement les interfaces) et dans une hiérarchie de classes importante, on peut hériter d'une classe dont un de nos ancêtres avait déjà hérité :
class A : public B, public C{
//...
}
Il est tout à fait possible que B elle-même soit déjà un ancêtre
de C. Il existe deux manières d'hériter de façon multiple d'une
même classe : sans partage (les membres de la classes seront
dupliqués) ou avec partage(les membres ne seront pas
dupliqués mais partagées).
Il faut cependant dans tous les cas qu'il n'y ait pas d'ambiguïté dans l'accès aux membres; c'est pour cette raison que le C++ interdit l'héritage direct de la même classe :
class base{
public:
int a;
//...
};
class dervivee: public base, public base{
//interdit heritage double direct
// ...
};
On n'aurait aucun moyen de distinguer entre les deux
membres a issus des deux classes bases.
Par contre, l'héritage double indirect est possible,
l'utilisateur devant éviter les ambiguïtés dans les accès
aux membres
.
class base{
public:
void f();
//...
};
class d1: public base{
//...pas de membre f
};
class d2: public base{
//...pas de membre f
};
class D: public d1, public d2{
// ...pas de membre f
};
void essai(){
D d;
d.f(); //ambigue d1::base::f() ou
// d2::base::f()
d.d1::f(); //ok
d.d2::f(); //ok
}
Attention, la classe D hérite deux fois de la
classe base. En particulier, les données membres de
la classe base, seront représentées deux fois.