Skip to content

虚函数与多态 —— 深度复盘 ​

日期:2026-09-09 主题:C++ 面向对象 · 虚函数底层机制 / 对象切割 / 抽象类 关联笔记:面向对象 · 多态格式说明:每题含「题目 → 我的回答(原话归纳)→ 点评(✅ 答对 / ⚠️ 不完整 / ❌ 答错)→ 标准答案/补充细节」


问链一:虚函数底层机制 ​

Q1. p->f() 从编译到运行,底层发生了什么? ​

题目:Base 含虚函数 virtual void f(),Derived 重写;执行 Base* p = new Derived(); p->f();

我的回答:p 是基类指针指向派生类对象;通过对象 vptr 找到该类 vtable 再调用;虚表编译期生成,但动态类型运行期才确定。

点评:✅ 方向正确(查表分派、静态/动态类型、编译期建表)。⚠️ 缺三个关键细节:

  1. vptr 位置:通常位于对象布局最开头,调用 = 取内存首地址 → 读前 8 字节得 vptr → 解引用得 vtable。
  2. vtable 存什么:不是"存虚函数",而是虚函数地址数组——被重写函数的槽位被覆盖为 Derived::f;未被重写的虚函数槽位仍指向基类版本。查找靠编译期写死的偏移量,不是运行时找名字。
  3. 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 个析构函数:

版本符号职责
D2base object destructor只析构当前一层子对象,供派生类析构内部调用
D1complete object destructor析构完整对象(派生成员 + 链式调基类析构),不释放内存
D0deleting destructorD1 + 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, …)     ← ★释放:对象【自身】占的内存

两个要点

  1. 基类析构是硬性链式调用,不再虚分派。派生类销毁完了必然轮到基类,没有"选择"的余地,自然不需要查表——这与问链二 Q4②「纯虚析构为什么必须在类外给实现」是同一个机制:链接器需要 ~Base() 的真实地址
  2. 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就是它✅ 成功
OtherDerived 继承自 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正确判断结果方向搞反会得出
DerivedD 是 T?是(相等)✅也是 ✅
BaseD 是 Base 的派生类?是✅❌ 错答成失败
OtherD 是 Other 的派生类?不是❌也是 ❌

中间那行就是分水岭:对象 Derived 转 Base 是成功的。因为 Base 是 Derived 的基类,不是派生类——按错方向会说成失败。

不变量:对象的静态类型永远"比动态类型更泛"或相同,绝不会更具体。

        Base          ← 静态类型可以停在这(更泛)
         |
      Derived         ← 也可以停在这(此时 static == dynamic)
         |
    MostDerived       ← ❌ 不能停在这(比动态类型更具体)

dynamic_cast 让静态类型沿继承链向动态类型"靠近",但永远不能越过它。相等只是"恰好走到那一格"的特例,不是定义。

一句话背这个:拿「对象的动态类型」去对「目标类型」问一句:你是我的基类(或就是我)吗?

两个反例说明"改类型"这个说法为什么错:

  1. 转基类也成功——dynamic_cast<Base*>(p),动态类型本来就在 Base 支上,谈不上"改"
  2. 多继承下地址真的会变——实测第二基类差 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) 是 false

typeid 不是编译保护的。基类没有虚函数时,它退化成静态类型,返回 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_castdynamic_cast 根本编译不过(source type is not polymorphic)

第三行才是"非虚函数"与 static_cast 的正确关系——不是"该用它",是"只能用它的无奈"。而且没虚函数时你连"我转错了"都无从检查。

④ static_cast 的两道编译期防护(都不检查动态类型)

  1. 不相关的类型之间不能转(如 int* → double* 报错)
  2. 它不检查"这个对象实际是什么"——这正是实测暴露的

一句话: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)?☐
8override/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:编译器自动生成规则、三种所有权模式☐
16operator= 陷阱:自赋值、copy-and-swap 为什么异常安全☐
17🔥 RAII:三要素、为何可靠(语言机制保证)、锁守卫手写、与 GC 对比☐
18线程池四连 delete(为什么拷贝移动全禁;移动后 this 失效崩溃)☐

四、内存布局与计算(笔试题常客) ​

#考点状态
19🔥 内存对齐:规则、sizeof 手算、成员按大小降序排列省空间☐
20🔥 类大小综合计算:空类=1/EBO、单继承+虚函数、多继承 N×vptr、虚继承+vbptr☐

五、类与对象基础 ​

#考点状态
21struct vs class;this 指针本质☐
22🔥 初始化列表:为什么推荐、哪三类成员必须用、初始化顺序只由声明顺序决定(经典陷阱题)☐
23explicit、= default vs {}(Trivial 性)、编译器默认生成的成员函数☐

六、综合实战题(任意一次练习末尾) ​

#考点状态
24给定类定义手算 sizeof(成员顺序/虚函数/继承混合)☐
25判断程序输出(构造析构顺序 + 虚调用 + 切割混合场景)☐
26设计题:手写 MyString(Rule of Five + copy-and-swap)☐