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

发表于 | 分类于 |  PV

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

基础概念

多态的引入使得代码的构建更加灵活，使的代码更简洁、可维护性更强
具体来讲，多态把不同的子类对象都当作父类来看，可以屏蔽不同子类对象之间的差异，写出通用的代码，做出通用的编程，以适应需求的不断变化。

从代码的角度看多态

  • 应用于形参，可以接收更多类型的数据。
  • 应用于返回值类型，可以返回更多类型的数据。

介绍多态前，首先明确以下概念

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

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

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

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

  • 多态

    • 动态多态（即本文所述多态）
      • 虚函数的重写 + 动态联编
      • 使用 父类的指针/引用（指向父类时访问父类方法，指向子类时访问子类方法）
    • 静态多态（函数重载）
      • 函数同名不同參
      • （依据参数在编译时生成不同的函数签名，解决二义性）

  • 虚函数表(虚表），解决多态问题

多态及其对象模型

示例

1
2
3
4
5
6
7
8
9
10
11
12
int main(void)  
{  
    A a;  
    B b;  
    A *p = &a;  
    p->foo();  
    p->fun();  
    p = &b;  
    p->foo();  
    p->fun();  
    return 0;  
}

多态对象模型

上述效果是通过c++的多态处理机制完成的

具体实现，则是通过动态联编机制，在程序运行时决定应调用的函数代码，具体则是通过维护「虚函数表」实现

当成员函数被声明为虚函数并构成重写、使用指针/引用以满足多态构成条件时，程序运行时不直接调用代码段（静态联编），而是生成「虚函数表」，程序通过虚函数表找到需要执行的代码。
通过虚函数表的对象模型，结合 父类的指针/引用，可以实现 指向父类时访问父类方法，指向子类时访问子类方法。

对如下代码，A 是父类（基类），B 是子类（派生类）
通过剖析以下代码中类的内存分布，来理解多态的对象模型

多态对象模型的内存分布

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//......
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);

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//....
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到真实地址（代码段中）

虚函数表在菱形继承

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


代码如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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函数代码如下时

1
2
3
4
5
6
7
8
9
10
11
12
13
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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
//......
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不会崩溃，静态联编函数地址不在对象内，没有对指针解引用。