面向对象的程序设计学习笔记4-虚基类

若一个派生类衍生于多个基类，而这些基类又有一个共同的基类，则在对该基类中声明的名字进行访问时，可能产生二义性。例如下面的例子：

#include <iostream>
using namespace std;
class B
{
public:
int b;
};
class B1:public B
{
private: 
int b1;
};
class B2:public B
{
private:
int b2;
};
class C:public B1,public B2
{
public:
int f();
private:
int d;
};
void main()
{
C c1;
c1.b;//产生二义性
c1.B::b;//从哪里继承来的呢？
c1.B1::b;//才是正确的
c1.B2::b;
}

修改后的程序

#include <iostream>
using namespace std;
class B
{
public:
int b;
};
class B1:public B
{
private: 
int b1;
};
class B2:public B
{
private:
int b2;
};
class C:public B1,public B2
{
public:
int f();
private:
int d;
};
void main()
{
C c1;

c1.B1::b=5;
c1.B2::b=10;
cout<<"path B1="<<c1.B1::b<<endl;
cout<<"path B2="<<c1.B2::b<<endl;
}

在建立C类对象的时候，B的构造函数将被调用两次：一次是由B1所调用的，一次是由B2所调用的，以初始化C类的对象中所包含的两个B类的子对象。在此时的公共基类会在派生类的对象中产生多个基类子对象。要使这个公共基类在派生类中只产生一个子对象，需要将此基类声明为虚基类。所以vitual关键字是加在继承中。

具体的例子如下：

#include <iostream>
using namespace std;
class B
{
public:
int b;
};
class B1:virtual public B
{
private: 
int b1;
};
class B2:virtual public B
{
private:
int b2;
};
class C:public B1,public B2
{
public:
int f();
private:
int d;
};
void main()
{
C c1;
c1.b=1;//此时就可以调用了，此时的C类对象c1中只有一个B类的子对象
cout<<"path B1="<<c1.b<<endl;cout<<"path B2="<<c1.b<<endl;
c1.B1::b=5;
cout<<"path B1="<<c1.B1::b<<endl;cout<<"path B2="<<c1.B2::b<<endl;
c1.B2::b=10;
cout<<"path B1="<<c1.B1::b<<endl;cout<<"path B2="<<c1.B2::b<<endl;
}

此时的b成员被约束到该子对象上，所以，以不同路径使用名字b访问B类的子对象时，所访问的都是唯一的基类子对象。即c1.B1::b和c1.B2::b是引用同一个基类B的子对象。

下面的例子，可以直观地对比看出虚基类的好处。

#include <iostream>
using namespace std;
class A
{
public:
A(){cout<<"class A"<<endl;}//构造函数
};
class B:virtual public A
{
public:
B(){cout<<"class B"<<endl;}//构造函数…………
};
class C:virtual public A
{
public:
C(){cout<<"class C"<<endl;}
};
class D:public B,public C
{
public:
D(){cout<<"class D"<<endl;}
};
void main()
{
D d;
}

从运行的结果可以看出，创建D类对象d时，分别是调用了ABCD的构造函数。若是没有使用虚基类呢？请看下面的例子：

#include <iostream>
using namespace std;
class A
{
public:
A(){cout<<"class A"<<endl;}//构造函数
};
class B: public A
//class B:virtual public A
{
public:
B(){cout<<"class B"<<endl;}//构造函数…………
};
class C: public A
//class C:virtual public A
{
public:
C(){cout<<"class C"<<endl;}
};
class D:public B,public C
{
public:
D(){cout<<"class D"<<endl;}
};
void main()
{
D d;
}

从运行的结果可以看出，创建D类对象d时，是先调用AB的构造函数，再调用AC的构造函数，最后调用D的构造函数。