跳转到内容

17 · 我的疑问与答疑(复习用)

用途:把我问过的每一个知识疑问集中记在这里,复习时先看「一句话结论」,卡住的再点进对应章节看详细。 追加方式:直接问我,我会把新问题补到对应章节下面,并在最上面的总表加一行。 说明:只记 C++ 知识类疑问;界面/站点/工具类需求不记在这里。

# 疑问 出处 一句话结论
1 不写 override 会报错吗 05 §4.1 不会;不写也能重写。写了 override 但找不到可重写函数才报错
2 虚函数能内联吗?devirtualization 是什么 05 §4.2 函数体能内联;通过指针/引用调用无法内联。去虚拟化 = 把间接调用改成直接调用
3 抽象类不能实例化,那基类实现纯虚函数还有什么用 05 §4.3 纯虚 = “必须重写”,不是“没有实现”;用 Base::f() 显式调用
4 子类析构要写 override 吗 05 §5 不需要但推荐;主要价值是基类忘写 virtual 时直接编译报错
5 虚继承整体不懂 05 §6.3 ①一份共享子对象,由最派生类构造 ②偏移不固定→运行期查表 ③放在对象末尾
6 什么是“热路径”?dynamic_cast 少用是因为慢吗 05 §7 热路径 = 执行最频繁的代码;少用不只是慢,更是“类型判断散落=设计在恶化”
7 多继承时 vptr 都排在对象头部吗 05 §8 Q2-补 不准确:vptr 是它所在子对象的第一项,不是整个对象的第一项
8 空基类优化(EBO)是什么 05 §8 Q11 空类当基类时那 1 个占位字节可被合并掉;当成员不能
9 final 的基类可以被虚继承吗 05 §4.1 说反了:class D final 是禁止 D 被继承,所以继承它(含虚继承)直接编译错误
10 多个 vptr 一般不是紧挨着的对吗 05 §8 Q2-补 对。每个子对象以自己 vptr 打头,后面跟着自己的成员,所以被隔开
11 (void*)pa != (void*)pb 还是没懂 05 §8 Q2-补 pb 指向同一个对象的中间(+16);pa == pb 甚至不能编译
12 push_back vs emplace_back 的区别 06 §2.3 emplace_back 转发参数原地构造,省临时对象 + 一次移动/拷贝;但不总是更好

结论:不会。

  • 不写 override:编译器按签名去基类找匹配,匹配上就是重写,行为完全一样。
  • 写了 override 但基类里找不到可重写的函数:编译报错(报错的是 override 这个说明符本身)。

它的真正价值:把“以为重写了、其实是名字隐藏”这类静默 bug 提前到编译期。

struct D : Base {
void f(double); // 想重写 virtual void f(int)
};
// 不写 override:编译通过,但基类 f 被隐藏,多态悄悄失效(最难查的 bug)
// 写了 override:立刻报"没有可重写的成员函数"

顺带记牢:重写的签名必须完全相同(参数、const、引用限定符、返回类型),返回类型只能是相同或协变。

详见 05 章 §4.1


2 · 虚函数能是内联的吗?devirtualization 是什么?

Section titled “2 · 虚函数能是内联的吗?devirtualization 是什么?”

结论:函数体可以被内联;但“通过基类指针/引用调用”这一次调用无法内联——编译期不知道会调到哪个版本。

去虚拟化(devirtualization) = 编译器把“查虚表的间接调用”改写成“直接调用某个确定函数”,改写之后这次调用才谈得上内联。

触发场景(记这 5 条):

  1. 直接对对象调用:Dog d; d.speak();
  2. 类型是 final 类,或函数是 final
  3. 构造/析构函数内部(动态类型已知)
  4. 显式类名限定:d.Animal::speak()
  5. LTO 全程序优化(链接期看到全部派生类)

概念澄清:inline 关键字对虚函数没有意义——“内联”是指把函数体展开到调用点,和 inline 关键字无关。

详见 05 章 §4.2


3 · 抽象类不能实例化,那基类实现纯虚函数还有什么用?

Section titled “3 · 抽象类不能实例化,那基类实现纯虚函数还有什么用?”

结论:纯虚函数 = “必须重写”,不是“没有实现”。基类的实现只能通过显式限定调用到达。

三种用得到基类实现的场合:

  1. 派生类里显式调用:void f() override { Base::f(); } —— 语法上点名函数,静态绑定、不查虚表
  2. 基类其他函数内部调用(模板方法模式):基类定骨架、派生类填细节
  3. 纯虚析构必须有实现:virtual ~Base() = 0; 必须写 Base::~Base() {},否则派生类析构时链接错误

陷阱:在基类构造/析构函数里调 f()(不加限定)→ 仍然是未定义行为(此时基类版本是纯虚的,多数实现调 __cxa_pure_virtual 直接终止)。

详见 05 章 §4.3


