C++ 多态深度解析：从虚函数表到底层机制

在 main 函数中创建了一个 B 类型的对象，并将它的指针赋值给了 B* 类型的指针 p。然后使用 p 调用 test 函数，这实际上调用的是 B 中继承自 A 部分的 test 函数。但在调用过程中，传递给 test 函数的 this 指针是 B 类型的指针。

根据多态的对象决定论，访问的 func 函数是派生类 B 重写后的版本。虽然派生类的 func 没有声明 virtual，但由于基类已是虚函数，它依然构成了重写。由于默认参数是在编译期绑定的，调用 test() 时使用的是基类 A 中定义的默认值 val=1。

因此运行结果是 B->1。

2.3 析构函数的重写

在继承体系中，基类指针可以指向派生类对象。这时候传统的析构方式就会出问题。

#include <iostream>
using namespace std;

class A {
public:
    virtual ~A() {
        cout << "~A()" << endl;
    }
};

class B : public A {
public:
    ~B() {
        cout << "~B()" << endl;
    }
protected:
    int* _p = new int[10];
};

int main() {
    A* p1 = new A;
    A* p2 = new B;
    delete p1;
    delete p2; // 如果 A 的析构不是虚函数，这里只会调用 A 的析构，导致内存泄漏
    return 0;
}

我们希望将指针指向的对象全部析构掉。但如果指针是 A 基类类型，且析构函数非虚，删除时只会调用基类析构函数，派生类部分不会被有效释放，造成资源泄漏。

解决方案是将析构函数置为虚函数。这样派生类和基类中的析构函数就构成了重写。再次 delete 基类指针时，会先调用派生类析构函数，再调用基类析构函数，确保空间释放干净。

2.4 override 和 final 关键字

在继承体系中，重写的判断条件比较苛刻。只要有一点不一样就无法构成重写，有时甚至不会报错，这很危险。为此引入了 override 和 final 关键字。

• override：用来检查是否构成重写，如果不匹配则编译报错。
• final：声明这个函数不能被重写。

class A {
public:
    virtual ~A() {}
    virtual void func1() {}
    virtual void func2() final {}
};

class B : public A {
public:
    virtual ~B() {}
    virtual void func1(size_t i) override {} // 报错：参数不匹配
    virtual void func2() {}                 // 报错：基类已声明 final
};

如图所示，代码会直接编译报错，从而避免了潜在的错误逻辑。

2.5 纯虚函数和抽象类

在虚函数后面写上 =0，则该函数为纯虚函数。纯虚函数不需要定义实现（虽然语法上可以实现），因为它强制要求派生类重写。 包含纯虚函数的类叫做抽象类，抽象类不能实例化对象。如果派生类继承后不重写纯虚函数，那么派生类也是抽象类。这在某种程度上强制了派生类重写虚函数。

2.6 协变

派生类重写基类虚函数时，返回值类型可以与基类不同。即基类虚函数返回基类对象的指针或引用，派生类虚函数返回派生类对象的指针或引用时，称为协变。

class Person {
public:
    virtual A* BuyTicket() {
        cout << "买票 - 全价" << endl;
        return nullptr;
    }
};

class Student : public Person {
public:
    virtual B* BuyTicket() {
        cout << "买票 - 打折" << endl;
        return nullptr;
    }
};

三、多态的底层实现

3.1 虚函数表简介

在上述情景中，类的内存中都存在一个 _vfptr 指针，这就是虚函数表指针，也叫虚表指针，它指向了类中的虚函数表。

3.2 多态的实现

满足多态条件后，要调用哪个函数并不是在编译时就确定的，而是需要在运行时到指向虚函数地址的虚函数表内确定虚函数的地址，然后再调用。这样就实现了指针或引用指向基类就调用基类的虚函数，指向派生类就调用派生类对应的虚函数。

class Person {
public:
    virtual A* BuyTicket() {
        cout << "买票 - 全价" << endl;
        return nullptr;
    }
};

class Student : public Person {
public:
    virtual B* BuyTicket() {
        cout << "买票 - 打折" << endl;
        return nullptr;
    }
};

void Func(Person* ptr) {
    ptr->BuyTicket();
}

int main() {
    Person ps;
    Student st;
    Func(&ps);
    Func(&st);
    return 0;
}

3.3 静态绑定和动态绑定

• 静态绑定：对不满足多态条件（指针或者引用 + 调用虚函数）的函数调用，是在编译时绑定，也就是编译时确定调用函数的地址。函数重载和函数模版都是静态绑定。
• 动态绑定：满足多态条件的函数调用是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数的地址，也就做动态绑定。

3.4 虚函数表详解

3.4.1 虚函数表的相关规则

1. 同类型的对象的虚函数表是同一个（不直接将虚函数的函数指针存在对象中，而是存在一个指针数组中就是为了节省空间）。
2. 派生类先将基类的虚函数表继承下来（但是是拷贝，指向的不是同一块空间）。
3. 构成了重写的函数会将原来的函数指针覆盖掉。
4. 派生类的虚函数表中包含：(1) 基类的虚函数地址，(2) 派生类重写的虚函数地址完成覆盖，(3) 派生类自己的虚函数地址三个部分。
5. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了一个 0x00000000 标记。（这个 C++ 并没有进行规定，各个编译器自行定义的，VS 系列编译器会在后面放个 0x00000000 标记，g++ 系列通常不会放）

还有需要注意的是： 当虚函数继承了多个基类时，新增的虚函数，统一放在第一个基类的虚函数表中。

3.4.2 虚函数存放的位置问题（这里有坑）

大部分人看到这个问题可能想到的是：虚函数明显是存在虚函数里的。 实则不然，虚函数也是函数，是存在代码段中的，只不过是也在虚函数表中存了一份指针。

3.4.3 虚函数表存放的位置

这个 C++ 委员会并未明确规定存放位置，但是可以通过程序验证。

#include <cstdio>

class Base {
public:
    virtual void func1() { printf("Base::func1\n"); }
    virtual void func2() { printf("Base::func2\n"); }
    void func5() { printf("Base::func5\n"); }
protected:
    int a = 1;
};

class Derive : public Base {
public:
    virtual void func1() { printf("Derive::func1\n"); }
    virtual void func3() { printf("Derive::func3\n"); }
    void func4() { printf("Derive::func4\n"); }
protected:
    int b = 2;
};

int main() {
    int i = 0;
    static int j = 1;
    int* p1 = new int;
    const char* p2 = "xxxxxxxx";
    
    printf("栈:%p\n", &i);
    printf("静态区:%p\n", &j);
    printf("堆:%p\n", p1);
    printf("常量区:%p\n", p2);
    
    Base b;
    Derive d;
    Base* p3 = &b;
    Derive* p4 = &d;
    
    printf("Person 虚表地址:%p\n", *(int*)p3);
    printf("Student 虚表地址:%p\n", *(int*)p4);
    printf("虚函数地址:%p\n", (void*)&Base::func1);
    printf("普通函数地址:%p\n", (void*)&Base::func5);
    
    delete p1;
    return 0;
}

验证得：虚函数表大概是在常量区（只读数据段）。