菱形继承的内部实现方式

问题：

    由于将下图定义为多继承类型时，子类会发生二义性与数据冗余，而用菱形继承时会解决这些问题，菱形继承发生了些什么？又是怎么实现的？

本次试着说明菱形继承的机理（实现方法）

按照上图建立多继承，编写代码：

class Base
{
public:
 virtual void func1()
 {
  cout << "Base::func1()" << endl;
 }

protected:
 int _a;
};

class Base1: public Base
{
public:
 virtual void func1()
 {
  cout << "Base1::func1()" << endl;
 }

 virtual void func3()
 {
  cout << "Base1::func3()" << endl;
 }


protected:
 int _b;
};

class Base2 : public Base
{
public:
 virtual void func2()
 {
  cout << "Base2::func2()" << endl;
 }
 virtual void func4()
 {
  cout << "Base2::func4()" << endl;
 }

protected:
 int _c;
};

class Derive : public Base1, public Base2
{
public:
 virtual void func1() 
 {
  cout << "Derive::func1()" << endl;
 }

 virtual void func2()
 {
  cout << "Derive::func2()" << endl;
 }

 virtual void func3()
 {
  cout << "Derive::func3()" << endl;
 }

 virtual void func4()
 {
  cout << "Derive::func4()" << endl;
 }
 virtual void func5()
 {
  cout << "Derive::func5()" << endl;
 }
protected:
 int _d;
};


typedef void(*FUNC)();

void pfun(int *vTable)
{
 for (int i = 0; vTable[i] != 0; ++i)
 {
  printf("第 %d 个虚函数-> %p\n", i, vTable[i]);
  FUNC f = (FUNC)vTable[i];
  f();
 }
}

void test6()
{
 Base a;
 Base1 b;
 Base2 c;
 Derive d;

 int sb = sizeof(a);
 int sb1 = sizeof(b);
 int sb2 = sizeof(c);
 int sd = sizeof(d);

 pfun((int*)*(int*)&d);
 printf("\n");
 pfun((int*)(*(int*)&d + 20));
 printf("\n");
 }

多继承运行结果：（虚表指针地址可由运行时“d”的_vfptr可得）

可看出：Base1、Base2中都有func1()；Base1的_vfptr与Base2的_vfptr地址不同，指向的内容也不同Base1的虚表与Base2的虚表都含有Base的func()，这种继承存在二义性与冗余性。

在定义 Base1,Base2时，在public Base前加 virtual，将此继承变为菱形继承。

菱形继承运行结果：

菱形继承解决了二义性与冗余性问题。

多继承计算大小得：

菱形继承计算大小得：

将多继承与菱形继承结合起来分析：

    由上图可以看出，在菱形继承与多继承时，超类大小一样，但从父类开始大小发生区别，父类多了8个字节，子类多了18个字节。这其中做了些什么？
    由于要想消除二义性与冗余性，就得将Base1、Base2中的Base部分变为一份，那只能将Base1、Base2中Base部分变为指针指向Base部分。那具体又是怎么实现的？     

打开“d”的内部

发现多了一个Base,再将Base1、Base2、Base都打开。

看到：Base1的_vfptr，Base2的_vfptr，Base的_vfptr地址相同，指向的内容也一样是Base的虚表。

通过上图及调用内存窗口，对相应地址进行分析得到下图

    由上图分析可以得到：相比多继承，菱形继承中在子类中会多8个字节（两个指针），是因为在子类继承的父类部分会各增加一个指针，作用是指向一个地址，地址中保存着父类增加的指针的地址与超类的地址偏移值，通过地址与偏移值相加，找到超类成员部分，并且两个父类指针都指向的是同一块空间。

    这样子类中父类与超类公共部分都是同一块存储空间，就解决了二义性与数据冗余问题。