主题
虚函数与多态 —— 深度复盘
日期:2026-09-09 主题:C++ 面向对象 · 虚函数底层机制 / 对象切割 / 抽象类 关联笔记:面向对象 · 多态格式说明:每题含「题目 → 我的回答(原话归纳)→ 点评(✅ 答对 / ⚠️ 不完整 / ❌ 答错)→ 标准答案/补充细节」
问链一:虚函数底层机制
Q1. p->f() 从编译到运行,底层发生了什么?
题目:Base 含虚函数 virtual void f(),Derived 重写;执行 Base* p = new Derived(); p->f();
我的回答:p 是基类指针指向派生类对象;通过对象 vptr 找到该类 vtable 再调用;虚表编译期生成,但动态类型运行期才确定。
点评:✅ 方向正确(查表分派、静态/动态类型、编译期建表)。⚠️ 缺三个关键细节:
- vptr 位置:通常位于对象布局最开头,调用 = 取内存首地址 → 读前 8 字节得 vptr → 解引用得 vtable。
- vtable 存什么:不是"存虚函数",而是虚函数地址数组——被重写函数的槽位被覆盖为
Derived::f;未被重写的虚函数槽位仍指向基类版本。查找靠编译期写死的偏移量,不是运行时找名字。 - vtable 放哪:只读数据段(.rodata),每个类一张,同类对象共用。
标准回答:p->f() 编译为:从 p 指向内存开头取 vptr → 解引用得 Derived 的 vtable → 按编译期定好的偏移量取函数地址 → 跳转。 表是在编译期生成、存放于只读段;对象构造时 vptr 才指向自己类的表,因此动态类型在运行期才定。
Q2. vptr 是什么时候、被谁写进对象的?
题目:执行 new Derived() 的内存分配后,vptr 经历什么?
我的回答:构造时写入,位于内存前端,指向编译期生成的该类虚表。
点评:⚠️ 方向对,但漏了继承链上 vptr 会被写两次这一核心细节:
第 1 步:分配原始内存(此时没有 vptr)
第 2 步:进入 Base 构造——Base 构造体执行前,vptr → Base 的 vtable(对象"以为自己是 Base")
第 3 步:Base 构造完,回到 Derived 流程,执行派生类成员初始化/构造体前,vptr 被【重新赋值】→ Derived 的 vtable
第 4 步:初始化 Derived 成员、执行构造体一句话:构造到哪一层,vptr 就指向哪一层的表。单层类"构造时写入一次"的说法成立;继承链上必须说"先指向基类,回派生层时覆盖改写"。
Q3. 构造函数中调用虚函数,输出什么?为什么?
题目:
cpp
class Base {
public:
Base() { print(); } // 构造中调虚函数
virtual void print() { cout << "Base" << endl; }
};
class Derived : public Base {
int* data;
public:
Derived() : data(new int[100]) {}
virtual void print() override { cout << "Derived" << endl; }
};
Derived d; // 输出?我的回答:输出 "Base"。构造先执行 Base 构造函数,此时 vptr 指向 Base 虚表,调的是基类版本。
点评:✅ 答案与推理链完整(先构造基类 → vptr 指向基类表 → 虚调用落基类版)。还差"为什么语言要故意这么设计":
若基类构造期间真分派到
Derived::print,此时data尚未初始化(派生类成员在基类构造后才轮到),访问即垃圾值/UB。故 C++ 规定:构造/析构期间 vptr 永远指向当前正在构造/析构的类,虚调用按当前类解析——是刻意为之的安全保护,不是实现缺陷。
对称考点(快问快答):析构中调虚函数同理——Derived 先析构,vptr 回退指向基类表,只调当前层版本,原因同为"派生类部分已销毁"。
Q4.(答疑)为什么只打印一次"Base"?
我的疑问:打印完 Base 后应该继续构造派生类,为什么不打印?
解答:print() 的调用点只有一个——Base 构造体里那一行。Derived 只是重写(override),重写仅覆盖 vtable 槽位,本身不产生调用;Derived 构造体为空,无任何调用,自然不再输出。vptr 后来确实改为指向 Derived 表,但没有代码触发调用,表只是工具,不会主动调函数。
反例小测:若 Derived 构造体里也写一行 print();,完整输出是 "Base" → "Derived"——第二次调用发生时 vptr 已指向 Derived 表。同一虚函数,执行那一刻 vptr 指向谁,就调谁的版本。
问链二:对象切割与抽象类
Q1. 值传递为什么丢多态?两个层面分别发生什么?
题目:void makeSound(Animal a); 传 Dog d;
我的回答:对象切割;形参是基类类型,执行的是 Animal 的(拷贝)构造,Dog 特有成员被切掉只剩基类部分;vptr 指向基类虚表;最终构造出的是纯基类对象。
点评:✅ 核心全对(走基类拷贝构造、切数据、vptr 指向基类表、"新对象是纯基类对象"这一本质总结尤其到位)。一处表述必须纠正:
❌ "Dog 特有的成员函数等数据成员会被删除" —— 成员函数不在对象里,不参与切割。对象内存只有 vptr + 成员变量;函数编译期生成、放代码段、全部对象共享,通过
this区分操作对象。切割切的是数据。
补充:为什么新对象 vptr 不能复制源对象的?
若
Animal a持有 Dog 的 vptr,a.speak()查表调到Dog::speak,其函数体访问 Dog 特有成员(已被切掉)→ 越界 UB。故语言规定:vptr 永远指向"该对象实际类型"的表,构造完成后必然指向基类表。与 Q2 问链呼应:vptr 由构造写入,从不从源对象复制。
本质再总结:切割不是"Dog 被缩小",而是调用了基类拷贝构造、生成了一个全新的纯基类对象;Dog 的部分自始至终不属于新对象。两步:① 拷贝清单只含基类成员(数据被切);② vptr 被重置指向基类表(多态失效)。
Q2. 如何从语言层面杜绝对象切割?
我的回答:把基类虚函数设纯虚 → 抽象类不能实例化 → 值传参编译期报错,从根源杜绝。
点评:✅ 标准答案。一旦基类抽象,void f(Animal a) 的形参声明本身编译失败,静默的坑变成编译错误(最理想的失败时机)。侧面印证:设计良好的接口基类几乎都是抽象类——Animal 是抽象概念,不该有实例,语义与防御双重正确。
Q3. 抽象类边界:六行代码,哪些编译通过?
题目:
cpp
class Shape { // 含 virtual double area() = 0;
protected: double scale;
public:
Shape(double s = 1.0) : scale(s) {}
virtual double area() = 0;
};
class Circle : public Shape { // 已实现 area()
double r;
public:
Circle(double rr, double s) : Shape(s), r(rr) {}
double area() override { return 3.14 * r * r; }
};| # | 代码 | 结果 | 原因 |
|---|---|---|---|
| ① | Shape s; | ❌ | 抽象类不能实例化 |
| ② | Shape* p = new Circle(1, 1); | ✅ | 实例化的是派生类;基类指针/引用是抽象类的合法用法(多态入口) |
| ③ | Circle c(1, 1); | ✅ | 派生类实现了全部纯虚函数,可实例化 |
| ④ | void f(Shape s); f(c); | ❌ | 抽象类不能按值传参(编译期) + 即使非抽象也会对象切割 |
| ⑤ | Shape arr[10]; | ❌ | 要构造 10 个 Shape 实例,全是抽象类 |
| ⑥ | Circle* q = new Shape(); | ❌ | new 的对象类型是 Shape(抽象),与指针声明类型无关——经典陷阱 |
我的回答:六题全对,⑥ 抓住本质(实例化的是基类,不是指针类型)。
补充:为什么抽象类不能实例化(本质)?
纯虚函数无实现 → 对应 vtable 槽位是空的。若允许
new Shape(),构造完 vptr 指向这张表,调用area()查表取地址——取到空槽,跳转即崩。故语言在编译期禁止实例化,保证"能被实例化的类的 vtable 必然完整"。派生类不实现全部纯虚函数就仍是抽象类,同理(它的表里也还有空槽)。
Q4.(快问快答)纯虚函数的两个冷门细节
① 纯虚函数可以带函数体吗? virtual void print() = 0 { ... }
我的回答:合法,但派生类仍必须重写;认为函数体"无意义、方便阅读"。
点评:✅ 判断正确(合法、必须重写)。❌ 对函数体意义的理解错误——它是"默认实现":
cpp
class Circle : public Shape {
public:
void print() override {
Shape::print(); // 显式调用基类默认实现,复用公共逻辑(不走虚分派)
cout << "Circle" << endl;
}
};对比:普通虚函数不重写则静默继承默认行为;纯虚带实现 = 逼你写重写,但给你可复用的默认版本,需要时显式调用。纯虚 + 函数体 ≠ 纯摆设。
② 析构函数可以是纯虚的吗?只写 virtual ~Shape() = 0; 不给实现会怎样?
我的回答:认为不可以(错误)。
点评:❌ 析构可以是纯虚的,且是实用技巧:
场景:类里没有合适函数设纯虚,但想强制抽象 → 把析构设纯虚即可(含纯虚函数的类即为抽象类)。 坑:纯虚析构必须在类外给实现(
Shape::~Shape() {}),否则链接错误(编译能过)。
为什么必须给实现? 与"重写覆盖"不同,析构是链式调用:派生类销毁时必然先执行自己析构体、再自动调用基类析构——这个自动调用是编译器生成的硬性代码,链接时需要
~Shape()的真实地址;纯虚声明不提供实体,链接器找不到。普通纯虚函数无实现没事(没人自动调用它),但析构函数天生会被派生类自动调用,绕不开。记忆点:虚表中普通纯虚函数空槽可以一直空着;析构的调用链逼着它必须有实体。
问链三:虚析构与资源释放
Q1. delete p;(基类析构非 virtual)到底发生什么?
题目
cpp
class Base {
public:
~Base() { cout << "~Base()" << endl; } // 注意:没有 virtual
};
class Derived : public Base {
int* data;
public:
Derived() : data(new int[100]) {}
~Derived() { delete[] data; cout << "~Derived()" << endl; }
};
Base* p = new Derived();
delete p; // 输出?后果?我的回答:只打印 ~Base();p 的静态类型是 Base,不是虚函数所以直接调 Base 析构;后果是派生类堆数据无法释放,内存泄漏。
点评:✅ 结论全对。⚠️ 解释停在"静态类型"表象层,缺三层深度:
① 不是"查表查到 Base 版",是根本没资格查表
virtual 的作用就是给这个函数在 vtable 里开一个槽位。析构非虚 → 槽位不存在 → 连查表这个动作都不会发生,编译器直接写死一条 call Base::~Base()(静态绑定)。对比问链一 Q1 的 p->f():那时有槽位,才会走「取 vptr → 查表 → 跳转」;这里第一条指令就分岔了。
② 后果不止一个指针泄漏,是成链的
~Derived() 这个函数体整个没被执行,派生类的成员对象全部不析构:
| 派生类成员 | 不析构的后果 |
|---|---|
int* data | 那块内存泄漏(你答到的) |
std::string / std::vector | 内部堆缓冲区泄漏 |
std::ofstream | 缓冲区不 flush → 数据丢失 |
std::mutex | 不解锁 → 其他线程永久死锁 |
基类部分被正确析构了,派生类部分整体被跳过——而派生类部分往往才是持有资源的那个。
③ 标准层面是 UB,不只是"泄漏"
C++ 标准规定:若 delete 的指针静态类型 ≠ 动态类型,则静态类型必须有虚析构,否则行为未定义。多继承 / 有偏移时,p 指向的是基类子对象,不是完整对象首地址;非虚析构 → 编译器按 Base 布局归还内存 → 把错误地址喂给 operator delete → 堆破坏,典型的 crash / 安全漏洞来源。
补充(本题代码的局限):上面代码里 Base 一个虚函数都没有,所以对象里连 vptr 都不存在。经典版本是基类有别的虚函数(说明它会被继承),但析构偏偏忘了写 virtual:这时 vptr 真实存在、且指向 Derived 的表——可表里没有析构的槽位,vptr 一样帮不上忙。"有 vptr" ≠ "虚析构",高频误解。
⚠️ 易错点:编译器不会拦截(我的复述踩过这个坑)
复述时我曾说"编译器禁止该行为,被拦截"。错。实测:
$ g++ -std=c++17 -Wall -Wextra -Wpedantic novt.cpp -o novt
✅ 编译成功,零警告
$ ./novt
~Base()
exit=0编译通过、零警告、正常跑完、静静泄漏。 编译器一声不吭。而且"被拦截"与"未定义"自相矛盾——被拦截就不会有 UB,有 UB 就说明没拦住。
两个保护机制别搞混:
| 场景 | 时机 | 谁保护你 |
|---|---|---|
| 抽象类按值传参(问链二 Q2) | 编译期报错 | 语言机制:cannot declare parameter to be of abstract type |
非虚析构 + delete 基类指针(本题) | 运行期 UB | 没人保护,只能靠人自觉 |
这恰恰是"工程准则"存在的理由:因为编译器不保护,所以只能靠"基类有虚函数 → 析构必须 virtual"这条纪律兜底。若编译器会拦,这条准则就没必要口口相传了。
话术:「这里编译器不会报错——编译通过、运行时才 UB。所以这条是靠工程准则兜底,不是靠编译器兜底。」
Q2. 改虚析构后,delete p 的完整调用链
我的回答:取前 8 字节 vptr → 找到 Derived 虚表 → 执行重写的析构释放内存 → "由于 delete 会依次调用上层 Base 的析构函数" → 对象完全析构。
点评:✅ 主干对。❌ 一处因果错误:「由于 delete 才调用 Base 析构」——Base 析构是 Derived 析构函数体内部直接、非虚调用过去的,编译期写死;delete 全程只发起一次间接调用。
标准答案:析构函数的三个版本
编译器为每个有虚析构的类生成 3 个析构函数:
| 版本 | 符号 | 职责 |
|---|---|---|
| D2 | base object destructor | 只析构当前一层子对象,供派生类析构内部调用 |
| D1 | complete object destructor | 析构完整对象(派生成员 + 链式调基类析构),不释放内存 |
| D0 | deleting destructor | D1 + operator delete。delete p 命中的是它 |
完整调用链
delete p
└─ 取 vptr → 查表 → 跳到 Derived::~Derived() [D0] ← 全程唯一一次间接调用
├─ call Derived::~Derived() [D1]
│ ├─ delete[] data ← 释放:对象【持有】的资源
│ └─ call Base::~Base() [D2] ← ★直接调用,不走 vtable
└─ call operator delete(p, …) ← ★释放:对象【自身】占的内存两个要点
- 基类析构是硬性链式调用,不再虚分派。派生类销毁完了必然轮到基类,没有"选择"的余地,自然不需要查表——这与问链二 Q4②「纯虚析构为什么必须在类外给实现」是同一个机制:链接器需要
~Base()的真实地址 operator delete由 D0 调用,不是delete表达式调的。所以它收到的肯定是p原值——这也解释了 Q1 里非虚析构遇到多继承时地址喂错、堆破坏的成因
记忆:先释放"对象持有的资源",最后才释放"对象自己占的内存",两件事别合并。
Q3. 只写 p->~Base(); 不写 delete 会怎样?
题目
cpp
Base* p = new Derived();
p->~Base(); // 只显式调析构,不写 delete我的回答:(本题未作答,由我给出答案)
标准答案:~Base 是虚函数,所以显式析构调用同样触发多态,命中的是 vtable 里的 D1 槽位(不是 delete 用的 D0,两者偏移不同)。因此:
- ✅
~Derived()执行,data正常释放,没有派生类资源泄漏 - ❌ 对象自身那块内存泄漏(
operator delete没被调用),实测new=2, delete=1 - 一句话:析构了,但没还内存。
衍生:显式析构完再 delete 会 double free 吗?
实测没崩,原因是析构函数会把 vptr 回退指向当前层(基类)的表(与问链一 Q2 同源):D1 执行到底时 vptr 已指回 Base 的表,delete p 再读 vptr 拿到的是 Base 的表 → 命中 Base::D0 → 只析构基类子对象就归还内存。
⚠️ 但这是 UB,只是侥幸没炸(单继承首基类地址恰好一致 +
~Base()恰好平凡)。若Base析构里有delete ptr;,第二次执行即 double free。工程铁律:显式调过析构函数的对象,绝不能再
delete。
Q4. ~Derived() 不写 virtual,它是虚函数吗?
题目
cpp
class Base {
public:
virtual void f() {}
virtual ~Base() {}
};
class Derived : public Base {
public:
~Derived() { } // ★ 没写 virtual
};
Derived d;
Base* p = &d;
delete p; // 会正确调到 ~Derived() 吗?我的回答:是虚函数。(✅ 结论对,但未给"为什么")
标准答案
一旦基类把析构声明为 virtual,派生类析构自动就是虚函数,无需重写 virtual。 virtual 是继承的属性,不是每层都要声明的。
原理:virtual 决定的是"这个函数在 vtable 里有没有槽位",槽位按函数身份划分,不按类划分。基类开了槽,派生类同名同签名即占据并覆盖该槽位——槽位一旦存在,派生类没有能力取消它。所以本题 delete p 正确调用 ~Derived(),不泄漏。
注意析构的特殊性:~Base 和 ~Derived 名字根本不同,却能构成重写——这是语言特例:派生类析构函数总是覆盖基类虚析构函数,无论名字。
追问:override 用在析构上有意义吗?
- 语义价值很低:
override的价值是让编译器校验"我以为在重写"。普通函数签名写错(void f(int)想重写f())会静默变成隐藏,加override立刻报错;而析构函数不存在写错名字的可能,编译器天然强制校验 - 真正有价值的是
virtual关键字本身,属文档价值:读代码的人不必回头翻基类,一眼看出"这里发生多态"。C++11 后~Derived() override = default;是清晰写法 - 工程铁律:
virtual必须写在基类上(否则一切免谈);派生类写不写不影响正确性,只影响可读性
问链四:RTTI(typeid / dynamic_cast)
Q1. dynamic_cast 的失败行为
题目
cpp
class Base { public: virtual ~Base() {} };
class Derived : public Base { public: int x = 42; };
class Other : public Base { public: int y = 99; };
Base* pb = new Derived();
Base& rb = *pb;
Derived* pd = dynamic_cast<Derived*>(pb); // ①
Other* po = dynamic_cast<Other*>(pb); // ②
Derived& rd = dynamic_cast<Derived&>(rb); // ③
Other& ro = dynamic_cast<Other&>(rb); // ④我的回答:答不上来。印象中这是把基类指针改为派生类指针的下行转换,要求有虚函数、有继承关系。
点评:✅ 印象里那三点都对(下行转换 / 要求虚函数 / 要有继承关系)。⚠️ 缺失败行为和为什么,而且"要求虚函数"是硬性要求,不只是习惯。
标准答案(实测)
| # | 表达式 | 结果 |
|---|---|---|
| ① | dynamic_cast<Derived*>(pb) | ✅ 成功,返回有效指针,pd->x = 42 |
| ② | dynamic_cast<Other*>(pb) | ❌ 返回 nullptr |
| ③ | dynamic_cast<Derived&>(rb) | ✅ 成功,rd.x = 42 |
| ④ | dynamic_cast<Other&>(rb) | ❌ 抛 std::bad_cast |
为什么指针和引用的失败行为不一样?
不是刻意设计,是引用"没得选"。 指针有天然的"无效值"
nullptr,失败就返回它,调用方自己判。引用必须绑定到一个真实对象,语言层面不存在"空引用"。所以失败时只有抛异常或 UB 两条路——C++ 选了抛bad_cast。这是被迫的,不是偏好。
空指针特例:对指针类型的 dynamic_cast,源指针为空 → 结果直接为空,不会去查类型信息,不崩。
⚠️ 但
dynamic_cast<Derived*>(nullptr)编译不过——nullptr是std::nullptr_t,不是指针类型,报source is not a pointer。必须先转成Base*:dynamic_cast<Derived*>((Base*)nullptr)。
补充:为什么 ②④ 失败?—— 判据是"对象是不是一个 T",不是"类型相不相等"
cpp
class Base { virtual ~Base() {} };
class Derived : public Base {};
class Other : public Base {}; Base
/ \
Derived Other ← 兄弟,互不兼容对象真实身份是 Derived,套用判据 成功 ⟺ 目标类型在真实类型的继承链上:
| 目标 T | 判断 | 结果 |
|---|---|---|
Derived | 就是它 | ✅ 成功 |
Other | Derived 继承自 Other?不是(兄弟) | ❌ 失败 |
关键:换对象结果就翻转 —— 同一句 dynamic_cast<Derived*>(p),对象是 Derived 时成功、是 Other 时失败。决定成败的是对象的真实类型,不是 cast 怎么写。
真实对象=Derived | cast到Derived: 成功 | cast到Other: 失败
真实对象=Other | cast到Derived: 失败 | cast到Other: 成功它不是"相等判断"(实测):对象 Derived、目标 Base,类型不相等却转换成功:
typeid(*p) == typeid(Base) : 0 ← 不相等
dynamic_cast<Base*>(p) : 成功 ← 却成功判据是 is-a 关系,不是 ==。
❌ 错误模型:「
dynamic_cast就是把静态类型改为动态类型」 ✅ 正确模型:一次「带验证的编译期类型改写」
- 编译期:改写静态类型(所以失败时编译仍通过——改写本身是合法的)
- 运行期:向对象核对"这个改写说得通吗?"→ 通则放行并调偏移,不通则
nullptr/bad_cast
⚠️ 易错点:运行期只用到【两个】类型,源静态类型不参与
复述时我曾把参与判断的类型说成三个(目标类型 + 源静态类型 + 动态类型)。源静态类型只在编译期用——编译器拿它做两件事:① 检查转换合法 ② 算偏移量。到了运行期,它跟判断结果一点关系都没有。
实测:同一个对象,把源指针的静态类型从 Derived* 换成 Base*,结果一模一样:
源静态=Derived* | 转Other: 失败 | 转Base: 成功
源静态=Base* | 转Other: 失败 | 转Base: 成功
→ 源静态类型变了,结果一模一样 → 它不参与运行期判断参与运行期判断的只有两个:
| 类型 | 来源 |
|---|---|
目标类型 T | 你写进 <T*> 的那个("改后的静态类型") |
对象的动态类型 D | 从 vptr → vtable +0x08 → typeinfo 读出来 |
⚠️ 易错点:方向别搞反(我在此处连错三次)
❌ 错:T 是 D 或 D 的派生类 (把上位下位弄反了)
✅ 对:D 是 T 或 T 的派生类锚定方法:动态类型 = 具体的那个(继承链下位);目标类型 = 泛化的那个(上位)。 问的是「具体的这个,能装进那个泛化的框里吗」。
套本题(D = Derived):
| 目标 T | 正确判断 | 结果 | 方向搞反会得出 |
|---|---|---|---|
Derived | D 是 T?是(相等) | ✅ | 也是 ✅ |
Base | D 是 Base 的派生类?是 | ✅ | ❌ 错答成失败 |
Other | D 是 Other 的派生类?不是 | ❌ | 也是 ❌ |
中间那行就是分水岭:对象 Derived 转 Base 是成功的。因为 Base 是 Derived 的基类,不是派生类——按错方向会说成失败。
不变量:对象的静态类型永远"比动态类型更泛"或相同,绝不会更具体。
Base ← 静态类型可以停在这(更泛)
|
Derived ← 也可以停在这(此时 static == dynamic)
|
MostDerived ← ❌ 不能停在这(比动态类型更具体)
dynamic_cast让静态类型沿继承链向动态类型"靠近",但永远不能越过它。相等只是"恰好走到那一格"的特例,不是定义。
一句话背这个:拿「对象的动态类型」去对「目标类型」问一句:你是我的基类(或就是我)吗?
两个反例说明"改类型"这个说法为什么错:
- 转基类也成功——
dynamic_cast<Base*>(p),动态类型本来就在 Base 支上,谈不上"改" - 多继承下地址真的会变——实测第二基类差
0x10,转回C*又还原。说明它还在算指针偏移量,不只是"改标签"
| 概念 | 是什么 | dynamic_cast 动它吗 |
|---|---|---|
| 静态类型 | 编译器眼里的类型,决定能调哪些成员 | ✅ 动——这就是 cast 的成果 |
| 动态类型 | 对象真实身份,由 vptr 指向的 typeinfo 体现 | ❌ 永不动——它本来就是事实 |
与 static_cast 的关系一下清楚了:
| 改写静态类型 | 运行期核对 | 算偏移 | |
|---|---|---|---|
static_cast | ✅ | ❌ 跳过核对 | ✅ |
dynamic_cast | ✅ | ✅ 核对 | ✅ |
两者干的"活"一模一样,
dynamic_cast只是多做一道核对。 这正好印证 Q3 实测:static_cast<Other*>(pb)返回非空地址、读出垃圾值——因为它跳过核对照样算偏移。
推论:失败时对象根本没被碰过。Other* po = dynamic_cast<Other*>(pb) 失败后,pb 依然完好指向那个 Derived 对象。失败只是拒绝交给你一个答案,不是去破坏什么。
Q2. 基类没有虚函数会怎样?
标准答案(实测):dynamic_cast 和 typeid 行为完全不同
| 用法 | 没有虚函数时 |
|---|---|
dynamic_cast | ❌ 编译错误:source type is not polymorphic(指针版、引用版都拒绝) |
typeid | ⚠️ 编译通过、静静给出错误答案 |
$ ./novirt3
4Base ← 对象实际是 Derived,却报 Base!
相同? 0 ← typeid(*pb) == typeid(Derived) 是 falsetypeid 不是编译保护的。基类没有虚函数时,它退化成静态类型,返回 Base——你拿到一个看起来正常、实际是错的答案,没有任何报错。
这就是「为什么要求基类有多态」的答案
RTTI 信息本身就挂在虚表上——就是问链三扒出来的
+0x08 &typeinfo(Derived)那个槽位。没虚表 → 没 typeinfo → 无从判断。dynamic_cast报错、typeid退化,都是同一个原因。
底层原理
dynamic_cast<Derived*>(pb)
└─ 取 pb 的 vptr → 找到 vtable → 读 +0x08 → 拿到 &typeinfo(Derived) ← 真实动态类型
└─ 与目标类型 typeinfo 比对(考虑继承关系,不是单纯相等)
├─ 兼容 → 调整指针偏移,返回
└─ 不兼容 → 指针返回 nullptr / 引用抛 bad_cast
typeid走同一个入口,但只做相等判断,不做继承关系推导。
Q3. static_cast vs dynamic_cast
我的回答:dynamic_cast 慢,因为有运行时检查;static_cast 没有运行时检查,没有保护,不会报错;在非虚函数情况下用 static_cast。
点评:✅ 前两条主干全对。❌ 第三条说反了,且漏一个关键点。
① 慢多少、慢在哪(补量级)
- 比
static_cast慢几十到几百倍(static_cast编译期算完偏移,运行期只是加法甚至零开销) - 慢在要走 vptr → vtable →
+0x08取 typeinfo → 遍历继承链比对;多继承下可能多次跳转 - 无法内联——结果是运行期才知道,编译器优化空间被封死
② static_cast 没保护,实测比"不报错"更狠
cpp
Base* pb = new Derived();
Other* po = static_cast<Other*>(pb); // Derived 对象硬当 Other 用
po->y; // 输出 42!返回非空有效地址,照样读出一个值——读的是 Derived 对象的内存,被按 Other 布局解释。不崩、不报错、给一个看起来合理的垃圾值。
static_cast<Other*>(pb) → 0x...b0 (非空)
dynamic_cast<Other*>(pb) → (nil) (正确识别失败)"静默的错误答案"比崩溃更危险——崩溃至少你知道出事了。
③ 说反的地方:选 static_cast 的理由不是"非虚函数"
真正理由是:你(程序员)已经知道动态类型是什么,且能保证它是对的。
判断标准不是"有没有虚函数",而是**"编译器知不知道、以及你确不确定"**:
| 场景 | 用什么 | 为什么 |
|---|---|---|
你确定它就是 Derived(比如刚从 Derived 转上去) | static_cast | 编译期算偏移,零开销 |
| 你不确定,要靠运行期确认 | dynamic_cast | 必须有检查 |
| 基类没有虚函数 | 只能 static_cast | dynamic_cast 根本编译不过(source type is not polymorphic) |
第三行才是"非虚函数"与 static_cast 的正确关系——不是"该用它",是"只能用它的无奈"。而且没虚函数时你连"我转错了"都无从检查。
④ static_cast 的两道编译期防护(都不检查动态类型)
- 不相关的类型之间不能转(如
int*→double*报错) - 它不检查"这个对象实际是什么"——这正是实测暴露的
一句话:
static_cast是"我说了算",dynamic_cast是"让运行时核实"。
追问:实际项目里怎么选?
默认
static_cast,只在"真的不确定动态类型"时才用dynamic_cast。典型场景:类型擦除/异构容器里拿回具体类型(如
Any里存了Base*,取出来不知道是哪个派生类)。如果设计上能靠虚函数分派解决,就别做类型判断——那本身就是设计味道(该用多态的地方用了 RTTI,说明基类接口设计不全)。
附:问链四实测证据
环境:g++ -std=c++17 -O0
① dynamic_cast / typeid 全用例输出
① pd = 0x599ca24412b0 (非空)
② po = (nil) (nullptr)
pd->x = 42
③ rd.x = 42 (成功)
④ 抛 bad_cast: std::bad_cast (失败)
⑤ pn = (nil) (nullptr)
--- typeid ---
typeid(*pb).name() = 7Derived
typeid(rb).name() = 7Derived
typeid(*pb) == typeid(Derived) : 1
typeid(*nullp) → 抛 bad_typeid② 无虚函数时的分叉
dynamic_cast 指针版 → error: source type is not polymorphic
dynamic_cast 引用版 → error: source type is not polymorphic
typeid → 编译通过,输出 "4Base"(静态类型),比较为 false
static_cast<Other*>(pb) → 非空地址;po->y 读出 42(垃圾值)
dynamic_cast<Other*>(pb) → (nil)复现方式
bash
cat > rtti.cpp <<'EOF'
struct Base { virtual ~Base() {} };
struct Derived : Base { int x = 42; };
struct Other : Base { int y = 99; };
int main() {
Base* pb = new Derived();
Base& rb = *pb;
Derived* pd = dynamic_cast<Derived*>(pb);
Other* po = dynamic_cast<Other*>(pb);
try { Derived& rd = dynamic_cast<Derived&>(rb); } catch (const std::bad_cast&) {}
try { Other& ro = dynamic_cast<Other&>(rb); } catch (const std::bad_cast&) {}
Derived* pn = dynamic_cast<Derived*>((Base*)nullptr);
}
EOF
g++ -std=c++17 -O0 rtti.cpp -o rtti && ./rtti下次待练清单(按优先级排序)
状态标记:☐ 未练 / ◐ 已部分 / ☑ 已通关。标 🔥 为高频必练。
一、虚函数/多态 剩余弹药
| # | 考点 | 典型追问链 | 状态 |
|---|---|---|---|
| 1 | 🔥 虚析构:为什么基类析构必须 virtual? | ✅ 已练(问链三 Q1–Q4)。掌握:D0/D1/D2 三版本、调用链次序、显式析构走 D1 不释放内存、virtual 的继承性 | ☑ |
| 2 | 🔥 RTTI:typeid vs dynamic_cast | ✅ 已练(问链四 Q1–Q3)。掌握:指针 nullptr / 引用 bad_cast、空指针特例、无虚函数时 dynamic_cast 编译错误 vs typeid 静默退化、RTTI 挂在虚表 +0x08、static_cast 静默垃圾值 | ☑ |
| 3 | 🔥 多继承布局:C : A, B(两基类各有虚函数) | 对象里几个 vptr?sizeof 手算(A=16 → C=40)?多继承下 this 指针偏移调整?虚函数表不止一张怎么保证调用正确? | ☐ |
| 4 | 虚继承与菱形继承 | 普通菱形继承成员有几份?vbptr 放哪?虚基类为什么由最派生类构造?构造顺序? | ☐ |
| 5 | 虚函数为什么不能是模板 | vtable 大小需编译期确定 vs 模板实例化时机?类型擦除三层架构(Any/Base/Derive<T>,结合线程池)? | ☐ |
| 6 | 静态多态 vs 动态多态 | 各自实现方式/绑定时机/性能差异? | ☐ |
| 7 | 多态的代价 + 虚函数能否内联 | 空间(对象多 vptr)/时间(查表、难内联)?什么条件下虚调用可以被编译器去虚化(devirtualize)? | ☐ |
| 8 | override/final 细节 | 签名不符时编译器报什么错?final 用在类与函数上? | ☐ |
二、继承板块
| # | 考点 | 状态 |
|---|---|---|
| 9 | 🔥 重载 vs 重写 vs 隐藏(含同名不同参隐藏陷阱、using Base::f) | ☐ |
| 10 | 三种继承方式对成员访问级别的影响 | ☐ |
| 11 | 🔥 菱形继承问题与虚继承解决方案 | ☐(与 #4 联动) |
| 12 | 继承 vs 组合(何时用哪个;组合优于继承) | ☐ |
三、拷贝控制与资源管理
| # | 考点 | 状态 |
|---|---|---|
| 13 | 🔥 深拷贝 vs 浅拷贝(何时必须深拷贝;默认拷贝构造是浅拷贝) | ☐ |
| 14 | 🔥 移动语义:右值引用、std::move 本质、移动构造/赋值写法、为什么 noexcept | ☐ |
| 15 | 🔥 Rule of Three / Five / Zero:编译器自动生成规则、三种所有权模式 | ☐ |
| 16 | operator= 陷阱:自赋值、copy-and-swap 为什么异常安全 | ☐ |
| 17 | 🔥 RAII:三要素、为何可靠(语言机制保证)、锁守卫手写、与 GC 对比 | ☐ |
| 18 | 线程池四连 delete(为什么拷贝移动全禁;移动后 this 失效崩溃) | ☐ |
四、内存布局与计算(笔试题常客)
| # | 考点 | 状态 |
|---|---|---|
| 19 | 🔥 内存对齐:规则、sizeof 手算、成员按大小降序排列省空间 | ☐ |
| 20 | 🔥 类大小综合计算:空类=1/EBO、单继承+虚函数、多继承 N×vptr、虚继承+vbptr | ☐ |
五、类与对象基础
| # | 考点 | 状态 |
|---|---|---|
| 21 | struct vs class;this 指针本质 | ☐ |
| 22 | 🔥 初始化列表:为什么推荐、哪三类成员必须用、初始化顺序只由声明顺序决定(经典陷阱题) | ☐ |
| 23 | explicit、= default vs {}(Trivial 性)、编译器默认生成的成员函数 | ☐ |
六、综合实战题(任意一次练习末尾)
| # | 考点 | 状态 |
|---|---|---|
| 24 | 给定类定义手算 sizeof(成员顺序/虚函数/继承混合) | ☐ |
| 25 | 判断程序输出(构造析构顺序 + 虚调用 + 切割混合场景) | ☐ |
| 26 | 设计题:手写 MyString(Rule of Five + copy-and-swap) | ☐ |