详解C++中基类与派生类的转换以及虚基类

C++基类与派生类的转换
在公用继承、私有继承和保护继承中，只有公用继承能较好地保留基类的特征，它保留了除构造函数和析构函数以外的基类所有成员，基类的公用或保护成员的访问权限在派生类中全部都按原样保留下来了，在派生类外可以调用基类的公用成员函数访问基类的私有成员。因此，公用派生类具有基类的全部功能，所有基类能够实现的功能， 公用派生类都能实现。而非公用派生类（私有或保护派生类）不能实现基类的全部功能（例如在派生类外不能调用基类的公用成员函数访问基类的私有成员）。因此，只有公用派生类才是基类真正的子类型，它完整地继承了基类的功能。

不同类型数据之间在一定条件下可以进行类型的转换，例如整型数据可以赋给双精度型变量，在赋值之前，把整型数据先转换成为双精度型数据，但是不能把一个整型数据赋给指针变量。这种不同类型数据之间的自动转换和赋值，称为赋值兼容。现在要讨论 的问题是：基类与派生类对象之间是否也有赋值兼容的关系，可否进行类型间的转换？

回答是可以的。基类与派生类对象之间有赋值兼容关系，由于派生类中包含从基类继承的成员，因此可以将派生类的值赋给基类对象，在用到基类对象的时候可以用其子类对象代替。具体表现在以下几个方面。

1) 派生类对象可以向基类对象赋值

可以用子类(即公用派生类)对象对其基类对象赋值。如

  A a1; //定义基类A对象a1
  B b1; //定义类A的公用派生类B的对象b1
  a1=b1; //用派生类B对象b1对基类对象a1赋值

在赋值时舍弃派生类自己的成员。也就是“大材小用”，如图

实际上，所谓赋值只是对数据成员赋值，对成员函数不存在赋值问题。

请注意，赋值后不能企图通过对象a1去访问派生类对象b1的成员，因为b1的成员与a1的成员是不同的。假设age是派生类B中增加的公用数据成员，分析下面的用法：
    a1.age=23;  //错误，a1中不包含派生类中增加的成员
    b1.age=21;  //正确，b1中包含派生类中增加的成员

应当注意，子类型关系是单向的、不可逆的。B是A的子类型，不能说A是B的子类型。只能用子类对象对其基类对象赋值，而不能用基类对象对其子类对象赋值，理由是显然的，因为基类对象不包含派生类的成员，无法对派生类的成员赋值。同理，同一基类的不同派生类对象之间也不能赋值。

2) 派生类对象可以替代基类对象向基类对象的引用进行赋值或初始化

如已定义了基类A对象a1，可以定义a1的引用变量：

  A a1; //定义基类A对象a1
  B b1; //定义公用派生类B对象b1
  A& r=a1; //定义基类A对象的引用变量r，并用a1对其初始化

这时，引用变量r是a1的别名，r和a1共享同一段存储单元。也可以用子类对象初始化引用变量r，将上面最后一行改为

  A& r=b1; //定义基类A对象的引用变量r，并用派生类B对象b1对其初始化

或者保留上面第3行“A& r=a1;”，而对r重新赋值：

  r=b1; //用派生类B对象b1对a1的引用变量r赋值

注意，此时r并不是b1的别名，也不与b1共享同一段存储单元。它只是b1中基类部分的别名，r与b1中基类部分共享同一段存储单元，r与b1具有相同的起始地址。

3) 如果函数的参数是基类对象或基类对象的引用，相应的实参可以用子类对象。

如有一函数：

  fun: void fun(A& r) //形参是类A的对象的引用变量
  {
    cout<<r.num<<endl;
  } //输出该引用变量的数据成员num

函数的形参是类A的对象的引用变量，本来实参应该为A类的对象。由于子类对象与派生类对象赋值兼容，派生类对象能自动转换类型，在调用fun函数时可以用派生类B的对象b1作实参：

   fun(b1);

输出类B的对象b1的基类数据成员num的值。

与前相同，在fun函数中只能输出派生类中基类成员的值。

4) 派生类对象的地址可以赋给指向基类对象的指针变量，也就是说，指向基类对象的指针变量也可以指向派生类对象。

[例] 定义一个基类Student(学生)，再定义Student类的公用派生类Graduate(研究生)， 用指向基类对象的指针输出数据。本例主要是说明用指向基类对象的指针指向派生类对象，为了减少程序长度，在每个类中只设很少成员。学生类只设num(学号),name(名字)和score(成绩)3个数据成员，Graduate类只增加一个数据成员pay(工资)。程序如下：

#include <iostream>
#include <string>
using namespace std;
class Student//声明Student类
{
public:
  Student(int, string,float); //声明构造函数
  void display( ); //声明输出函数
private:
  int num;
  string name;
  float score;
};
Student::Student(int n, string nam,float s) //定义构造函数
{
  num=n;
  name=nam;
  score=s;
}
void Student::display( ) //定义输出函数
{
  cout<<endl<<"num:"<<num<<endl;
  cout<<"name:"<<name<<endl;
  cout<<"score:"<<score<<endl;
}
class Graduate:public Student //声明公用派生类Graduate
{
public:
 Graduate(int, string ,float,float); //声明构造函数
 void display( ); //声明输出函数
private:
 float pay; //工资
};
//定义构造函数
Graduate::Graduate(int n, string nam,float s,float p):Student(n,nam,s),pay(p){ }
void Graduate::display() //定义输出函数
{
  Student::display(); //调用Student类的display函数
  cout<<"pay="<<pay<<endl;
}
int main()
{
  Student stud1(1001,"Li",87.5); //定义Student类对象stud1
  Graduate grad1(2001,"Wang",98.5,563.5); //定义Graduate类对象grad1
  Student *pt=&stud1; //定义指向Student类对象的指针并指向stud1
  pt->display( ); //调用stud1.display函数
  pt=&grad1; //指针指向grad1
  pt->display( ); //调用grad1.display函数
}

