Héritage multiple en C++

1. Utiliser l’héritage multiple pour appliquer plusieurs propriétés des deux classes données à une autre
2. Utilisez le mot-clé virtuel pour corriger plusieurs copies des classes de base

Cet article présente plusieurs méthodes d’utilisation de plusieurs héritages en C++.

Utiliser l’héritage multiple pour appliquer plusieurs propriétés des deux classes données à une autre

Les classes en C++ peuvent avoir plusieurs héritages, ce qui offre la possibilité de dériver une classe de plusieurs classes de base directes.

Cela implique qu’il peut y avoir un comportement inhabituel particulier lorsque les classes ne sont pas implémentées avec soin. Par exemple, considérons l’extrait de code suivant, où la classe C est dérivée des classes B et A. Tous ont le constructeur par défaut qui génère la chaîne spéciale. Cependant, lorsque nous déclarons un objet de type C dans la fonction mainc, trois constructeurs impriment la sortie. Notez que les constructeurs sont appelés dans le même ordre qu’ils ont été hérités. En revanche, les destructeurs sont appelés dans l’ordre inverse.

#include <iostream>

using std::cin;
using std::cout;
using std::endl;
using std::string;

class A {
 public:
  A() { cout << "A's constructor called" << endl; }
};

class B {
 public:
  B() { cout << "B's constructor called" << endl; }
};

class C : public B, public A {
 public:
  C() { cout << "C's constructor called" << endl; }
};

int main() {
  C c;
  return 0;
}

Production:

Bs constructor called
As constructor called
Cs constructor called

Utilisez le mot-clé virtuel pour corriger plusieurs copies des classes de base

Notez que le programme suivant sort les deux instances du constructeur de classe Planet, les constructeurs Mars et Earth chacun, et enfin le constructeur de classe Rock. De plus, le destructeur de la classe Planet sera appelé deux fois lorsque l’objet sortira de sa portée. Attention cependant, ce problème peut être résolu en ajoutant le mot-clé virtual aux classes Mars et Earth. Lorsqu’une classe a plusieurs classes de base, il est possible que la classe dérivée hérite d’un membre avec le même nom de deux ou plusieurs de ses classes de base.

#include <iostream>

using std::cin;
using std::cout;
using std::endl;
using std::string;

class Planet {
 public:
  Planet(int x) { cout << "Planet::Planet(int ) called" << endl; }
};

class Mars : public Planet {
 public:
  Mars(int x) : Planet(x) { cout << "Mars::Mars(int ) called" << endl; }
};

class Earth : public Planet {
 public:
  Earth(int x) : Planet(x) { cout << "Earth::Earth(int ) called" << endl; }
};

class Rock : public Mars, public Earth {
 public:
  Rock(int x) : Earth(x), Mars(x) { cout << "Rock::Rock(int ) called" << endl; }
};

int main() { Rock tmp(30); }

Production:

Planet::Planet(int ) called
Mars::Mars(int ) called
Planet::Planet(int ) called
Earth::Earth(int ) called
Rock::Rock(int ) called