C++ 多态详解：概念、语法与底层实现

2.1 条件 1：虚函数的定义

类成员函数前加 virtual 关键字，该函数即为虚函数（非成员函数和静态成员函数不能加 virtual）。虚函数的作用是'标记'该函数需要参与多态，让编译器为其生成动态绑定逻辑。

// 基类：Person
class Person {
public:
    // 虚函数：标记为需要参与多态
    virtual void BuyTicket() {
        cout << "买票 - 全价" << endl;
    }
};

2.2 条件 2：虚函数的重写（覆盖）

派生类中定义一个'与基类虚函数完全一致'的函数，即为重写。这里'完全一致'指：

• 函数名相同；
• 参数列表（参数类型、个数、顺序）相同（缺省参数可以不管）；
• 返回值类型相同（协变除外，下文讲解）。

代码示例（注意看注释）：

// 基类：Person
class Person {
public:
    // 虚函数：标记为需要参与多态
    virtual void BuyTicket() {
        cout << "买票 - 全价" << endl;
    }
};

// 派生类：Student（继承 Person）
class Student : public Person {
public:
    // 重写基类虚函数：函数名、参数、返回值完全一致
    // 派生类中 virtual 也可以省略
    virtual void BuyTicket() {
        cout << "买票 - 打折" << endl;
    }
};

// 派生类：Soldier（继承 Person）
class Soldier : public Person {
public:
    // 重写基类虚函数
    // 派生类中 virtual 也可以省略
    virtual void BuyTicket() {
        cout << "买票 - 优先" << endl;
    }
};

// 关键：用基类指针调用虚函数（满足多态条件 1）
// 这里也可以用基类引用
void Func(Person* ptr) {
    // 运行时根据 ptr 指向的对象类型，调用对应类的 BuyTicket
    // Person* ptr ptr->BuyTicket();
    // 如果是基类引用 (Person& ptr)
    //ptr.BuyTicket();
}

int main() {
    Person ps;      // 基类对象
    Student st;     // 派生类对象（学生）
    Soldier sr;     // 派生类对象（军人）
    Func(&ps);      // 指向基类对象 → 调用 Person::BuyTicket → 输出'买票 - 全价'
    Func(&st);      // 指向学生对象 → 调用 Student::BuyTicket → 输出'买票 - 打折'
    Func(&sr);      // 指向军人对象 → 调用 Soldier::BuyTicket → 输出'买票 - 优先'
    return 0;
}

注意：派生类重写时，即使不加 virtual，也能构成重写（因为基类虚函数的'虚属性'会被继承），但不建议这么写，可读性差且易出错。 坑点（下面的笔试题会有体现）：在 C++ 中，虚函数重写时若基类和派生类的虚函数都指定了缺省参数，调用时的缺省值只由'基类的函数声明'决定，与派生类的重写实现无关。

2.3 多态场景的一个笔试选择题（重要）：

以下程序输出的结果是什么（B）
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

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(int argc, char* argv[]) {
    B* p = new B;
    p->test();
    return 0;
}

图解如下：

改编扩展：以下程序输出的结果是什么（D）
A: A->0 B: B->1 C: A->1 D: B->0 E: 编译出错 F: 以上都不正确

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(int argc, char* argv[]) {
    B* q = new B;
    q->func();
    return 0;
}

图解如下：

三、虚函数重写的特殊情况

虚函数重写并非只有'完全一致'一种情况，还有两种特殊场景需要注意：协变和析构函数重写，这也是面试高频考点。

3.1 协变（了解）

派生类重写基类虚函数时，返回值类型可以不同，但必须满足：

• 基类虚函数返回'基类对象的指针 / 引用'；
• 派生类虚函数返回'派生类对象的指针 / 引用'。

这种情况称为 '协变'，实际开发中使用较少，了解即可。

代码示例（注意看注释）：

#include <iostream>
using namespace std;

// 基类 A
class A {};

// 派生类 B（继承 A）
class B : public A {};

// 基类 Person
class Person {
public:
    // 虚函数：返回基类 A 的指针
    virtual A* BuyTicket() {
        cout << "买票 - 全价" << endl;
        return nullptr;
    }
};

