C++ 多态：概念、实现与底层原理详解

这里可以看到 fun 函数虽然都是 Person 引用 p 在调用 BuyTicket，但结果由 p 指向的实际对象决定。

2.1.4 多态场景的一个选择题

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

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

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

int main(int argc, char* argv[]) {
    B* p = new B;
    p->test();
    return 0;
}

这道题有些难度。对于虚函数重写，我们理解为只重写实现（函数体）。所以派生类可以不写 virtual。 但在 p->test() 时，this 指针实际上是 A* 类型。 func 函数是否构成重写？由于默认参数不一致，且 val 参数不同，这里存在陷阱。 最终输出应该是 B->1。

2.1.5 虚函数重写的一些其他问题

• 协变：派生类重写基类虚函数时，若基类返回基类指针/引用，派生类返回派生类指针/引用，称为协变。
• 析构函数的重写：基类析构函数为虚函数时，派生类析构函数无论是否加 virtual 都构成重写。这很重要，否则 delete 基类指针时只会调用基类析构函数，导致内存泄漏。

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; // 只有基类析构函数为虚函数，这里才能正确调用 B 的析构函数
    return 0;
}

一句话：为了防止通过基类指针删除派生类对象时，只调用基类析构函数而不调用派生类析构函数，导致内存泄漏。

2.1.6 override 和 final 关键字

C++11 提供了 override 帮助检测是否重写成功，避免拼写错误导致的静默失败。如果想禁止派生类继续重写，可用 final 修饰。

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

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

若拼写错误，编译器会报错。若基类加了 final，派生类再 override 也会报错。

2.1.7 重载/重写/隐藏的对比

这是面试常考点。重载是同一作用域同名不同参；重写是继承关系中同名同参；隐藏是派生类屏蔽基类同名函数（无论参数是否相同）。

三、纯虚函数和抽象类

虚函数后写 =0 即为纯虚函数。包含纯虚函数的类叫抽象类，不能实例化。派生类若不重写纯虚函数，也是抽象类。这强制了派生类实现接口。

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

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

class BMW : public Car {
public:
    virtual void Drive() { cout << "BMW 操控" << endl; }
};

int main() {
    Car* pBenz = new Benz;
    pBenz->Drive();
    Car* pBMW = new BMW;
    pBMW->Drive();
    return 0;
}

四、多态的原理

4.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;
}

虚函数表本质是函数指针数组。

4.2 多态的原理

4.2.1 多态是如何实现的

底层不再是编译时确定函数地址，而是运行时到指向对象的虚表中查找对应虚函数的地址。

class Person {
public:
    virtual void BuyTicket() { cout << "买票全价" << endl; }
private:
    string _name;
};

class Student : public Person {
public:
    virtual void BuyTicket() { cout << "买票打折" << endl; }
private:
    string _id;
};

class Soldier : public Person {
public:
    virtual void BuyTicket() { cout << "买票优先" << endl; }
private:
    string _codename;
};

void Func(Person* ptr) { ptr->BuyTicket(); }

int main() {
    Person ps;
    Student st;
    Soldier sr;
    Func(&ps);
    Func(&st);
    Func(&sr);
    return 0;
}

ptr 指向谁，就去谁的虚表里找 BuyTicket 的地址。

4.2.2 动态绑定与静态绑定

• 静态绑定：不满足多态条件（如普通函数调用），编译时确定地址。
• 动态绑定：满足多态条件（指针/引用 + 虚函数），运行时查虚表确定地址。

涉及汇编层面，简单理解即可：静态绑定直接 call 函数地址；动态绑定先取 vptr，再取 vtable 中的函数地址，最后 call。

4.2.3 虚函数表

• 基类所有虚函数的地址。同类型对象共用同一张虚表。
• 派生类虚表包含：(1) 基类虚函数地址，(2) 派生类重写的虚函数地址（覆盖），(3) 派生类自己的虚函数地址。
• 虚函数表一般存放在常量区。VS 编译器会在虚表末尾放 0x00000000 标记，g++ 通常不放。

class Base {
public:
    virtual void func1() { cout << "Base::func1" << endl; }
    virtual void func2() { cout << "Base::func2" << endl; }
    void func5() { cout << "Base::func5" << endl; }
protected:
    int a = 1;
};

class Derive : public Base {
public:
    virtual void func1() { cout << "Derive::func1" << endl; }
    virtual void func3() { cout << "Derive::func1" << endl; }
    void func4() { cout << "Derive::func4" << endl; }
protected:
    int b = 2;
};

int main() {
    Base b;
    Derive d;
    // 调试时可查看虚表地址
    return 0;
}

总结

多态让'同一接口'在'不同对象'上拥有'不同实现'，是 C++ 面向对象思想真正落地的关键。掌握其底层机制有助于写出更健壮、高效的代码。