下面对程序的分析很重要，请大家仔细阅读和思考。

很多读者会认为，在派生类中有两个同名的display成员函数，根据同名覆盖的规则，被调用的应当是派生类Graduate对象的display函数，在执行Graduate::display函数过程中调用Student::display函数，输出num,name,score，然后再输出pay的值。

事实上这种推论是错误的，先看看程序的输出结果：

num:1001
name:Li
score:87.5

num:2001
name:wang
score:98.5

前3行是学生stud1的数据，后3行是研究生grad1的数据，并没有输出pay的值。

问题在于pt是指向Student类对象的指针变量，即使让它指向了grad1，但实际上pt指向的是grad1中从基类继承的部分。

通过指向基类对象的指针，只能访问派生类中的基类成员，而不能访问派生类增加的成员。所以pt->display()调用的不是派生类Graduate对象所增加的display函数，而是基类的display函数，所以只输出研究生grad1的num,name,score3个数据。

如果想通过指针输出研究生grad1的pay，可以另设一个指向派生类对象的指针变量ptr，使它指向grad1，然后用ptr->display()调用派生类对象的display函数。但这不大方便。

通过本例可以看到，用指向基类对象的指针变量指向子类对象是合法的、安全的，不会出现编译上的错误。但在应用上却不能完全满足人们的希望，人们有时希望通过使用基类指针能够调用基类和子类对象的成员。如果能做到这点，程序人员会感到方便。后续章节将会解决这个问题。办法是使用虚函数和多态性。

C++虚基类详解
多继承时很容易产生命名冲突，即使我们很小心地将所有类中的成员变量和成员函数都命名为不同的名字，命名冲突依然有可能发生，比如非常经典的菱形继承层次。如下图所示：

类A派生出类B和类C，类D继承自类B和类C，这个时候类A中的成员变量和成员函数继承到类D中变成了两份，一份来自 A-->B-->D 这一路，另一份来自 A-->C-->D 这一条路。

在一个派生类中保留间接基类的多份同名成员，虽然可以在不同的成员变量中分别存放不同的数据，但大多数情况下这是多余的：因为保留多份成员变量不仅占用较多的存储空间，还容易产生命名冲突，而且很少有这样的需求。

为了解决这个问题，C++提供了虚基类，使得在派生类中只保留间接基类的一份成员。

声明虚基类只需要在继承方式前面加上 virtual 关键字，请看下面的例子：

#include <iostream>
using namespace std;
class A{
protected:
  int a;
public:
  A(int a):a(a){}
};
class B: virtual public A{ //声明虚基类
protected:
  int b;
public:
  B(int a, int b):A(a),b(b){}
};
class C: virtual public A{ //声明虚基类
protected:
  int c;
public:
  C(int a, int c):A(a),c(c){}
};
class D: virtual public B, virtual public C{ //声明虚基类
private:
  int d;
public:
  D(int a, int b, int c, int d):A(a),B(a,b),C(a,c),d(d){}
  void display();
};
void D::display(){
  cout<<"a="<<a<<endl;
  cout<<"b="<<b<<endl;
  cout<<"c="<<c<<endl;
  cout<<"d="<<d<<endl;
}
int main(){
  (new D(1, 2, 3, 4)) -> display();
  return 0;
}

运行结果：

a=1
b=2
c=3
d=4

本例中我们使用了虚基类，在派生类D中只有一份成员变量 a 的拷贝，所以在 display() 函数中可以直接访问 a，而不用加类名和域解析符。

请注意派生类D的构造函数，与以往的用法有所不同。以往，在派生类的构造函数中只需负责对其直接基类初始化，再由其直接基类负责对间接基类初始化。现在，由于虚基类在派生类中只有一份成员变量，所以对这份成员变量的初始化必须由派生类直接给出。如果不由最后的派生类直接对虚基类初始化，而由虚基类的直接派生类（如类B和类C）对虚基类初始化，就有可能由于在类B和类C的构造函数中对虚基类给出不同的初始化参数而产生矛盾。所以规定：在最后的派生类中不仅要负责对其直接基类进行初始化，还要负责对虚基类初始化。

有的读者会提出：类D的构造函数通过初始化表调了虚基类的构造函数A，而类B和类C的构造函数也通过初始化表调用了虚基类的构造函数A，这样虚基类的构造函数岂非被调用了3次？大家不必过虑，C++编译系统只执行最后的派生类对虚基类的构造函数的调用，而忽略虚基类的其他派生类（如类B和类C）对虚基类的构造函数的调用，这就保证了虚基类的数据成员不会被多次初始化。

最后请注意：为了保证虚基类在派生类中只继承一次，应当在该基类的所有直接派生类中声明为虚基类，否则仍然会出现对基类的多次继承。

可以看到：使用多重继承时要十分小心，经常会出现二义性问题。上面的例子是简单的，如果派生的层次再多一些，多重继承更复杂一些，程序员就很容易陷人迷 魂阵，程序的编写、调试和维护工作都会变得更加困难。因此很多程序员不提倡在程序中使用多重继承，只有在比较简单和不易出现二义性的情况或实在必要时才使用多重继承，能用单一继承解决的问题就不要使用多重继承。也正由于这个原因，C++之后的很多面向对象的编程语言（如Java、Smalltalk、C#、PHP等）并不支持多重继承。