虚基类

     多继承体系中：  
        class   B{};  
        class   A   :   public   B{};  
        class   C   :   public   B{};  
        class   D   :   public   A,   public   C{};  
        A里有个B，C里也有个B，则D里会有两个B。  
        如果  
        class   B{};  
        class   A   :   virtual   public   B{};  
        class   C   :   virtual   public   B{};  
        class   D   :   public   A,   public   C{};  
        B是A，C，以及更高层D的虚基类，此时  
        A里有个B，C里也有个B，但D里只有一个B，这就是虚基类的作用。

抽象类：是指包含纯虚函数的类，纯虚函数形如： virtual  type   function()   =   0; ，这样的类不能用来定义对象。此种类的重要作用就是定义一个统一的接口。
========================

#include <iostream.h>
class A{
public:
void fn(){cout<<"A: fn()"<<endl;}
};
class B1: virtual public A{ //虚拟继承
public:
void fn(){cout<<"B1: fn()"<<endl;}
};
class B2: virtual public A{ //虚拟继承
public:
void fn(){cout<<"B2: fn()"<<endl;}
};
class C1: public B1 { };
class C2: public B2 { };
class D: public C1,public C2 {};
void main()
{D obj;
obj.C1::fn();
obj.C2::fn();
obj.A::fn(); //可以执行,无二义性
}

　　在本例中，若类A不是虚基类,则语句obj.A∷fn()就不能执行,这是因为计算机无法确定是执行B1继承的基类A的函数,还是执行B2继承的基类A的函数,具有二义性。A为虚基类就只有一个基类副本。

==============================

class Base1 {
public:
    Base1(void) {
    cout << "class Base1" << endl;
    }
};
class Base2 {
public:
    Base2(void) {
    cout << "class Base2" << endl;
    }
};
class Level1:virtual public Base2,public Base1 {
public:
    Level1(void) {
    cout << "class Level1" << endl;
    }
};
class Level2:public Base2,virtual public Base1 {
public:
    Level2(void) {
    cout << "class Level2" << endl;
    }
};
class Leaf:public Level1,virtual public Level2 {
public:
    Leaf(void) {
    cout << "class Leaf" << endl;
    }
};
     
int main(void) {
    Leaf obj;
    return 0;
}
遵循两个原则，而且按顺序优先满足：1 先调用完所以基类，再调用子类；2 先调用虚拟基类，再调用非虚拟基类。
Base2
Base1
Base2
Level2
Base1
Level1
Leaf