C++ 多态原理与虚函数表详解

被 static 修饰的变量 a 存放在静态区，局部变量 b 存储在栈区，指针 p1 指向在堆上开辟出的对象，常量字符串的指针存放在代码段。

虚表中，因为 a1 是一个类对象，它的地址存放了虚表指针和内置类型_a 两部分。虚表指针是一个 void 类型的指针，占 4 个字节，把它强制转换成 int* 类型的指针，再解引用，得到的是虚表的指针。

虚函数地址就是固定用法，要把是哪个类的虚函数标注出来，然后用取地址符号。

从上图我们可以观察到，虚函数和普通函数存放位置接近，代码段和虚表存放位置接近，而虚表和虚函数相对于静态区、栈区以及堆区来说还是离代码段更近。也就是说，虚函数和普通函数以及虚表存放在代码段。

2、多态的原理

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

void func(A& ra) { ra.D(); }

void test() {
    A a, b;
    func(a);
    func(b);
}

当 ra 为 A 对象时，函数调用时在 A 的虚表中找到 func，当 ra 为 B 对象时，函数调用时在 B 的虚表中找到 func，然后调用，这样就实现出了不同对象去完成同一行为时，展现出不同的形态。

我们要达到多态，有两个条件：一个是虚函数覆盖，一个是对象的指针或引用调用虚函数。

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

void func(A* p) { p->D(); }

void test() {
    A a;
    func(&a);
    a.D();
}

对于多态调用： p 中存的是 A 对象的指针，将 p 移动到 eax 中： mov eax,dword ptr [p]

[eax]就是取 eax 值指向的内容，这里相当于把对象头 4 个字节 (虚表指针) 移动到了 edx： mov edx,dword ptr [eax]

[edx]就是取 edx 值指向的内容，这里相当于把虚表中的头 4 字节存的虚函数指针移动到了 eax： mov eax,dword ptr [edx]

call eax 中存虚函数的指针，这里可以看出满足多态的调用，不是在编译时确定的，是运行起来以后到对象的中去查找的。

对于普通调用： 因为不满足多态调用所以是普通函数调用，直接 call 地址。

3、动态绑定和静态绑定

静态绑定又称为前期绑定 (早绑定)，在程序编译期间确定了程序的行为，也称为静态多态，比如：函数重载。

动态绑定又称后期绑定 (晚绑定)，是在程序运行期间，根据具体拿到的类型确定程序的具体行为，调用具体的函数，也称为动态多态。

五、单继承和多继承关系的虚函数表

1、单继承中的虚函数表

class A {
public:
    virtual void func1() { cout << "A::func1" << endl; }
    virtual void func2() { cout << "A::func2" << endl; }
private:
    int _a;
};
class B : public A {
public:
    virtual void func1() { cout << "B::func1" << endl; }
    virtual void func3() { cout << "B::func3" << endl; }
    virtual void func4() { cout << "B::func4" << endl; }
private:
    int _b;
};

int main() {
    A a, b;
    return 0;
}

图中的监视窗口中我们发现看不见 func3 和 func4，这里是编译器的监视窗口故意隐藏了这两个函数。

那我们如何查看整个 b 的虚表呢？

typedef void (*VFPTR)();

void PrintVTable(VFPTR vTable[]) {
    // 依次取虚表中的虚函数指针打印并调用。调用就可以看出存的是哪个函数
    cout << "虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i) {
        printf("第%d个虚函数地址 :0X%x,->", i, vTable[i]);
        VFPTR f = vTable[i];
        f();
    }
    cout << endl;
}

int main() {
    A a, b;
    VFPTR* vTablea = (VFPTR*)(*(int*)&a);
    PrintVTable(vTablea);
    VFPTR* vTableb = (VFPTR*)(*(int*)&b);
    PrintVTable(vTableb);
    return 0;
}

PrintVTable 函数： 核心点就是这个函数指针 VFPTR，这是一个函数指针，指向的类型是 void*，参数为（），也就是无参，也就是说这个指针可以指向任意一个返回类型为 void* 并且无参的函数。

PrintVTable 函数的参数也可以写成 VFPTR* vTable，虚表的地址就是指针 vTable，后加 [] 就是对表中的指针进行访问，打印出它们的指针，并且将这些指针指向的函数调用表示出来，让我们可以看到这个地址对应的是哪个函数。

main 函数： 取出 a、b 对象的头 4bytes，就是虚表的指针。虚函数表本质是一个存虚函数指针的指针数组，这个数组最后面放了一个 nullptr。

1. 先取 a 的地址，强转成一个 int* 的指针。
2. 再解引用取值，就取到了 a 对象头 4bytes 的值，这个值就是指向虚表的指针。
3. 再强转成 VFPTR*，因为虚表就是一个存 VFPTR 类型 (虚函数指针类型) 的数组。
4. 虚表指针传递给 PrintVTable 进行打印虚表。
5. 需要说明的是这个打印虚表的代码经常会崩溃，因为编译器有时对虚表的处理不干净，虚表最后面没有放 nullptr，导致越界，这是编译器的问题，我们只需要重新生成解决方案就行。

2、多继承中的虚函数表

class A1 {
public:
    virtual void func1() { cout << "A1::func1" << endl; }
    virtual void func2() { cout << "A1::func2" << endl; }
private:
    int a1;
};
class A2 {
public:
    virtual void func1() { cout << "A2::func1" << endl; }
    virtual void func2() { cout << "A2::func2" << endl; }
private:
    int a2;
};
class B : public A1, public A2 {
public:
    virtual void func1() { cout << "B::func1" << endl; }
    virtual void func3() { cout << "B::func3" << endl; }
private:
    int b;
};

typedef void (*VFPTR)();

void PrintVTable(VFPTR vTable[]) {
    cout << "虚表地址>" << vTable << endl;
    for (int i = 0; vTable[i] != nullptr; ++i) {
        printf("第%d个虚函数地址 :0X%x,->", i, vTable[i]);
        VFPTR f = vTable[i];
        f();
    }
    cout << endl;
}

int main() {
    B b;
    VFPTR* vTablea1 = (VFPTR*)(*(int*)&b);
    PrintVTable(vTablea1);
    VFPTR* vTablea2 = (VFPTR*)(*(int*)((char*)&b + sizeof(A1)));
    PrintVTable(vTablea2);
    return 0;
}

多继承派生类的未重写的虚函数放在第一个继承基类部分的虚函数表中，也就是 func3 函数，第一个继承基类就是最左边继承的这个基类。

六、多态中的一些小 tips

1. 内联函数可以是虚函数，但是如果被 inline 修饰的函数是虚函数，那么 inline 特性将会消失，被修饰的函数相当于没被修饰。
2. 静态成员不可以是虚函数，因为静态成员没有 this 指针，使用类型::成员函数的调用方式无法访问虚函数表，所以静态成员函数无法放进虚函数表。
3. 构造函数不能是虚函数，因为对象中的虚函数表指针是在构造函数初始化列表阶段才初始化的。
4. 最好把基类的析构函数定义为虚函数，因为如果基类的析构函数不是虚函数，那么只会调用基类的析构函数，而不会调用派生类的析构函数，这会导致派生类部分的对象没有被正确析构，可能会引发资源泄露。
5. 对象在访问虚函数与普通函数速度的对比，如果是普通对象访问，两者一样快，如果是多态对象访问（指针对象或者引用对象），则调用普通函数更快，因为虚函数构成多态，运行时需要到虚函数表中去查找。
6. 虚函数表在编译阶段就生成了。