4 · 子类析构函数需要写 override 吗?

Section titled “4 · 子类析构函数需要写 override 吗?”

结论:不需要,但推荐写。

  • 基类析构是 virtual 时,派生类析构自动成为重写(写不写 virtual/override 都一样)。
  • 析构函数没有参数、没有返回类型,所以“签名写错”的空间几乎为零 → override 的主要价值是:基类忘了写 virtual 时,编译器直接报 no suitable member to override,顺手把“delete 基类指针导致资源泄漏”那个 UB 也拦住了。
  • 顺带记:析构函数默认 noexcept,里面抛异常会 std::terminate。

详见 05 章 §5


5 · 虚继承整体不懂 —— 三条机制

Section titled “5 · 虚继承整体不懂 —— 三条机制”

结论:virtual public A 的意思是“A 这个基类子对象,整个对象里最多只留一份,由最派生的类统一负责”。

  1. 谁构造:构造 D 的顺序是 A → B → C → D,A 只构造一次,由 D 负责。B、C 构造函数里写的 A(1) 会被忽略(这是虚继承最反直觉的地方)。所以虚基类最好提供默认构造函数。
  2. 为什么访问要“多一次间接”:同一个 B* 可能指向“独立的 B”,也可能指向“D 里的那个 B”,两种情况 A 的偏移不同 → 不能用编译期固定偏移,必须运行期查 vbase 偏移表(Itanium ABI 放在虚表 -3 槽)。代价 = 多一次内存访问。
  3. 放哪:虚基类子对象统一放在对象末尾,所以离其他 vptr 更远。

反直觉但重要:虚继承反而更占内存(sizeof(D) 从 8 变 24),它买的是“语义正确(无二义性 + 状态唯一)”,不是省内存。

详见 05 章 §6.3


6 · 什么是“热路径”?dynamic_cast 少用是因为开销大吗?

Section titled “6 · 什么是“热路径”?dynamic_cast 少用是因为开销大吗?”

结论:热路径 = 程序里执行最频繁的那条路径(游戏里:每帧 Tick、每帧遍历实体、渲染提交、碰撞宽相;一秒 60~144 次 × 每次几千个对象)。反面是冷路径(初始化、报错处理)。

dynamic_cast 在热路径少用,不只是因为慢:

  1. 它是运行期库调用,要遍历继承图判断类型,无法内联、无法被编译期优化;
  2. 循环里对每个对象做一次,开销乘以对象数量,还会打断流水线、增加分支预测失败;
  3. 更本质:dynamic_cast 用得越多,说明类型判断散落在业务代码里,设计上通常在往反模式走(该用虚函数/visitor/组件查询,如 UE 的 Cast<>、ECS 的组件表)。

对比记忆:虚函数调用也是一次运行期跳转,但它有去虚拟化、内联的机会;dynamic_cast 连这个机会都没有。

详见 05 章 §7


7 · 多继承时 vptr 都排在对象头部吗?

Section titled “7 · 多继承时 vptr 都排在对象头部吗?”

结论:不准确。准确说法是:vptr 是“它所在子对象的第一项”,不是“整个对象的第一项”。

  • 主基类(继承列表里第一个动态类)与派生类共享 vptr,在偏移 0;
  • 每个次基类另起一个完整子对象(按 dsize 对齐),该子对象的第一个字段才是它自己的 vptr,后面紧跟它自己的成员变量;
  • 派生类自己的成员放在所有基类子对象之后。

所以“多个 vptr 挤在头部”只在各基类都没有数据成员时成立。

详见 05 章 §8 Q2-补


结论:C++ 里任何对象/子对象都必须有唯一地址,所以空类 sizeof 是 1(不是 0)。但当空类作为基类时,这 1 个字节可以合并进派生类的填充字节里:

struct Empty {}; // sizeof == 1
struct WithMember { Empty e; int x; }; // sizeof == 8(成员 empty 占 1 + 3 填充)
struct WithBase : Empty { int x; }; // sizeof == 4(空基类被优化掉)

三条边界:

  1. 作为成员不能优化(Empty e; 仍占 1 字节),C++20 的 [[no_unique_address]] 才补上这条路;
  2. 两个同类型空基类不能共用地址,必有一个至少占 1 字节;
  3. 不同类型的空基类可以重叠在同一偏移。

用途:std::vector<T, Alloc> 让分配器当基类,无状态分配器不额外占空间;游戏引擎 ECS/组件管理器、std::function 的小对象缓冲也靠它。

详见 05 章 §8 Q11


9 · final 的基类可以被虚继承吗?

Section titled “9 · final 的基类可以被虚继承吗?”

结论:这里说反了 —— class D final : public B {} 的含义是“D 不能被继承”(D 是最终类),不是“D 不能重写别人”。所以任何类对它做普通继承或虚继承都编译错误。

