C++ 多态机制详解：虚函数与动态绑定

析构函数的重写

基类的析构函数为虚函数，此时派生类析构函数只要定义，无论是否加 virtual 关键字，都与基类的析构函数构成重写，虽然基类与派生类析构函数名字不同看起来不符合重写的规则，实际上编译器对析构函数的名称做了特殊处理，编译后析构函数的名称统一处理成 destructor，所以基类的析构函数加了 virtual 修饰，派生类的析构函数就构成重写。

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

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

int main() {
    A* p1 = new A;
    A* p2 = new B;
    delete p1;
    delete p2;
    return 0;
}

如果 ~A() 不加 virtual，那么 delete p2 时只调用的 A 的析构函数，没有调用 B 的析构函数，就会导致内存泄漏问题，因为 ~B() 中在释放资源。

只有派生类 Student 的析构函数重写了 Person 的析构函数，下面的 delete 对象调用析构函数，才能构成多态，才能保证 p1 和 p2 指向的对象正确的调用析构函数。

override 和 final 关键字

1. override 关键字 作用：明确标记一个函数是重写基类的虚函数，编译器会检查以下条件：
   • 基类中是否存在同名虚函数。
   • 基类和派生类的函数签名（参数、常量性、引用限定符）是否严格一致。
   • 返回类型是否符合协变规则（如果适用）。
2. final 关键字 作用：final 有两种用法：
   • 修饰虚函数：禁止派生类重写该虚函数。
   • 修饰类：禁止该类被继承。

纯虚函数和抽象类

在虚函数的后面写上=0，则这个函数为纯虚函数，纯虚函数不需要定义实现 (实现没啥意义因为要被派生类重写，但是语法上可以实现)，只要声明即可。包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象，如果派生类继承后不重写纯虚函数，那么派生类也是抽象类。纯虚函数某种程度上强制了派生类重写虚函数，因为不重写实例化不出对象。

• 纯虚函数：在基类中声明为 virtual，并且没有实现的函数，形式为 virtual void func() = 0;。
• 抽象类：包含纯虚函数的类称为抽象类，不能实例化对象，只能作为基类被派生。
  • Shape 是一个抽象类，Circle 是派生类，重写了 draw() 函数。

多态的使用：

Shape* shape = new Circle();
shape->draw(); // 输出：Drawing Circle

示例：

class Shape {
public:
    virtual void draw() = 0; // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing Circle" << endl;
    }
};

多态的原理

多态是如何实现的

在 C++ 中，多态主要通过虚函数（virtual functions）和继承机制来实现。以下是多态实现的详细过程和原理：

1. 虚函数表（vtable）

• 概念：每个包含虚函数的类都会有一个虚函数表（vtable），它是一个存储虚函数地址的数组。当创建一个类的对象时，对象会包含一个指向其类的虚函数表的指针（vptr）。
• 作用：vtable 是实现多态的关键。当通过基类指针或引用调用虚函数时，程序会通过 vptr 找到对应的 vtable，然后通过 vtable 找到实际的虚函数地址。

虚函数表知识要点

1. 基类对象的虚函数表中存放基类所有虚函数的地址。同类型的对象共用同一张虚表，不同类型的对象各自有独立的虚表，所以基类和派生类有各自独立的虚表。
2. 派生类由两部分构成，继承下来的基类和自己的成员，一般情况下，继承下来的基类中有虚函数表指针，自己就不会再生成虚函数表指针。但是要注意这里继承下来的基类部分虚函数表指针和基类对象的虚函数表指针不是同一个，就像基类对象的成员和派生对象中的基类对象成员也独立的。
3. 派生类中重写的基类的虚函数，派生类的虚函数表中对应的虚函数就会被覆盖成派生类重写的虚函数地址。
4. 派生类的虚函数表中包含，(1) 基类的虚函数地址，(2) 派生类重写的虚函数地址完成覆盖，派生类自己的虚函数地址三个部分。
5. 虚函数表本质是一个存虚函数指针的指针数组，一般情况这个数组最后面放了 0x00000000 标记。（此条取决于编译器）
6. 虚函数存储的位置（vs 下为常量区） 可以自行验证：

class Base {
public:
    virtual void func1() {}
protected:
    int a = 1;
};

class Derive : public Base {
public:
    virtual void func1() {}
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;
    Base* p3 = &b;
    printf("虚表地址:%p\n", *(int*)p3);
    return 0;
}

//通过比较虚表地址，找到其最近的内存片段来确定

2. 虚函数的声明

• Base 类的 show() 函数被声明为虚函数，Derived 类重写了这个虚函数。

在类中使用 virtual 关键字声明函数为虚函数。 Base 为基类，Derived 为继承类。

class Base {
public:
    virtual void show() {
        cout << "Base show()" << endl;
    }
};

class Derived : public Base {
public:
    void show() override {
        // override 表示重写基类的虚函数
        cout << "Derived show()" << endl;
    }
};

3. 多态的实现过程

• 当创建 Derived 类的对象 d 时，对象中会包含一个 vptr，指向 Derived 类的 vtable。
• Derived 类的 vtable 中存储了 Derived 类重写的虚函数 show() 的地址。
• ptr 是一个指向 Base 类的指针，但它指向的是 Derived 类的对象。
• 当调用 ptr->show() 时，程序会通过 ptr 找到对象的 vptr，然后通过 vptr 找到 Derived 类的 vtable，最终调用 Derived 类的 show() 函数。
• 这就是多态的运行时绑定（动态绑定）过程。

通过基类指针或引用调用虚函数：

Base* ptr = &d;
ptr->show();

创建对象：

Derived d;

动态绑定与静态绑定

• 对不满足多态条件 (指针或者引用 + 调用虚函数) 的函数调用是在编译时绑定，也就是编译时确定调用函数的地址，叫做静态绑定。
• 满足多态条件的函数调用是在运行时绑定，也就是在运行时到指向对象的虚函数表中找到调用函数的地址，也就做动态绑定。