C++ 多态深度解析：虚函数、重写与底层原理

3. 虚函数重写的其他关键问题

3.1 析构函数的虚化

在继承体系中，如果基类的析构函数不是虚函数，当通过基类指针删除派生类对象时，只会调用基类的析构函数，导致派生类特有的资源无法释放，引发内存泄漏。

因此，基类的析构函数应当声明为虚函数。编译器对析构函数名称有特殊处理，即使不加 virtual，只要派生类定义了同名析构函数，也会构成某种形式的重写，但为了安全起见，显式添加 virtual 是最佳实践。

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

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

int main() {
    A* p1 = new A;
    A* p2 = new B;

    delete p1; // 正常
    delete p2; // 若 A 析构非虚，~B() 不会被调用，造成泄漏
    return 0;
}

只有当基类析构函数是虚函数时，delete 操作才能正确触发派生类的析构逻辑。

4. override 和 final 关键字

C++11 引入了 override 和 final 来增强代码的安全性和意图表达。

• override：强制编译器检查派生类函数是否真正重写了基类的虚函数。如果函数签名不匹配（如拼写错误），编译会报错，避免静默失败。
• final：阻止派生类继续重写当前虚函数。

class Car {
public:
    virtual void Drive() {}
};

class Benz : public Car {
public:
    // 如果 Drive 拼写错误，这里会编译报错
    virtual void Drive() override {
        std::cout << "Benz 舒适" << std::endl;
    }
};

若基类希望禁止后续重写：

class Car {
public:
    virtual void Drive() final {} // 禁止子类再重写
};

class Benz : public Car {
public:
    // 此处会报错，因为基类已标记 final
    virtual void Drive() {
        std::cout << "Benz 舒适" << std::endl;
    }
};

5. 重载、重写与隐藏的区别

理解这三者的区别对于掌握多态至关重要：

此外，父子类中同名的成员变量也会发生隐藏。

6. 纯虚函数与抽象类

将虚函数声明为 = 0，即成为纯虚函数。包含纯虚函数的类称为抽象类，它不能被实例化。

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

class Benz : public Car {
public:
    void Drive() override { // 必须重写，否则 Benz 也是抽象类
        std::cout << "Benz 舒适" << std::endl;
    }
};

int main() {
    // Car car; // 编译报错：无法实例化抽象类
    Car* pBenz = new Benz;
    pBenz->Drive();
    delete pBenz;
    return 0;
}

纯虚函数强制派生类提供具体实现，常用于定义接口规范。

7. 多态的底层原理

多态是如何实现的？满足条件后，底层不再依赖编译期确定的函数地址，而是通过**虚函数表（vtable）**在运行期查找。

7.1 虚函数表机制

1. 虚表存储：每个含有虚函数的类都有一个虚函数表，存放该类所有虚函数的地址。同类型对象共享同一张虚表。
2. 虚表指针：对象内部包含一个指向虚表的指针（vptr）。派生类对象继承基类部分时，会携带基类的虚表指针，但通常会生成独立的虚表。
3. 覆盖机制：派生类重写虚函数时，其虚表中对应位置的地址会被更新为派生类函数的地址。
4. 本质：虚函数表本质上是一个存函数指针的数组，末尾通常有结束标记。

简而言之，当你通过基类指针调用虚函数时，程序会先找到对象的虚表指针，再通过虚表找到实际函数的地址并执行。这就是为什么能实现'指向基类，调用派生类'的效果。