对比:

  • class D final → 禁止继承 D(副作用:编译器能对 D 去虚拟化)
  • void f() final → 禁止该虚函数被更下层重写

所以“接口类”绝不能标 final(标了就没法被实现了);该标 final 的是最底层的叶子实现类。

详见 05 章 §4.1


10 · 多个 vptr 一般不是紧挨着的对吗?

Section titled “10 · 多个 vptr 一般不是紧挨着的对吗?”

结论:对。因为 vptr 是“子对象的第一个字段”,而每个子对象后面还跟着它自己的成员变量。

class A { public: virtual void fa(); int a; };
class B { public: virtual void fb(); int b; };
class C : public A, public B { public: int cc; };

MSVC 实测布局(cl /d1 reportAllClassLayout):

偏移 内容
+0 A 的 vptr
+8 A::a
+12 padding 4B(把 B 子对象对齐到 8)
+16 B 的 vptr ← 不在头部,被 A 的成员隔开了
+24 B::b
+28 C::cc
+32 padding → sizeof(C) = 40

两个 vptr 之间隔着 16 字节。只有次基类没有数据成员(纯虚接口)时,两个 vptr 才真正相邻 —— 实测 sizeof(Impl) = 24、ia → ib 调整 8。

详见 05 章 §8 Q2-补;想自己验证用 html/_tools/vptr_probe.cpp


核心一句:pb 不是指向另一个对象,而是指向同一个 C 对象的中间(+16)。

C 对象在内存里是一整块:A 的部分在前、B 的部分在后。“子对象”就是这一整块里的各个区段,所以一个 C 对象同时有三个合法但数值不同的指针:

C 对象
+0 ┌──────────────┐ ← pc 指向这里
│ A 的 vptr │ ← pa 也指向这里(A 在偏移 0)
+8 │ A::a │
+16 │ B 的 vptr │ ← pb 指向这里(同一个对象的中间!)
...

为什么必须 +16:B 的虚函数要用 B 自己的 vptr 查 B 的虚表;pb->b 也要以 B 子对象为基准。不调偏移就会读到 A 的 vptr → 调错函数。所以这个加法是正确性的一部分。

三种看起来矛盾的结果(实测):

表达式 结果 为什么
(void*)pa == (void*)pb false(0) 转 void* 就是比数值,两者差 16
(void*)pa == (void*)pc true(1) A 在偏移 0,转换不调整
pa == pb 编译错误(MSVC C2446) A* 与 B* 在不同继承分支、互不相关,语言层面就没有这个比较
static_cast<C*>(pa) == static_cast<C*>(pb) true(1) 想比较“是否同一对象”,要先各自转成同一个类型再比

口诀:转换看数值(会加/减偏移),比较要同类型(先显式转成同一个指针类型)。

工程结论:跨继承分支一律用 static_cast/dynamic_cast,绝不手算偏移(布局是实现定义的)。

详见 05 章 §8 Q2-补


12 · push_back 和 emplace_back 的区别?

Section titled “12 · push_back 和 emplace_back 的区别?”

结论:push_back 收的是已经构造好的对象;emplace_back 收的是构造这个对象所需的参数,直接在容器内存上原地构造,省掉“临时对象 + 一次移动/拷贝”。

void push_back(const T&); // 拷贝
void push_back(T&&); // 移动
template <class... Args>
reference emplace_back(Args&&... args); // 完美转发 → 原地构造(C++17 起返回新元素引用)
v.push_back(Point(1, 2)); // 构造临时 → 移动进容器 → 析构临时(1 构造 + 1 移动 + 1 析构)
v.emplace_back(1, 2); // 直接在容器内存上构造(只有 1 次构造)

但 emplace 不总是更好(面试加分点):

  1. 参数已是现成对象 → 没区别:v.emplace_back(p) 也是拷贝构造一次;
  2. 花括号列表推不出类型(经典坑):
    std::vector<std::vector<int>> vv;
    vv.push_back({1,2,3}); // ✅
    vv.emplace_back({1,2,3}); // ❌ 编译错误:Args 无法从 {1,2,3} 推导
    vv.emplace_back(std::initializer_list<int>{1,2,3}); // ✅ 必须显式写类型
  3. 能调用 explicit 构造 = 双刃剑:
    std::vector<std::unique_ptr<int>> v;
    v.push_back(new int(5)); // ❌ 编译错误(explicit)—— 编译器救了你一次
    v.emplace_back(new int(5)); // ✅ 合法,但中途抛异常会泄漏裸指针

选择建议:T 构造/移动代价大(大结构体、string)用 emplace_back;平凡类型(int/double)差别可忽略;参数已是对象、或要传 {...} 时用 push_back。

别答漏的两点:两者都是尾部插入、都摊还 O(1)、扩容时都会让全部迭代器/指针/引用失效。

详见 06 章 §2.3