C++ 多态核心原理与实现细节

输出结果会显示 fun 函数虽然都是 Person 引用 p 在调用 BuyTicket，但实际执行的是由 p 指向的对象决定的版本。

常见陷阱：默认参数

下面这道题考察了多态的一个深入细节：

class A {
public:
    virtual void func(int val = 1) { 
        std::cout << "A->" << val << std::endl; 
    }
    virtual void test() { func(); }
};

class B : public A {
public:
    void func(int val = 0) { 
        std::cout << "B->" << val << std::endl; 
    }
};

int main() {
    B* p = new B;
    p->test();
    delete p;
    return 0;
}

很多人会误以为输出是 B->0，但实际上输出是 B->1。

原因分析： 对于虚函数的重写，我们理解为只重写实现（函数体）。但在多态调用时，this 指针的类型决定了调用哪个版本的虚函数表，而默认参数的值是在编译期根据指针/引用的静态类型确定的。

在 p->test() 中，p 是 B*，但 test 是 A 的成员函数，且 test 内部调用 func 时，编译器看到的是 A 的签名，因此默认参数取 A 中的 val=1。尽管运行时调用了 B 的 func 实现，但参数值已经固定为 1。

其他重要问题

1. 协变（Covariance）：派生类重写基类虚函数时，返回值类型不同。如果基类虚函数返回基类对象的指针或引用，派生类虚函数返回派生类对象的指针或引用，称为协变。这在处理对象生命周期管理时很有用。

2. 析构函数的重写：基类的析构函数为虚函数时，派生类析构函数无论是否加 virtual 关键字，都与基类的析构函数构成重写。这是为了防止通过基类指针删除派生类对象时，只调用基类析构函数而不调用派生类析构函数，导致内存泄漏。

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

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

int main() {
    A* p2 = new B;
    delete p2; // 正确调用 ~B() 和 ~A()
    return 0;
}

2. override 和 final 关键字

C++11 提供了 override 和 final 来增强安全性。

• override：帮助检测是否真正重写了虚函数。如果拼写错误或参数不匹配，编译器会报错。
• final：阻止派生类继续重写该虚函数。

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

class Benz : public Car {
public:
    void Drive() override { cout << "Benz 舒适" << endl; }
};

如果 Drive 拼写错误，加上 override 后编译器会直接报错，避免运行时才发现逻辑错误。

3. 重载 / 重写 / 隐藏的对比

这三个概念经常混淆，简单区分如下：

• 重载（Overload）：同一作用域内，函数名相同，参数列表不同。
• 重写（Override）：派生类与基类之间，函数名、参数、返回值相同，且有虚函数机制参与。
• 隐藏（Hide）：派生类定义了与基类同名的函数，但参数不同或未加 virtual，此时基类函数被隐藏。

三、纯虚函数和抽象类

在虚函数后面写上 =0，则这个函数为纯虚函数。包含纯虚函数的类叫做抽象类，抽象类不能实例化出对象。如果派生类继承后不重写纯虚函数，那么派生类也是抽象类。

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

class Benz : public Car {
public:
    void Drive() { cout << "Benz 舒适" << endl; }
};

int main() {
    // Car car; // 错误：抽象类不能实例化
    Car* pBenz = new Benz;
    pBenz->Drive();
    delete pBenz;
    return 0;
}

纯虚函数某种程度上强制了派生类重写虚函数，因为不重写就无法实例化对象。

四、多态的原理

1. 虚函数表指针

含有虚函数的类中至少都有一个虚函数表指针（vptr）。一个对象的大小除了成员变量外，还包含了这个指针。

class Base {
public:
    virtual void Func1() { cout << "Func1()" << endl; }
protected:
    int _b = 1;
    char _ch = 'x';
};

int main() {
    Base b;
    cout << sizeof(b) << endl; // 通常比成员变量总和大，因为多了 vptr
    return 0;
}

虚函数表本质是一个存虚函数指针的数组。同类型的对象共用同一张虚表，不同类型的对象各自有独立的虚表。

2. 动态绑定与静态绑定

• 静态绑定：对不满足多态条件的函数调用（如普通函数、非虚函数），在编译时确定调用函数的地址。
• 动态绑定：满足多态条件（指针/引用 + 虚函数）的调用，在运行时到指向对象的虚表中找到调用函数的地址。

底层汇编层面来看，动态绑定需要多一次间接寻址：先拿到对象头部的 vptr，再拿到 vptr 指向的虚表，最后从虚表中取出函数地址进行调用。

3. 虚函数表的存储位置

虚函数表本身存储在常量区（数据段）。派生类的虚函数表包含三部分：

1. 基类的虚函数地址。
2. 派生类重写的虚函数地址（覆盖基类对应位置）。
3. 派生类自己的虚函数地址。

当基类虚函数被派生类重写时，派生类虚表中对应的虚函数地址会被覆盖成派生类重写的地址，这就是多态能够生效的根本原因。

总结

多态让'同一接口'在'不同对象'上拥有'不同实现'，是让 C++ 面向对象思想真正落地的关键。理解虚函数表、动态绑定以及析构函数的虚化设计，对于编写健壮、可扩展的系统至关重要。