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 0;
}

　　上述程序的输出为：

　　

　　由上边结果可以看出，析构函数调用次序跟构造函数是相反的。另外，构造函数调用次序跟类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 0;
}

　　在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 0;
}

　　程序输出如下：

　　

　　上边程序第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 0;
}

　　程序的输出如下：

　　

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