多态分两种。函数重载和函数模板属于编译时多态:实参到形参的匹配在编译期完成,调用哪个函数在生成代码时就定了。运行时多态是同一个调用,根据对象实际类型走不同实现——普通人买票全价,学生买票打折,军人买票优先;同样是“叫”,猫叫和狗叫不是一回事。
动态绑定只有两个条件
- 通过基类的指针或引用调用;
- 被调用的函数是虚函数,并且派生类完成了重写。
条件一不是形式要求。按值传参会构造一个基类形参对象,派生类那部分被切掉,形参对象里的 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,没有对象可供分派。

重写要求三样一致,默认参数不参与
重写的条件是:返回类型、函数名、参数列表完全相同。三样缺一不可,因为虚表的覆盖本质上是按槽位替换,签名有差别,槽位就对不上。
派生类写重写时,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 字节。

课件说这个指针“放在对象的前面,有些平台可能会放到对象末尾”。这个说法要收一收:C++ 标准完全不规定对象布局,放在哪里由 ABI 决定。MSVC 和 Itanium ABI 在单继承、没有虚基类的情况下,都把第一个多态基类的 vptr 放在偏移 0,监视窗口看到的就是这个情况。多继承时对象里会有多个 vptr,各自位于对应多态基类子对象的开头,从整个对象看就不止“最前面一个”。
虚表是每个类一张,不是每个对象一张。同类对象共享同一张表,基类和派生类各有自己的表。对象里只存指向本类虚表的那个指针。同一个基类下的多个派生类各自重写,就各自有一张表,同一个调用点可以在它们之间切换——Person、Student、Soldier 三个对象走同一个 Func,各自调到自己的版本。

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

虚表本质是一个函数指针数组。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)看到全部实现,都可能把虚调用降成直接调用。这些是优化机会,不是语言保证。
所以“多态一定慢”和“虚函数没有成本”都不对。单次调用的额外开销很小,真正的代价常来自失去内联后带走的那些优化。热循环里如果确实测出虚调用是瓶颈,再考虑用模板做静态分派;没有测量数据之前,按接口需要选多态就够了。
还没有评论 — 第一条由你来留。