多态分两种。函数重载和函数模板属于编译时多态:实参到形参的匹配在编译期完成,调用哪个函数在生成代码时就定了。运行时多态是同一个调用,根据对象实际类型走不同实现——普通人买票全价,学生买票打折,军人买票优先;同样是“叫”,猫叫和狗叫不是一回事。

动态绑定只有两个条件

  1. 通过基类的指针或引用调用;
  2. 被调用的函数是虚函数,并且派生类完成了重写。

条件一不是形式要求。按值传参会构造一个基类形参对象,派生类那部分被切掉,形参对象里的 vptr 指向基类的虚表,函数里拿到的就是一个彻底的基类对象,怎么调都回不到派生类。只有指针和引用能既指向基类对象,又指向派生类对象里的基类子对象。

#include <iostream>
 
class Person
{
public:
    virtual void BuyTicket() { std::cout << "买票-全价\n"; }
};
 
class Student : public Person
{
public:
    void BuyTicket() override { std::cout << "买票-打折\n"; }
};
 
void Func(Person* ptr) { ptr->BuyTicket(); }
 
int main()
{
    Person ps;
    Student st;
    Func(&ps);      // 买票-全价
    Func(&st);      // 买票-打折
}

虚函数就是类成员函数前面加 virtual。非成员函数不能加 virtual,静态成员函数也不行,因为它们没有 this,没有对象可供分派。

两个类各自重写 BuyTicket,Func 只收 Person*;同一个调用点,Mike 走全价、Johnson 走打折,区别由指针指向的对象决定

重写要求三样一致,默认参数不参与

重写的条件是:返回类型、函数名、参数列表完全相同。三样缺一不可,因为虚表的覆盖本质上是按槽位替换,签名有差别,槽位就对不上。

派生类写重写时,virtual 可以不写。虚属性从基类继承下来,派生类的同名同签名函数仍然是虚函数,仍然构成重写。语法允许,现代代码里写上 override 就足够,它同时表达“这是重写”并让编译器检查。课件提醒的考点是真的:选择题经常拿“派生类没写 virtual”来判断是否构成多态,答案是构成。

有一个例外叫协变(covariant return):基类返回基类对象的指针或引用,派生类返回派生类对象的指针或引用。

class A {};
class B : public A {};
 
class Person
{
public:
    virtual A* BuyTicket() { return nullptr; }
};
 
class Student : public Person
{
public:
    B* BuyTicket() override { return nullptr; }   // 协变,合法
};

返回值不同还能构成重写,只有这一种情况,实际用途不大。

默认参数是另一条规则:函数体可以动态绑定,默认实参不能。默认实参在编译期按调用点的静态类型确定,动态绑定只负责选函数体。

#include <iostream>
 
class A
{
public:
    virtual void func(int val = 1) { std::cout << "A->" << val << '\n'; }
    virtual void test() { func(); }
};
 
class B : public A
{
public:
    void func(int val = 0) override { std::cout << "B->" << val << '\n'; }
};
 
int main()
{
    B b;
    b.test();        // 输出 B->1
}

b.test() 调用的是继承下来的 A::test。test 内部写 func(),等价于 this->func(),满足“指针/引用 + 虚函数”,动态分派到 B::func;但默认实参取自静态类型 A 的声明,也就是 val = 1。所以输出是 B->1,不是 B->0。把默认参数写在派生类里,不会改变通过基类声明发起的调用。

析构函数也构成重写,虽然基类和派生类的析构函数名字看起来不同。标准在重写判断时把析构函数当作同名的特殊成员函数处理,有的编译器实现会把它统一改成 destructor 之类的内部名字。基类析构加上 virtual,派生类析构无论写不写 virtual 都重写它;不加,两者构成隐藏。

override 和 final 是 C++11 给这套规则加的两道检查:

#include <iostream>
 
class Car
{
public:
    virtual void Drive() { std::cout << "Car\n"; }
    virtual void Stop() final {}
};
 
class Benz : public Car
{
public:
    void Drive() override { std::cout << "Benz-舒适\n"; }   // 名字、签名都对上
    // void Stop() override {}   // error C3248:final 的函数不能被重写
};

把 Drive 写成 Dirve 再加 override,MSVC 报 C3668,GCC 报 “marked ‘override’, but does not override”。没有 override 时这种拼写错误不会报错,派生类只是多了一个普通函数,基类的虚函数仍是隐藏状态,运行时行为不对,排查要花很久。final 修饰虚函数禁止后续重写,修饰类禁止被继承。

重载、重写、隐藏三个概念经常一起考,差别在作用域和虚函数:

三者的判定条件:重载在同一作用域、名字相同参数不同;重写在父子类不同作用域、名字/参数/返回值都相同且两边都是虚函数;隐藏是父子类不同作用域、只要名字相同且不构成重写就算

虚析构:delete 只看静态类型

#include <iostream>
 
class A
{
public:
    virtual ~A() { std::cout << "~A()\n"; }
};
 
class B : public A
{
public:
    ~B()
    {
        std::cout << "~B()\n";
        delete[] _p;
    }
private:
    int* _p = new int[10];
};
 
int main()
{
    A* p1 = new A;
    A* p2 = new B;
    delete p1;      // ~A()
    delete p2;      // ~B() 然后 ~A()
}

delete p2 的静态类型是 A*。如果 ~A 不是虚函数,析构按静态类型走,只调 ~A,~B 里那句 delete[] _p 一次也不执行,那个长度为 10 的数组就泄漏了。加上 virtual 之后,析构走动态绑定,先调 ~B,~B 结束后编译器再自动调 ~A。

