多态（Ｃ＋＋）（３）

带虚函数的虚拟继承

（1）概念：

在基类中存在虚函数，同时，派生类采用虚拟共有继承的方式，这种方式成为带虚函数共有继承。

（２）内存：

带虚函数的虚拟继承，在内存中增加4+4个字节的内存空间。其中4个字节用来存放指向虚函数表的地址，另外4个字节用来存放指向偏移量表格的地址。

（1）猜想单继承对象模型：

（1）程序实现：

#include <iostream>
using namespace std;
class B
{
public:
    virtual void FunTest1()
    {
        cout<<"B::FunTest1()"<<endl;
    }

    virtual void FunTest2()
    {
        cout<<"B::FunTest2()"<<endl;
    }
    int _b;
};
class D:virtual public B
{
public:
    virtual void FunTest1()
    {
        cout<<"D::FunTest1()"<<endl;
    }

    virtual void FunTest2()
    {
        cout<<"D::FunTest2()"<<endl;
    }

    virtual void FunTest3()
    {
        cout<<"D::FunTest3()"<<endl;
    }

    int _d;
};

typedef void (*PVTF)();//类型声明

void PrintVTF(B& b, char* str)//打印虚函数表
{
    PVTF* pFun = (PVTF*)*(int*)&b;
    while(*pFun)
    {
        (*pFun)();
        pFun++;
    }
    cout<<endl;
}

int main()
{
    cout<<sizeof(D)<<endl;
    D d;
    PrintVTF(d, "");

    B* pb = &d;
    pb = (B*)((int*)pb - 3);
    PrintVTF(*pb, "");
    return 0;
}

（2）、分析与总结：

在该基类B中，有自身的虚函数FunTest1（）和FunTest2（）以及基类成员变量_b，D虚拟共有继承B，在派生类D中，对基类的虚函数FunTest1（）和FunTest2（）进行重写，同时创建自身的虚函数FunTest3（）和自身成员变量_d;
于是大胆猜想，派生类D的大小为基类大小+派生类自身成员变量大小+ 指向虚函数表的4个字节+ 指向偏移量列表的4个字节，故而该类中所占内存空间大小为（8+4+4+4）=20个字节，程序运行结果如下：

由程序运行结果可知，我们的猜想模型正确，相对于普通的公有继承，在含有虚函数的虚拟共有继承中，内存会增加8个字节，前4个用来存放指向虚函数表的地址，后4个用来存放指向偏移量表格的地址。

（2）猜想菱形继承对象模型：

（1）程序实现：

// 8
class B
{
public:
    virtual void FunTest1()
    {
        cout<<"B::FunTest1()"<<endl;
    }

    virtual void FunTest2()
    {
        cout<<"B::FunTest2()"<<endl;
    }

    int _b;
};

// 16
class C1:virtual public B
{
public:
    virtual void FunTest1()
    {
        cout<<"C1::FunTest1()"<<endl;
    }

    virtual void FunTest3()
    {
        cout<<"C1::FunTest3()"<<endl;
    }

    int _c1;
};

// 16
class C2:virtual public B
{
public:
    virtual void FunTest2()
    {
        cout<<"C2::FunTest2()"<<endl;
    }

    virtual void FunTest4()
    {
        cout<<"C2::FunTest4()"<<endl;
    }

    int _c2;
};

class D:public C1, public C2
{
public:
    virtual void FunTest1()
    {
        cout<<"D::FunTest1()"<<endl;
    }

    virtual void FunTest3()
    {
        cout<<"D::FunTest3()"<<endl;
    }

    virtual void FunTest4()
    {
        cout<<"D::FunTest4()"<<endl;
    }

    virtual void FunTest5()
    {
        cout<<"D::FunTest5()"<<endl;
    }

    int _d;
};

// 函数指针变量---函数指针类型
typedef void (*PVTF)();
void PrintVFT(B& b, char* str)
{
    cout<<str<<":"<<endl;
    PVTF* pFun = (PVTF*)*(int*)&b;
    while(*pFun)
    {
        (*pFun)();
        pFun++;
    }
    cout<<endl;
}

// 基类--->派生类
void PrintVFT(C1& b, char* str)
{
    cout<<str<<":"<<endl;
    PVTF* pFun = (PVTF*)*(int*)&b;
    while(*pFun)
    {
        (*pFun)();
        pFun++;
    }
    cout<<endl;
}

// 基类--->派生类
void PrintVFT(C2& b, char* str)
{
    cout<<str<<":"<<endl;
    PVTF* pFun = (PVTF*)*(int*)&b;
    while(*pFun)
    {
        (*pFun)();
        pFun++;
    }
    cout<<endl;
}

int main()
{
    cout<<sizeof(D)<<endl;
    D d;
    d._b = 0;
    d._c1 = 1;
    d._c2 = 2;
    d._d = 3;

    C1& c1 = d;
    PrintVFT(c1, "C1 VFT");

    C2& c2 = d;
    PrintVFT(c2, "C2 VFT");

    B& b = d;

    PrintVFT(b, "C1 VFT");

    return 0;
}

（2）分析与总结：

在该基类中有FunTest1()和FunTest2()两个虚拟函数，以及自身成员变量＿ｂ；Ｃ１共有虚拟继承Ｂ，同时，对其FunTest1()进行重写，并创建自身虚函数FunTest３()及成员变量ｃ１；同理，Ｃ２共有虚拟继承Ｂ，同时，对其FunTest２()进行重写，并创建自身虚函数FunTest４()及成员变量ｃ２；派生类Ｄ共有继承ｃ１和ｃ２，对FunTest１()、FunTest３()、FunTest４()进行重写，同时添加自身虚函数FunTest５()和自身成员变量＿ｄ；理论上：Ｄ的大小应该为Ｃ１所占内存空间的大小＋Ｃ２所占内存空间的大小＋自身成员变量的大小＝１６＋１６＋４＝３６；下面我们来看程序运行结果：

未完待续