C++ 面向对象核心：多态详解

// A 类与 B 类中的 func 构成重写
class A {
public:
    virtual void func() {}
};

class B : public A {
public:
    void func() {} // 未加 virtual，但依然构成重写
};

override 和 final 关键字

C++ 对虚函数重写的要求比较严格，有时疏忽导致函数名或参数写错，无法构成重写，而编译器不会报错，只有运行后才发现问题。因此 C++11 提供了 override 关键字来辅助检测。

class Person {
public:
    virtual void buyticket() {}
};

class Student : public Person {
public:
    virtual void buyticket() override {} // 如果签名不匹配，编译会报错
};

如果我们不想让派生类继续重写这个虚函数，可以用 final 修饰。

3. 多态的实现

多态实现的条件

要实现运行时多态，必须满足两个条件：

1. 必须是基类的指针或者引用调用虚函数。
2. 被调用的函数必须是虚函数，并且完成了虚函数重写/覆盖。

第一点是因为只有基类的指针或引用才能同时指向基类和派生类对象。第二点是因为派生类必须重写虚函数，否则基类和派生类之间没有区别，也就没有多态的效果。

class Person {
public:
    virtual void buyticket() {
        cout << "全价票" << endl;
    }
};

class Student : public Person {
public:
    virtual void buyticket() override {
        cout << "半价票" << endl;
    }
};

void Func(Person* ptr) {
    ptr->buyticket(); // 用基类指针调用虚函数
}

int main() {
    Person p;
    Student s;
    Func(&p); // 调用基类虚函数
    Func(&s); // 调用派生类虚函数
    return 0;
}

多态场景下的经典面试题

看下面这段代码，输出结果是什么？

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

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

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

很多人直觉会选 D（B->0），因为指针指向 B 类对象。但正确答案是 B (B->1)。

原因在于：默认参数是静态绑定的。虽然 test 函数是虚函数，支持动态绑定调用函数体，但默认参数的值是在编译时根据调用者的指针类型决定的。这里 p 是 B* 类型，但 test() 属于基类 A 的接口声明，所以默认参数 val 会使用 A 中声明的值 1，而不是 B 中的 0。

形象理解：虚函数重写后，派生类中的虚函数其实是由基类虚函数的函数名和参数列表（包括默认值）与派生类的虚函数实现部分组成的。

4. 虚函数重写的特殊场景

析构函数的重写

基类的析构函数为虚函数时，派生类析构函数无论是否加 virtual，都与基类析构函数构成重写。这是因为编译器对析构函数名称做了特殊处理，统一成 destructor。

为什么要这样设计？ 这关系到内存安全。

当一个基类指针 ptr 指向派生类对象时，如果基类析构函数不是虚函数，delete ptr 时只会调用基类析构函数（静态绑定）。如果派生类中有额外资源（如动态分配的内存），就会导致内存泄漏。

只要基类析构函数设为虚函数，delete ptr 就会根据指针真正指向的类型调用相应的析构函数（动态绑定），派生类析构函数先执行释放资源，随后自动调用基类析构函数，确保资源被正确清理。

class A {
public:
    virtual ~A() {} // 虚析构函数
protected:
    int _a;
};

class B : public A {
public:
    ~B() { 
        delete[] _b; 
        _b = nullptr; 
    }
protected:
    int* _b = new int[10]; // 派生类有额外资源
};

int main() {
    A* a1 = new B;
    delete a1; // 正确释放，不会泄漏
    return 0;
}

协变（了解）

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

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

class Student : public Person {
public:
    virtual Student* BuyTicket() { // 返回派生类指针
        cout << "买票 - 打折" << endl;
        return nullptr;
    }
};

5. 纯虚函数和抽象类

在虚函数后面写上 =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）。在 32 位机器下，一个指针占 4 字节。如果一个类有虚函数，对象大小会增加一个指针的大小。

例如：

class B {
    char _ch;
    int _b;
    // 隐含了一个 _vfptr 指针
};

对象大小不仅仅是成员变量之和，还要考虑对齐和 vptr。

2. 虚函数表

• 基类对象的虚函数表中存放基类所有虚函数的地址。 同类型的对象共用同一张虚表，不同类型的对象各自有独立的虚表。
• 派生类虚函数表：包含继承下来的基类虚函数地址（可能被覆盖）、派生类重写的虚函数地址、派生类自己的虚函数地址。
• 虚函数存储位置：虚函数本身存储在代码段，虚函数表通常也存储在代码段（常量区）。

3. 多态的底层实现

满足多态条件后，底层不再是编译时确定函数地址，而是运行时到指向对象的虚表中查找对应的虚函数地址。这就实现了指针或引用指向基类就调用基类虚函数，指向派生类就调用派生类对应虚函数。

4. 动态绑定和静态绑定

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

三、总结

多态是 C++ 面向对象编程非常重要的特性，在处理相似特性的问题时作用巨大。面试中关于多态的考点很多，尤其是虚函数机制、析构函数虚化以及默认参数的静态绑定等细节，需要结合底层原理深入理解。