virtual>Class

虚基类的特点：
       虚基类构造函数的参数必须由最新派生出来的类负责初始化（即使不是直接继承）；
       虚基类的构造函数先于非虚基类的构造函数执行。
如果一个派生类有多个直接基类，而这些直接基类又有一个共同的基类，则在最终的派生类中会保留该间接共同基类数据成员的多份同名成员。
C++提供虚基类(virtual base class )的方法，使得在继承间接共同基类时只保留一份成员。
为了保证虚基类在派生类中只继承一次，应当在该基类的所有直接派生类中声明为虚基类。否则仍然会出现对基类的多次继承。

#include <iostream>  
using namespace std;
//基类  
class CBase  
{  
    protected:  
            int a;  
    public:  
          CBase(int na)  
            {  
                  a=na;  
                    cout<<"CBase constructor! ";  
        }  
  
           ~CBase(){cout<<"CBase deconstructor! "<<endl;}  
};  
  
class UCBase  
{  
    protected:  
            int a;  
    public:  
          UCBase(int na)  
            {  
                  a=na;  
                    cout<<"UCBase constructor! ";  
        }  
  
           ~UCBase(){cout<<"UCBase deconstructor! "<<endl;}  
};  
//派生类1(声明CBase为虚基类)  
class CDerive1:virtual public CBase  
{  
public:  
    CDerive1(int na):CBase(na)  
    {  
        cout<<"CDerive1 constructor! ";  
    }  
      
    ~CDerive1(){cout<<"CDerive1 deconstructor! "<<endl;;}  
  
    int GetA(){return a;}  
};  
class UCDerive1: public UCBase  
{  
public:  
    UCDerive1(int na):UCBase(na)  
    {  
        cout<<"UCDerive1 constructor! ";  
    }  
      
    ~UCDerive1(){cout<<"UCDerive1 deconstructor! "<<endl;;}  
  
    int GetA(){return a;}  
};  
  
//派生类2(声明CBase为虚基类)  
class CDerive2:virtual public CBase  
{  
public:  
    CDerive2(int na):CBase(na)  
    {  
        cout<<"CDerive2 constructor! ";  
    }  
    ~CDerive2(){cout<<"CDerive2 deconstructor! "<<endl;}  
    int GetA(){return a;}  
};  
class UCDerive2:public UCBase  
{  
public:  
   UCDerive2(int na):UCBase(na)  
    {  
        cout<<"UCDerive2 constructor! ";  
    }  
    ~UCDerive2(){cout<<"UCDerive2 deconstructor! "<<endl;}  
    int GetA(){return a;}  
};  
  
//子派生类  
class CDerive12:public CDerive1,public CDerive2  
{  
public:  
    CDerive12(int na1,int na2,int na3):CDerive1(na1),CDerive2(na2),CBase(na3)  
    {  
        cout<<"CDerive12 constructor! ";  
    }  
    ~CDerive12(){cout<<"CDerive12 deconstructor! "<<endl;}  
};  

class UCDerive12:public UCDerive1,public UCDerive2,public UCBase  
{  
public:  
    UCDerive12(int na1,int na2,int na3):UCDerive1(na1),UCDerive2(na2),UCBase(na3)  
    {  
        cout<<"UCDerive12 constructor! ";  
    }  
    ~UCDerive12(){cout<<"UCDerive12 deconstructor! "<<endl;}  
};

int main()
{  
    CDerive12 obj(100,200,300);  
    //得到从CDerive1继承的值  
    cout<<" from CDerive1 : a------->"<<obj.CDerive1::GetA()<<endl;;  
    //得到从CDerive2继承的值  
    cout<<" from CDerive2 : a-------> "<<obj.CDerive2::GetA()<<endl<<endl;  
cout<<"------------------------------------------------------------------"<<endl;
    UCDerive12 uobj(100,200,300);  
    //得到从CDerive1继承的值  
    cout<<" from UCDerive1 : a------->"<<uobj.UCDerive1::GetA()<<endl;;  
    //得到从CDerive2继承的值  
    cout<<" from UCDerive2 : a-------> "<<uobj.UCDerive2::GetA()<<endl<<endl;  
    return 0;
}  
温馨提示：使用多重继承时要十分小心，经常会出现二义性问题。许多专业人员认为：不要提倡在 程序中使用多重继承，
只有在比较简单和不易出现二义性的情况或实在必要时才使用多重继承，能用单一继承解决的问题就不要使用多重继承。
也是由于这个原因， 有些面向对象的程序设计语言(如Java，Smalltalk)并不支持多重继承