multiple inheritance in C++

Multiple inheritance is a feature of C++.
* In multiple inheritance, constructors of base classes are always called in derivation order from left to right and destructors are called in reverse order. 
* The very first constructors to be executed are the virtual inherited base classes anywhere in the hierarchy. They are executed in the order they appear in a depth-first left-to-right traversal of the graph of base classes, where left to right refer to the order of appearance of base class names. After all virtual inherited base class constructors are finished, the construction order is generally from base class to derived class. The details are easiest to understand if you imagine that the very first thing the compiler does in the derived class’s ctor is to make a hidden call to the ctors of its non-virtual inherited base classes (hint: that’s the way many compilers actually do it). So if class D inherits from B1 and B2, the constructor for B1 executes first, then the constructor for B2, then the constructor for D. This rule is applied recursively; for example, if B1 inherits from B1a and B1b, and B2 inherits from B2a and B2b, then the final order is B1a, B1b, B1, B2a, B2b, B2, D.
```
#include <iostream>
using namespace std;

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

int main() {
    C c;
    return 0;
}
```
Output:
```
A: constructor
B: constructor
C: constructor
```
Home