C++ 多态对象模型/虚继承对象模型

静态博客
https://sustyuxiao.github.io/2018/03/09/2018-03-09/

c++为了实现多态引入虚表的概念。为了解决多继承问题引入虚基表的概念。
本文通过介绍对象在内存中的分布简析 c++的多态/虚继承 对象模型

基础概念

• 重写（覆盖）：
  前提条件：父类函数为虚函数
  子类函数与父类函数完全相同时（返回值、函数名、参数），称作重写（覆盖）了父类函数

• 协变：
  前提条件：构成重写
  父类函数（虚函数）返回值为父类的引用/指针，子类函数的返回值为子类的引用/指针

• 重定义（隐藏）
  前提条件：不构成重写
  函数名相同

• 动态联编
  指针/引用 + 虚函数
  （将在虚表中寻找函数的函数地址）

• 多态
  虚函数的重写 + 动态联编
  多态的目的是使用 父类的指针/引用，指向父类时访问父类方法，指向子类时访问子类方法。

• 虚函数表(虚表），解决多态问题
  当成员函数被声明为虚函数时，程序运行时不直接调用代码段，而是生成「虚函数表」，程序通过虚函数表找到需要执行的代码。

虚函数表对象模型 - 多态的实现

通过虚函数表的对象模型，结合 父类的指针/引用，可以实现 指向父类时访问父类方法，指向子类时访问子类方法。

对如下代码，A 是父类（基类），B 是子类（派生类）

//......
class A
{
public:
    virtual void fuc()
    {
        cout << "A::fuc()" <<endl;
    }

    virtual void fucA()
    {
        cout << "A::fucA()" <<endl;
    }
private:
    int a;  
}

class B: public A
{
public:
    virtual void fuc()
    {
        cout << "B::fuc()" <<endl;
    }

    virtual void fucB()
    {
        cout << "B::fucB()" <<endl;
    }
private:
    int b;  
}

若定义对象 b （B b;）, 分析b的对象模型，b会有虚函数表(下图右半部分）

通过取得对象 b 的地址，我们可以将虚函数表打印出来
虚表的地址在对象模型头部 4 字节位置（32位）（上图左半部分）

使用
int* vTable = (int*)( *( (int*)(&b) ) );
取得虚表地址（取得对象地址后强转为int*，再解引用，即可拿到对象模型头部 4 字节，再强转为int*即可赋值给vTable）

上述代码可简化为
int* vTable = *(int **)(&b);

结合对象模型的图示，易给出以下代码打印出虚表

//....
typedef void(*VirtualFuc)();
void PrintVirtualTable(int *vTable)
{
    printf("the VirtualFuc address is %p\n\n", vTable);
    for (int i=0; vTable[i] != 0; i++)
    {
        printf("%d the fuc address is %p ", i, vTable[i]);
        VirtualFuc f = VirtualFuc(vTable[i]);
        f();
    }
    printf("\n");
}

int main()
{
    B b;
    int* vTable = *(int **)(&b);
}

运行结果

父类有虚表时，不再创建虚表

此外，虚表中的地址实际不是函数代码真实地址(代码段）
程序在运行时 汇编会call <address>，在call的过程中，会通过call虚拟地址 来jump到真实地址（代码段中）

虚函数表在菱形继承

一个会出现较为复杂的虚函数表的情形是菱形继承

代码如下

class A
{
    int _a;
public:
    virtual void fuc1()
    {
        cout << "A::fuc1()" << endl;
    }

    virtual void fucA()
    {
        cout << "A::fucA()" << endl;
    }
};

class B : public A
{
//同 class A
};

class C : public A
{
//同 class A
};

class D : public B, public C
{
//同 class A
};

int main(void)
{
//    A a;
//    B b;
//    C c;
    D d;
    int n = d._a;//编译报错

   return 0;
}

此时的 d 的虚函数表为

菱形会出现一个问题：数据冗余 和 二义性

• 数据冗余
  c只需要一个weight，实际上其拥有两个重复的值

• 二义性
  在对象c调用weight时，如果单继承很简单，但在多继承中，该对象不知道应调用A，B哪一个类下的weight

虚继承，虚基表解决二义性、容易解决问题

声明虚继承后，虚表中不会出现重复项（数据冗余），同时使用一张表（虚基表）指明继承关系。

在VS环境下，对象虚函数表指针的下一个字中，存储的不是对象的成员变量，虚基表
虚基类表仅是Microsoft编译器的解决办法。在其他编译器中，一般采用在虚函数表中放置虚基类的偏移量的方式。

将上节代码的每个形如class B : public A的代码片段改为class B : virtual public A，即声明了虚继承。

main函数代码如下时

int main(void)
{
    A a;
    B b;
    C c;
    D d;

    a._a = 1;
    b._b = 2;
    c._c = 3;
    d._d = 4;
   return 0;
}

该对象模型在内存中的分布如图（vs）

可以在 vs 调试模式下查看内存中的值进行验证。

值得强调的的是：（虚继承带来了较大开销，会影响程序性能。）

附录：典例1

求以下代码注释分别运行的结果

//......
class A
{
public:
    virtual void f1()
    {
        cout << "f1()" <<endl;
    }

    void f2()
    {
        cout << "f2()" <<endl;
    }
}

int main()
{
    A* p = NULL;
    //p -> f1();//代码段1
    //p -> f2();//代码段2

    return 0;
}

代码段1会崩溃，虚函数下动态联编需要解引用，空指针解引用会崩溃。
代码段2不会崩溃，静态联编函数地址不在对象内，没有对指针解引用。