// 派生类 Student
class Student : public Person {
public:
    // 重写：返回派生类 B 的指针（协变）
    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.2 析构函数的重写（重点）

基类的析构函数为虚函数：基类析构函数加 virtual 后，派生类析构函数无论是否加 virtual，都构成重写。这是因为编译器会将所有析构函数的名称统一处理为 destructor，看似名称不同，实则一致。

注意：这个在面试题中经常考到，问基类中的析构函数建不建议写成虚函数？大家可以结合下面的代码示例和为什么去进行回答，这样才能讲清楚

为什么需要析构函数构成重写？
如果基类析构函数不是虚函数，用基类指针指向派生类对象并 delete 时，只会调用基类析构函数，导致派生类中动态申请的资源无法释放，引发内存泄漏。

代码示例（注意看注释，其中额外测试部分是补充了解的和这里的重点不同）：

class A {
public:
    // 基类析构函数加 virtual，支持重写
    virtual ~A() {
        cout << "~A()" << endl;
    }
};

class B : public A {
public:
    // 派生类析构函数：自动构成重写（加不加 virtual 都可以）
    ~B() {
        cout << "~B()->delete:" << _p << endl;
        delete _p; // 释放派生类动态申请的资源
    }
protected:
    int* _p = new int[10]; // 派生类动态申请的数组
};

void test() {
    cout << "--------额外测试结果--------" << endl;
    // 额外测试，这个是正常场景，加不加都行
    // 只是为了让大家了解一下这个析构顺序
    // 析构顺序：~B(), ~A(), ~A()
    // 其中第一个~A() 是因为子类 B 析构完后调用基类的（先子后父）,后面一个是 a 对象析构
    A a;
    B b;
}

// 基类只要保障了析构函数是虚函数，下面场景就不会存在内存泄漏
int main() {
    // 基类指针指向派生类对象
    A* ptr1 = new B;
    delete ptr1; // 多态调用：先调用~B()，再先子后父自动调用~A()，无内存泄漏
    
    // 基类指针指向基类对象
    A* ptr2 = new A;
    delete ptr2; // 调用~A()
    
    test();
    return 0;
}

主要测试版块：如果基类析构不加 **virtual** ：delete ptr1 只会调用 ~A()，B 类中 _p 指向的数组未释放，导致内存泄漏。额外测试那里加不加都行。

四。C++11：override 与 final 关键字

虚函数重写对语法要求严格（如函数名写错、参数类型不匹配），这些错误编译时不会报错，只会在运行时出现非预期结果。C++11 提供 override 和 final 两个关键字，帮我们在编译阶段检测错误。

4.1 override：检测是否重写

在派生类虚函数后加 override，编译器会检查该函数是否真的重写了基类虚函数。若未重写（如函数名错、参数错），直接编译报错。 代码示例（注意看注释）：

class Car {
public:
    // 基类虚函数：Drive（注意拼写是 Drive，不是 Dirve）
    virtual void Drive() {
        cout << "Car-行驶" << endl;
    }
};

class Benz : public Car {
public:
    // 错误示例：函数名写成 Dirve，加 override 后编译报错
    // virtual void Dirve() override { cout << "Benz-舒适" << endl; }
    
    // 正确示例：函数名正确，override 检测通过
    virtual void Drive() override {
        cout << "Benz-舒适" << endl;
    }
};

int main() {
    Car* p = new Benz;
    p->Drive(); // 多态调用：输出'Benz-舒适'
    return 0;
}

4.2 final：禁止重写

在基类虚函数后加 final，表示该虚函数不允许任何派生类重写。若派生类强行重写，编译报错。 代码示例（注意看注释）：

class Car {
public:
    // 基类虚函数加 final：禁止派生类重写
    virtual void Drive() final {
        cout << "Car-行驶" << endl;
    }
};

class Benz : public Car {
public:
    // 错误：Drive() 被 final 修饰，无法重写，编译报错
    // virtual void Drive() override { cout << "Benz-舒适" << endl; }
};

int main() {
    return 0;
}

五。易混淆概念：重载、重写、隐藏的对比 (常考)

多态相关的三个概念 （重载、重写 (覆盖)、隐藏 (重定义)） 极易混淆，我们通过下面的图片，代码示例和表格来加强一下对它们的区分：

代码示例（借鉴 - 注意看注释）：

class Base {
public:
    // 1. 重载：同一作用域，函数名相同，参数不同
    void func(int a) {
        cout << "Base::func(int)" << endl;
    }
    void func(double b) {
        cout << "Base::func(double)" << endl;
    }
    
    // 虚函数：用于重写
    virtual void show() {
        cout << "Base::show()" << endl;
    }
};

class Derive : public Base {
public:
    // 2. 重写：基类与派生类，虚函数 + 函数名/参数/返回值相同
    virtual void show() override {
        cout << "Derive::show()" << endl;
    }
    
    // 3. 隐藏：基类与派生类，函数名相同但不构成重写
    void func(int a, int b) {
        cout << "Derive::func(int,int)" << endl;
    }
};

int main() {
    Derive d;
    d.func(1, 2); // 调用 Derive::func（隐藏基类 func）
    // d.func(3); // 编译报错：基类 func(int) 被隐藏，需显式调用 Base::func(3)
    
    Base* p = &d;
    p->show(); // 多态调用：Derive::show（重写）
    return 0;
}