C++多重继承与虚拟继承

　　本文只是粗浅讨论一下C++中的多重继承和虚拟继承。

多重继承中的构造函数和析构函数调用次序

　　我们先来看一下简单的例子：

 #include <iostream>
 using namespace std;

 class A
 {
 private:
     char idA;

 public:
     A(){
         idA = 'A';
         cout << "Constructor of A is called!" << endl;
     }
     ~A() { cout << "Destructor of A is called!" << endl; }
 };

 class B : public A
 {
 private:
     char idB;

 public:
     B(){
         idB = 'B';
         cout << "Constructor of B is called!" << endl;
     }
     ~B() { cout << "Destructor of B is called!" << endl; }
 };

 class C : public A
 {
 private:
     char idC;

 public:
     C(){
         idC = 'C';
         cout << "Constructor of C is called!" << endl;
     }
     ~C() { cout << "Destructor of C is called!" << endl; }
 };

 class D : public B, public C
 {
 private:
     char idD;

 public:
     D(){
         idD = 'D';
         cout << "Constructor of D is called!" << endl;
     }
     ~D() { cout << "Destructor of D is called!" << endl; }
 };

 int main()
 {
     D d;
     return ;
 }

　　上述程序的输出为：

　　

　　由上边结果可以看出，析构函数调用次序跟构造函数是相反的。另外，构造函数调用次序跟类D继承B、C次序（public B, public C）相关。

　　可能我们也发现了，对于类D的实例d来说，它其实有两个重复的A实例。我们应该要去掉其中一个以节省空间。具体做法就是采用虚拟继承的方法：

 class B : public virtual A
 {
     ...
 };

 class C : public virtual A
 {
     ...
 };

　　这是程序的输出就会变成：

　　

　　可见这个时候类D的实例d就只有一个类A实例。

二义性

　　请看下边程序：

 #include <iostream>
 using namespace std;

 class A
 {
 private:
     char idA;

 public:
     A(){
         idA = 'A';
         cout << "Constructor of A is called!" << endl;
     }
     ~A() { cout << "Destructor of A is called!" << endl; }
     char getID() { return idA; }
 };

 class B  : public virtual A
 {
 private:
     char idB;

 public:
     B(){
         idB = 'B';
         cout << "Constructor of B is called!" << endl;
     }
     ~B() { cout << "Destructor of B is called!" << endl; }
     char getID() { return idB; }
 };

 class C : public virtual A
 {
 private:
     char idC;

 public:
     C(){
         idC = 'C';
         cout << "Constructor of C is called!" << endl;
     }
     ~C() { cout << "Destructor of C is called!" << endl; }
     char getID() { return idC; }
 };

 class D : public B, public C
 {
 private:
     char idD;

 public:
     D(){
         idD = 'D';
         cout << "Constructor of D is called!" << endl;
     }
     ~D() { cout << "Destructor of D is called!" << endl; }
     // char getID() { return idD; }
 };

 int main()
 {
     D d;
     cout << d.getID() << endl;

     return ;
 }

　　在main函数中，第63行的d.getID()会优先在类D中查找有没有getID()的定义，如果没有就会到其父类查找；而恰好其父类B、C（同级）均定义了相同的getID()（类A的getID()定义存不存在都没关系），这时d.getID()就不知道要调用B类中的getID()还是C类中的，从而导致二义性。

　　不过我们可以通过d.B::getID()、d.C::getID()来指明具体要调用哪一个类的getID。但我们总不会想到这样子去做，而且这样子做也比较麻烦。

虚函数

　　对于多重继承的虚函数同样存在二义性。

　　先看一下程序：

 #include <iostream>
 using namespace std;

 class A
 {
 private:
     char idA;

 public:
     A(){
         idA = 'A';
         cout << "Constructor of A is called!" << endl;
     }
     ~A() { cout << "Destructor of A is called!" << endl; }
     char getID() { return idA; }
 };

 class B : public virtual A
 {
 private:
     char idB;

 public:
     B(){
         idB = 'B';
         cout << "Constructor of B is called!" << endl;
     }
     ~B() { cout << "Destructor of B is called!" << endl; }
     char getID() { return idB; }
 };

 class C : public virtual A
 {
 private:
     char idC;

 public:
     C(){
         idC = 'C';
         cout << "Constructor of C is called!" << endl;
     }
     ~C() { cout << "Destructor of C is called!" << endl; }
     char getID() { return idC; }
 };

 class D : public B, public C
 {
 private:
     char idD;

 public:
     D(){
         idD = 'D';
         cout << "Constructor of D is called!" << endl;
     }
     ~D() { cout << "Destructor of D is called!" << endl; }
     char getID() { return idD; }
 };

 int main()
 {
     D d;
     A a = d;
     B b = d;
     C c = d;
     cout << a.getID() << endl;
     cout << b.getID() << endl;
     cout << c.getID() << endl;
     cout << d.getID() << endl;

     return ;
 }

　　程序输出如下：

　　

　　上边程序第63~65行相当于a、b、c将d进行了分割（函数是否是虚函数在这里并无关系，而且注意这里的a、b、c、d都不是指针），分割出属于自己的部分，所以调用getID()的时候能正确反映具体的类。

　　

　　我们再来看一个程序：

 #include <iostream>
 using namespace std;

 class A
 {
 private:
     char idA;

 public:
     A(){
         idA = 'A';
         cout << "Constructor of A is called!" << endl;
     }
     ~A() { cout << "Destructor of A is called!" << endl; }
     virtual char getID() { return idA; }
 };

 class B : public virtual A
 {
 private:
     char idB;

 public:
     B(){
         idB = 'B';
         cout << "Constructor of B is called!" << endl;
     }
     ~B() { cout << "Destructor of B is called!" << endl; }
     virtual char getID() { return idB; }
 };

 class C : public virtual A
 {
 private:
     char idC;

 public:
     C(){
         idC = 'C';
         cout << "Constructor of C is called!" << endl;
     }
     ~C() { cout << "Destructor of C is called!" << endl; }
     virtual char getID() { return idC; }
 };

 class D : public B, public C
 {
 private:
     char idD;

 public:
     D(){
         idD = 'D';
         cout << "Constructor of D is called!" << endl;
     }
     ~D() { cout << "Destructor of D is called!" << endl; }
     virtual char getID() { return idD; }
 };

 int main()
 {
     D *d = new D();
     A *a = d;
     B *b = d;
     C *c = d;
     cout << a->getID() << endl;
     cout << b->getID() << endl;
     cout << c->getID() << endl;
     cout << d->getID() << endl;

     delete d;
     return ;
 }

　　程序的输出如下：

　　

　　从输出结果可以看出，类D的getID覆盖其所有父类的getID。需要注意的是，当我们在类D的一个父类，如A中不设定getID为虚函数，则“A *a = d”的效果仍然跟分割d指向的内存的效果一样。