判断标准是:这个类会不会被继承、派生类对象会不会通过基类指针 delete。会,基类析构就必须是虚函数。不作为多态基类使用的值类型类不需要虚析构,虚析构会让类带上虚表指针,对象变大。

纯虚函数把类变成只提供接口的抽象类

在虚函数声明后面写 = 0,这个函数就是纯虚函数。纯虚函数可以只有声明,也可以另外给一份定义(在类外写 void Car::Drive() {}),但一般没有意义,因为它注定要被派生类重写。

含有纯虚函数的类是抽象类,不能实例化对象。派生类如果不重写纯虚函数,派生类也是抽象类,仍然不能实例化。这是一条强制约束:接口想被使用,实现就必须补齐。

#include <iostream>
 
class Car
{
public:
    virtual void Drive() = 0;
    virtual ~Car() = default;       // 会被 delete 的多态基类,析构写成虚的
};
 
class Benz : public Car
{
public:
    void Drive() override { std::cout << "Benz-舒适\n"; }
};
 
class BMW : public Car
{
public:
    void Drive() override { std::cout << "BMW-操控\n"; }
};
 
int main()
{
    // Car car;                    // error C2259:无法实例化抽象类
    Car* pBenz = new Benz;
    Car* pBMW = new BMW;
    pBenz->Drive();
    pBMW->Drive();
    delete pBenz;
    delete pBMW;
}

虚表指针和虚表:对象里一个指针,类外一张表

32 位程序下这段代码输出 12:

#include <iostream>
 
class Base
{
public:
    virtual void Func1() {}
protected:
    int _b = 1;
    char _ch = 'x';
};
 
int main()
{
    std::cout << sizeof(Base) << '\n';   // 32 位:12,64 位:16
}

int 4 字节、char 1 字节,成员合计 5 字节、补齐到 8 字节;前面还有 4 字节的虚函数表指针 __vfptr(v 是 virtual,f 是 function),总共 12 字节。

MSVC 的监视窗口:b 展开后第一个成员就是 __vfptr,后面才是 _b 和 _ch。这个指针指向 Base::vftable

课件说这个指针“放在对象的前面,有些平台可能会放到对象末尾”。这个说法要收一收:C++ 标准完全不规定对象布局,放在哪里由 ABI 决定。MSVC 和 Itanium ABI 在单继承、没有虚基类的情况下,都把第一个多态基类的 vptr 放在偏移 0,监视窗口看到的就是这个情况。多继承时对象里会有多个 vptr,各自位于对应多态基类子对象的开头,从整个对象看就不止“最前面一个”。

虚表是每个类一张,不是每个对象一张。同类对象共享同一张表,基类和派生类各有自己的表。对象里只存指向本类虚表的那个指针。同一个基类下的多个派生类各自重写,就各自有一张表,同一个调用点可以在它们之间切换——Person、Student、Soldier 三个对象走同一个 Func,各自调到自己的版本。

对象、vfptr 与虚表的关系:三个对象各自持有一个 vfptr,分别指向 Person、Student、Soldier 的虚表;虚表槽里存的是该类的 BuyTicket 地址

派生类的虚表由三部分拼成:从基类继承下来的虚函数地址、被重写的槽位换成派生类函数的地址、派生类新增虚函数的地址。基类的虚表只有基类自己的函数。派生类对象里的 vptr 不指向基类虚表,而是指向派生类虚表——这和“基类子对象里有 vptr”不矛盾:vptr 位于基类子对象里,值是派生类虚表的地址。

内存窗口:Base 对象头 4 字节是虚表地址,表里依次是 func1、func2 和结尾的 0;Derive 对象的虚表里 func1 换成了 Derive::func1,func2 仍是基类地址,后面追加 func3 和 0

虚表本质是一个函数指针数组。MSVC 会在表尾放一个 0 做标记,GCC 不放;这不是标准要求,是编译器各自的约定。虚函数体编译后就是普通指令,落在代码段;虚表本身落在只读数据段(PE 的 .rdata、ELF 的 .rodata),标准同样不规定这些位置。

动态绑定就是两次访存加一次间接调用。静态绑定的调用地址在编译期就写死,虚调用要先把对象里的 vptr 读出来,再按槽位偏移读出函数地址:

; 虚调用:ptr → vptr → 槽位 → 间接调用
mov rax, qword ptr [ptr]
mov rdx, qword ptr [rax]
call qword ptr [rdx]
 
; 非虚调用:地址在编译期确定
call Person::BuyTicket

多态调用的开销

开销有三块。

  • 对象变大:64 位下每个多态对象多 8 字节的 vptr;多继承时每个多态基类子对象各带一个。
  • 每次调用多两次内存读和一次间接跳转,而且编译器通常没法内联——不到运行时不知道目标是哪个函数。
  • 间接调用对分支预测不友好:同一个调用点如果轮换多个派生类,目标地址一直在变,预测失败的比例会上升。

编译器会在能证明动态类型时去虚化(devirtualization):通过对象本身调用(不是指针/引用)、类型带 final、或者开了链接时优化(LTO)看到全部实现,都可能把虚调用降成直接调用。这些是优化机会,不是语言保证。

所以“多态一定慢”和“虚函数没有成本”都不对。单次调用的额外开销很小,真正的代价常来自失去内联后带走的那些优化。热循环里如果确实测出虚调用是瓶颈,再考虑用模板做静态分派;没有测量数据之前,按接口需要选多态就够了。