web培训机构关键词优化排名平台

1 菱形继承

之前我们学习继承所用的例子中，派生类只有一个基类，而这种一个派生类只有一个直接基类时的继承关系我们称为单继承。

而在处理实际问题时，一个派生类可能会有两个及以上的基类，那么这种继承关系我们称为多继承。

除此之外，还存在一种菱形继承：

菱形继承实际上是多继承的一种特殊情况，但这就会导致一些问题。

例：

#include <iostream>
using namespace std;
class Person
{
public:string _name; // 姓名
};class Student : public Person
{
protected:int _num; //学号
};class Teacher : public Person
{
protected:int _id; // 职工编号
};class Assistant : public Student, public Teacher
{
protected:string _majorCourse; // 主修课程
};int main()
{//这样会有二义性无法明确知道访问的是哪一个Assistant a;a._name = "peter";//需要显式指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决。//a.Student::_name = "xxx";//a.Teacher::_name = "yyy";return 0;
}

运行结果：

由于Assistant既是Teacher的派生类，又是Student的派生类，而Teacher和Student又同时是Person的派生类，这样一个菱形继承的关系就会产生二义性。

而从运行结果可以看到，当我们定义一个Assistant类的对象a后，由于Assistant的基类Teacher和Student中都有成员_name，所以导致了数据的冗余，而且由于当我们访问a的_name时不清楚它到底继承的是谁的_name，从而导致对_name的访问不明确，进而使编译器报错。

虽然访问不明确的问题可以通过显式指定访问来解决，但是数据冗余的问题仍无法解决。

从上图可以看出菱形继承有数据冗余和二义性的问题，即在Assistant的对象中Person成员会有两份。

9 菱形虚拟继承

9.1 virtual

为了解决菱形继承的二义性和数据冗余的问题，C++又引入了虚拟继承的概念，而要使用虚拟继承，就要用到关键字virtual。

我们先来直观地感受以下虚拟继承的使用方法：

#include <iostream>
using namespace std;
class Person
{
public:string _name;
};
//使用virtual修饰Assistant的直接基类Student和Teacher
class Student : virtual public Person
{
protected:int _num;
};
class Teacher : virtual public Person
{
protected:int _id;
};
class Assistant : public Student, public Teacher
{
protected:string _majorCourse;
};int main()
{Assistant a;a._name = "peter";cout << a._name << endl;return 0;
}

运行结果：

9.2 虚拟继承解决数据冗余和二义性的原理

为了研究虚拟继承原理，下面我们给出一个简化菱形继承的继承体系，再借助内存窗口观察对象成员的模型。

#include <iostream>
#include <string>
using namespace std;
class A
{
public:int _a;
};
class B : public A
//class B : virtual public A  //虚拟继承
{
public:int _b;
};
class C : public A
//class C : virtual public A  //虚拟继承
{
public:int _c;
};
class D : public B, public C
{
public:int _d;
};
int main()
{D d;d.B::_a = 1;d.C::_a = 2;d._b = 3;d._c = 4;d._d = 5;return 0;
}

使用虚拟继承前的调试结果：

从调试结果可以看到，此时B和C中各有一个A，存在数据冗余。

使用虚拟继承后的调试结果：

从调试结果可以看到，使用虚拟继承后，不仅d的内存空间变大了，除此之外还出现了一些像乱码的数据，也就是00337bdc和00337be4。

实际上，这两段乱码是一个地址，我们可以再开一个内存窗口来观察其指向的数据：

可以看到，00337bdc和00337be4的当前位置是0，它们的下一个值表示的十六进制数字14和C也就是20和12。这代表着什么呢？

实际上，00337bdc和00337be4分别是B和C中的一个指针，这两个指针叫做虚基表指针，它们分别指向了两张表，这两个表叫做虚基表，而20和12就是存放在虚基表中的偏移量，而在上面的例子中，我们分别把存放指针的地址006ffac0和006ffac8加上偏移量20和12后可以发现都等于006ffad4，这正是A的地址。

而从刚才使用虚拟继承后的调试结果可以发现，对象d中的_a被放到了结构组成的最下面，此时这个_a同时属于B和C。那么B和C要去找到这个公共的_a就需要通过这个偏移量来查找，而这个偏移量就是指针存放的地址相对于_a的距离。

我们可以通过下图来更好地理解它们之间的关系：

那么有人可能会问，为什么偏移量不直接存在指针指向的位置，而是指针指向位置的下一个位置呢？

实际上，这个地方空下来是为多态做准备，这里我们暂且不表，我们现在需要知道的是，这里不只是用来存偏移量，还会用来存别的数据。

那么又有人会问，为了达到这个目的反而让d的内存空间变大了，会不会有些不划算呢？

实际上，这只是因为我们的例子中_d本来所占用的内存较小，B和C也只同时继承了一个成员_a，此时数据冗余的影响并不大，而当继承的成员有很多时，通过存放一个指向虚基表的指针再通过偏移量来得到公有的对象就可以极大地节省空间了。

例：下面代码输出的结果是什么？

//代码输出的结果是什么？
#include<iostream>
using namespace std;
class A 
{
public:A(const char* s) { cout << s << endl; }~A() {}
};
class B :virtual public A
{
public:B(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};  
class C :virtual public A
{
public:C(const char* s1, const char* s2) :A(s1) { cout << s2 << endl; }
};
class D :public B, public C
{
public:D(const char* s1, const char* s2, const char* s3, const char* s4) :B(s1, s2), C(s1, s3), A(s1){cout << s4 << endl;}
};
int main() 
{D* p = new D("class A", "class B", "class C", "class D");delete p;return 0;
}

运行结果：

之前我们说过，初始化列表初始化的顺序跟出现的顺序无关，而跟声明的顺序有关，也就是说谁先声明谁先初始化，而对于继承也有类似的特性，谁先被继承谁就先声明。

在上面的代码中，由class D :public B, public C可知：D先继承了B再继承了C，而B和C都继承了A，也就是说A是最先被继承的，其次是B最后是C。

所以从运行结果可以看到，先调用了A的构造函数，其次是B，然后是C，最后才是D。

如果我们将D的继承顺序改为先继承C再继承B，运行结果将为：

以上，便是跟继承有关的所有内容。