C++ 对象内存布局:从 sizeof 到虚函数表
1. 从一个 sizeof 问题开始
成员一样,大小却不一样
先猜,再看答案
struct A { char c; int i; char d; };
struct B { int i; char c; char d; };
A 和 B 都是一个 int 加两个 char,成员大小加起来是 6 字节。它们的 sizeof 是多少?两者会相等吗?
先在纸上写下你的答案,再往下读。
展开答案
sizeof(A) 是 12,sizeof(B) 是 8。成员完全一样,只是顺序不同,大小就差了一半。
如果你猜的是 6,或者猜两者相等,说明还缺一个模型:编译器摆放成员时,除了成员本身的大小,还要满足对齐要求。这正是本文第 2 节要讲的。
本文的位置与阅读方式
这是现代 C++ 长期学习计划中“对象模型”的第一篇。前面的《C++ 类型推导》和《C++ 对象初始化》讨论的是“一个对象是什么类型、怎样被创建”,这一篇往下走一层:对象在内存里长什么样。
阅读路线是:普通成员的对齐与填充 → 空类 → 加入虚函数 → 单继承 → 多继承与 this 调整 → 虚析构函数 → 虚调用的汇编。每一步都先猜,再用编译器输出核对。
布局由谁决定?先交代实验环境
标准只规定一部分,剩下的是 ABI
C++ 标准规定了一些约束,比如同一访问级别的非静态成员按声明顺序排列、地址递增。但成员之间留多少空隙、虚函数表放在哪里,标准都没有规定,这些由 ABI(Application Binary Interface,二进制接口约定)决定。
Linux 和 macOS 上的 GCC、Clang 都遵循 Itanium C++ ABI,名字来自最早的 Itanium 平台,但如今 x86-64 和 ARM64 上的主流编译器都在用它。Windows 上的 MSVC 用的是另一套 ABI,本文的结论不能直接照搬过去。
本文的实验环境
- 编译器:Apple clang 21,
-std=c++20。 - 机器:Apple M5 Pro(arm64),macOS。
- 汇编:用
-target x86_64-linux-gnu生成 x86-64 汇编,因为面试和多数资料讨论的是 x86-64。
本文所有布局输出都在 arm64 macOS 和 -target x86_64-linux-gnu 两个目标上各跑了一遍,结果完全一致。
让编译器把布局打印出来
clang++ -std=c++20 -fsyntax-only -Xclang -fdump-record-layouts layout.cpp-fdump-record-layouts 是 Clang 前端的选项,所以要用 -Xclang 传进去。它只会打印被实际用到的类型,所以实验文件里要为每个类型定义一个变量,比如 A a; B b;。
输出的每一行左边是偏移量(字节),末尾是 sizeof 和 align:
0 | struct A
0 | char c
4 | int i
8 | char d
| [sizeof=12, dsize=12, align=4,
| nvsize=12, nvalign=4]dsize 和 nvsize 暂时可以忽略,第 5 节会用到 dsize。GCC 没有完全相同的选项,可以用 -fdump-lang-class 得到类似信息。
2. 对齐与填充
每个成员都有自己的对齐要求
从输出里读出规则
把 A 和 B 的输出并排摘录(省略了 dsize 等字段):
0 | struct A 0 | struct B
0 | char c 0 | int i
4 | int i 4 | char c
8 | char d 5 | char d
| [sizeof=12, align=4] | [sizeof=8, align=4]A 里,c 只占 1 字节,i 却从偏移 4 开始,中间空出了 3 字节。原因是 int 的对齐要求是 4:它的地址必须是 4 的倍数。编译器在 c 后面插入的这 3 个字节,叫填充(padding)。
可以用 alignof 查对齐要求。在这个环境里,alignof(char) 是 1,alignof(int) 是 4,alignof(double) 是 8。
末尾为什么也要补
A 的最后一个成员 d 放在偏移 8,占 1 字节,到 9 就结束了,可 sizeof(A) 是 12。末尾这 3 个字节同样是填充。
原因要从数组里看:A arr[2] 中,arr[1] 紧挨着 arr[0] 放,起始地址等于 &arr[0] 加上 sizeof(A)。arr[1].i 也必须 4 字节对齐,所以 sizeof(A) 必须是 alignof(A) 的整数倍。而结构体的对齐要求,取的是所有成员里最大的那个,这里是 4。
两条规则就能算出布局
- 每个成员放在“不小于当前位置、且是它对齐值整数倍”的第一个偏移上。
- 结构体的对齐值是成员对齐值的最大值,
sizeof向上补齐到它的整数倍。
用这两条规则算 B:i 在 0,c 在 4,d 在 5,数据到 6 结束,再补齐到 4 的倍数,得到 8。和编译器的输出一致。规则的标准依据见 C++20 草案 [basic.align]。
调整成员顺序,能省多少?
一个更明显的例子
struct C { char c; double x; int i; };
struct C2 { double x; int i; char c; };
0 | struct C 0 | struct C2
0 | char c 0 | double x
8 | double x 8 | int i
16 | int i 12 | char c
| [sizeof=24, align=8] | [sizeof=16, align=8]C 在 c 后面填了 7 字节,末尾又填了 4 字节,24 字节里有 11 字节是空的。按对齐值从大到小重新排列后,C2 只要 16 字节。
这个差别在单个对象上不明显,但一个装了一百万个元素的数组,就是 24 MB 和 16 MB 的区别。同样一条 cache line 能装下的对象数也会变多。
编译器为什么不自动重排?
既然重排能省空间,编译器为什么不替你做?
因为标准要求:同一访问级别的非静态成员,后声明的地址更高(见 C++20 草案 [class.mem])。很多代码依赖这个顺序,比如按字段顺序直接读写二进制文件、和 C 代码共享结构体定义。编译器擅自重排,这些代码就会坏掉。
所以成员顺序是你的决定。一个简单的经验是:按对齐值从大到小声明成员,填充通常最少。不过要先确认这个类型没有被用在依赖字段顺序的地方。
3. 空类:一个字节也不是白给的
sizeof(Empty) 为什么不是 0?
空类至少占 1 字节
struct Empty {};
0 | struct Empty (empty)
| [sizeof=1, dsize=1, align=1,Empty 没有任何成员,sizeof 却是 1。原因是 C++ 要求不同的对象有不同的地址。如果空类大小为 0,Empty arr[2] 里两个元素的地址就会相同,没法区分。
作为成员和作为基类,结果不同
struct D { Empty e; int i; }; // 空类作为成员
struct E : Empty { int i; }; // 空类作为基类
0 | struct D 0 | struct E
0 | struct Empty e (empty) 0 | struct Empty (base) (empty)
4 | int i 0 | int i
| [sizeof=8, align=4] | [sizeof=4, align=4]作为成员时,e 占了 1 字节,再加 3 字节填充,D 变成 8 字节。作为基类时,Empty 子对象和 i 共用偏移 0,E 只有 4 字节。这就是空基类优化(Empty Base Optimization,EBO):空的基类子对象可以不占空间。
标准库大量依赖这个优化。比如 std::unique_ptr 的默认删除器是一个空类,借助 EBO,unique_ptr 可以和裸指针一样大。
C++20 的 [[no_unique_address]]
如果不想为了省空间而改成继承,C++20 提供了属性 [[no_unique_address]]:
struct D2 { [[no_unique_address]] Empty e; int i; };
0 | struct D2
0 | struct Empty e (empty)
0 | int i
| [sizeof=4, align=4]e 仍然是成员,但允许和 i 共用地址,D2 和 E 一样只有 4 字节。规则见 C++20 草案 [dcl.attr.nouniqueaddr]。
alignas:主动要求更大的对齐
把对象撑到一条 cache line
struct alignas(64) F { int counter; };
0 | struct F
0 | int counter
| [sizeof=64, dsize=64, align=64,F 只有一个 int,但 alignas(64) 要求它按 64 字节对齐,sizeof 也就补齐到了 64。
这种写法常用来让两个被不同线程频繁修改的变量落在不同的 cache line 上,避免 false sharing:两个线程改的明明是不同变量,却因为在同一条 cache line 上而互相拖慢。这个问题会在后面讲并发与缓存时专门做实验。
64 不是通用答案
64 字节是常见 x86-64 处理器的 cache line 大小,但不是所有机器都这样。在本文的实验机器上:
sysctl -n hw.cachelinesize输出是 128。写死 64 在这台机器上并不足以隔开两个变量。
C++17 提供了 std::hardware_destructive_interference_size(在 <new> 中),表示编译器认为的“避免 false sharing 所需的最小间隔”。但它是编译期常量,不一定等于运行机器的实际值:在本文环境里打印它,得到的是 256,比实际的 128 还大。它能保证隔开,代价是多占空间。对性能敏感的代码,最好在目标机器上确认 cache line 大小后再决定。
4. 加入虚函数:对象里多了什么?
vptr:每个多态对象开头的那个指针
只多了一个 int,却多了 8 字节
struct Shape {
virtual ~Shape() = default;
virtual double area() const { return 0; }
int id = 0;
};
0 | struct Shape
0 | (Shape vtable pointer)
8 | int id
| [sizeof=16, dsize=12, align=8,Shape 只声明了一个 int,sizeof 却是 16。偏移 0 处多了一个 (Shape vtable pointer),通常叫 vptr,在 64 位平台上占 8 字节。id 只能排在它后面,最后再补齐到 8 的倍数。
只要一个类有虚函数(自己声明的或继承来的),它的每个对象就会带一个 vptr。注意是每个对象一个,而不是每个类一个。
vptr 指向哪里?
vptr 指向这个类的虚函数表(vtable)。vtable 每个类只有一份,存放在程序的只读数据区,所有 Shape 对象的 vptr 都指向它。
Clang 还可以打印 vtable 的内容:
clang++ -std=c++20 -c -o /dev/null -Xclang -fdump-vtable-layouts virt.cppVtable for 'Shape' (5 entries).
0 | offset_to_top (0)
1 | Shape RTTI
-- (Shape, 0) vtable address --
2 | Shape::~Shape() [complete]
3 | Shape::~Shape() [deleting]
4 | double Shape::area() const逐项看:
offset_to_top:从当前子对象回到完整对象开头要走多远。单继承时是 0,第 7 节多继承时才派上用场。RTTI:指向类型信息,typeid和dynamic_cast靠它工作。-- vtable address --这一行标出了 vptr 真正指向的位置:不是表的开头,而是第 2 项。前两项放在 vptr 指向位置的“前面”。- 两个析构函数:
[complete]只析构对象,[deleting]析构后再释放内存,供delete使用。虚析构函数在表里占两个槽位。 - 最后才是
area。
5. 单继承:共用一个 vptr
派生类的新虚函数加在哪里?
布局:基类在前,派生类成员在后
struct Circle : Shape {
double area() const override { return 3.14 * r * r; }
virtual void scale(double k) { r *= k; }
double r = 1;
};
0 | struct Circle
0 | struct Shape (primary base)
0 | (Shape vtable pointer)
8 | int id
16 | double r
| [sizeof=24, dsize=24, align=8,Circle 开头就是一个完整的 Shape 子对象,被标为 primary base(主基类)。Circle 没有自己的 vptr,而是和 Shape 共用偏移 0 的那一个。r 是 double,要 8 字节对齐,所以从 16 开始。
因为 Shape 子对象就在偏移 0,把 Circle* 转成 Shape* 时地址不变。这一点到多继承时就不成立了。
vtable:覆盖的替换,新增的追加
Vtable for 'Circle' (6 entries).
0 | offset_to_top (0)
1 | Circle RTTI
-- (Circle, 0) vtable address --
-- (Shape, 0) vtable address --
2 | Circle::~Circle() [complete]
3 | Circle::~Circle() [deleting]
4 | double Circle::area() const
5 | void Circle::scale(double)和 Shape 的表对照:
- 第 2–4 项的槽位顺序没变,内容换成了
Circle的版本。这就是覆盖:同一个槽位,换了函数。 - 新增的虚函数
scale追加在末尾第 5 项。
槽位顺序不变非常关键。拿着一个 Shape& 调用 area() 时,编译器只知道“去第 4 项取函数地址”,并不需要知道对象到底是 Shape 还是 Circle。
一个反直觉的细节:派生类成员可以塞进基类的填充里
先猜 Tagged 的大小
struct Tagged : Shape { int tag = 0; };
Shape 的 sizeof 是 16,Tagged 再加一个 int,直觉上是 16 + 4 = 20,再补齐到 24。实际输出是:
0 | struct Tagged
0 | struct Shape (primary base)
0 | (Shape vtable pointer)
8 | int id
12 | int tag
| [sizeof=16, dsize=16, align=8,tag 放在了偏移 12,正好是 Shape 末尾那 4 字节填充的位置,Tagged 依然只有 16 字节。
dsize 就是为这件事准备的
还记得 Shape 输出里的 dsize=12 吗?dsize 是“数据大小”,即去掉末尾填充后的大小。Itanium ABI 规定,派生类的成员可以从基类的 dsize 处开始放,而不是从 sizeof 处开始。
但不是所有基类都允许
这个复用有前提。下面两组只差一个用户提供的构造函数:
struct P { int x; char c; };
struct Q : P { char d; };
struct P2 { int x; char c; P2() {} };
struct Q2 : P2 { char d; };
0 | struct Q 0 | struct Q2
8 | char d 5 | char d
| [sizeof=12, dsize=9] | [sizeof=8, dsize=6]P 是一个简单的 C 风格结构体,Q 不能占用它的尾部填充,d 只能放在 8。P2 有用户提供的构造函数,Q2 就可以把 d 塞进偏移 5。
这样设计是为了兼容:C 风格结构体可能被 memcpy 整个复制,如果派生类的成员住在它的填充里,复制基类部分时就会把派生类的数据覆盖掉。具体条件见 Itanium ABI 中 POD for the purpose of layout 的定义。
基类没有 vptr 时,单继承也会改地址
只有派生类有虚函数
前面的 Shape 自己就有虚函数,所以 Circle 能和它共用偏移 0 的 vptr。换一种写法:基类是普通结构体,虚函数只出现在派生类里。
struct Base { int x = 0; };
struct Derived : Base {
virtual void f() {}
int y = 0;
};
0 | struct Derived
0 | (Derived vtable pointer)
8 | struct Base (base)
8 | int x
12 | int y
| [sizeof=16, dsize=16, align=8,这次 Base 没有被标成 primary base,而是被挤到了偏移 8。偏移 0 是 Derived 自己的 vptr。
原因在于 Itanium ABI 只会从多态类里挑选主基类。Shape 本身就有 vptr,派生类可以直接借用;Base 里没有 vptr 可借,Derived 只好自己在开头放一个,基类子对象就排到了后面。
地址真的差了 8
写个小程序,打印转换前后的地址:
#include <cstdio>
// Base、Derived 的定义同上
int main() {
Derived d;
Base* b = &d;
std::printf("&d = %p\n", static_cast<void*>(&d));
std::printf("b = %p\n", static_cast<void*>(b));
std::printf("b - &d = %td bytes\n",
reinterpret_cast<char*>(b) - reinterpret_cast<char*>(&d));
}
&d = 0x16f246110
b = 0x16f246118
b - &d = 8 bytes所以前面那句“Circle* 转成 Shape* 时地址不变”要加一个前提:基类本身是多态类。只要基类不在偏移 0,哪怕是单继承,指针转换也要加上偏移,指针版本也要判空,和第 7 节多继承的情况一样。
这个细节平时看不出来,直到有人对这个指针调用 delete。第 8 节会看到它的后果。
6. 多继承:两个 vptr,两个起点
一个对象,两个基类子对象
布局
struct Reader {
virtual ~Reader() = default;
virtual int read() { return 0; }
int rfd = 0;
};
struct Writer {
virtual ~Writer() = default;
virtual int write() { return 0; }
int wfd = 0;
};
struct Stream : Reader, Writer {
int read() override { return 1; }
int write() override { return 2; }
int buffered = 0;
};
0 | struct Stream
0 | struct Reader (primary base)
0 | (Reader vtable pointer)
8 | int rfd
16 | struct Writer (base)
16 | (Writer vtable pointer)
24 | int wfd
28 | int buffered
| [sizeof=32, dsize=32, align=8,几件事一起发生了:
- 第一个基类
Reader是主基类,放在偏移 0,Stream和它共用 vptr。 - 第二个基类
Writer放在偏移 16,带着自己的 vptr。所以Stream对象里有两个 vptr。 buffered放在 28,又是第 5 节讲的尾部填充复用:它住进了Writer子对象末尾的填充里。
同一个对象,两个不同的地址
既然 Writer 子对象在偏移 16,把 Stream* 转成 Writer* 时,地址就必须变。用一个小程序验证:
#include <cstdio>
// Reader、Writer、Stream 的定义同上
int main() {
Stream s;
Reader* r = &s;
Writer* w = &s;
std::printf("&s = %p\n", static_cast<void*>(&s));
std::printf("r = %p\n", static_cast<void*>(r));
std::printf("w = %p\n", static_cast<void*>(w));
std::printf("w - &s = %td bytes\n",
reinterpret_cast<char*>(w) - reinterpret_cast<char*>(&s));
std::printf("w == &s ? %d\n", w == &s);
std::printf("w->write() = %d\n", w->write());
}
用 clang++ -std=c++20 -O2 编译运行,一次的输出如下(具体地址每次运行都可能不同):
&s = 0x16f615e80
r = 0x16f615e80
w = 0x16f615e90
w - &s = 16 bytes
w == &s ? 1
w->write() = 2r 和 &s 相同,w 比 &s 大 16。但 w == &s 的结果是 1:比较时,编译器先把 &s 也转换成 Writer*(同样加 16),再比较,所以相等。
最后一行说明,通过 w 调用 write(),执行的确实是 Stream::write。问题来了:Stream::write 里访问 buffered,用的是相对 Stream 开头的偏移 28,可传进来的 this 是 w,指向偏移 16。它是怎么找到正确位置的?
第一个基类不是多态类:谁放在偏移 0?
先猜
把 Stream 的例子改一下:第一个基类是普通结构体,第二个基类才有虚函数。
struct A { int a = 0; }; // 非多态
struct B {
virtual ~B() = default;
virtual int f() { return 1; }
int b = 0;
};
struct D : A, B {
int f() override { return 2; }
int d = 0;
};
按声明顺序,A 应该在偏移 0,B 带着 vptr 排在后面。是这样吗?D* 转成 A* 和 B* 时,哪个要调整地址?
展开答案
0 | struct D
0 | struct B (primary base)
0 | (B vtable pointer)
8 | int b
12 | struct A (base)
12 | int a
16 | int d
| [sizeof=24, dsize=20, align=8,顺序被调换了:B 是主基类,放在偏移 0,A 被排到了偏移 12。打印转换后的地址也一样:
A* - &d = 12, B* - &d = 0, pb->f() = 2主基类只从多态基类里挑
第 5 节说过,Itanium ABI 只从多态类里挑选主基类,因为主基类的意义就是让派生类借用它的 vptr。多继承时,规则是:第一个非虚的多态基类当主基类,放在偏移 0;其余基类再按声明顺序往后排。A 没有 vptr 可借,虽然写在前面,也只能排到后面。
A 放在 12 而不是 16,是因为 B 的 dsize 是 12:A 住进了 B 末尾的填充里,下一张卡片会专门讲这件事。
调整的方向和直觉相反
D*转B*:地址不变。通过B*调用f()也不需要 thunk,B的 vptr 就是D的 vptr。D*转A*:地址加 12,指针版本还要判空。但A没有虚函数,所以除了转换时这一次加法,不存在 thunk 那种调用时的this调整。
所以判断要不要调整,看的不是声明顺序里谁排第一,而是哪个基类子对象在偏移 0:
- 不在偏移 0 的基类,转换时要加偏移,指针还要判空。
- 不在偏移 0、又被覆盖了虚函数的基类,通过它调用虚函数时还要经过 thunk。
多继承下,编译器怎样把对象压紧
空基类:不同类型可以叠在一起
第 3 节的空基类优化,放到多继承里会更明显:
struct E1 {};
struct E2 {};
struct M : E1, E2 { int x; }; // 两个不同的空基类
struct N : E1 { E1 e; int x; }; // 空基类和同类型的成员
0 | struct M 0 | struct N
0 | struct E1 (base) (empty) 0 | struct E1 (base) (empty)
0 | struct E2 (base) (empty) 1 | struct E1 e (empty)
0 | int x 4 | int x
| [sizeof=4, align=4] | [sizeof=8, align=4]M的两个空基类类型不同,都放在偏移 0,和x共用地址,M只有 4 字节。N的基类和成员e是同一个类型。C++ 要求同类型的两个不同对象地址不同,e只能挪到偏移 1,再补齐到x的对齐,N变成 8 字节。
std::tuple 这类大量依赖空基类优化的实现,要专门处理“同类型的空对象出现两次”的情况。
尾部填充:后一个基类也能住进去
第 5 节讲的是派生类成员住进基类的尾部填充。多继承时,后一个基类子对象也一样:
struct P { int x; char c; P() {} }; // dsize = 5
struct Q { char q; Q() {} };
struct R : P, Q { char r; };
0 | struct R
0 | struct P (base)
0 | int x
4 | char c
5 | struct Q (base)
5 | char q
6 | char r
| [sizeof=8, dsize=7, align=4,Q 从 P 的 dsize(5)开始放,而不是从 sizeof(P)(8)开始,R 只有 8 字节。上一张卡片里 A 放在偏移 12,用的也是这条规则。
条件和第 5 节相同:被复用填充的基类不能是“POD for the purpose of layout”。这里给 P 和 Q 都加了用户提供的构造函数,就是为了让它们不满足这个条件。去掉 P(),Q 就会退回偏移 8,R 变成 12 字节。
复用填充的代价
尾部填充被别人占用以后,基类子对象就不能再整块复制了。比如对 R 里的 P 子对象执行 std::memcpy(static_cast<P*>(&r), &other_p, sizeof(P)),会把 8 个字节全写进去,连带覆盖住在偏移 5、6 的 q 和 r。这正是 ABI 不让 C 风格结构体被复用的原因:这类类型最可能被 memcpy。
一般规律是:对基类子对象只能按 dsize 安全地复制,sizeof 只对完整对象成立。 标准层面的说法是,基类子对象是“可能重叠的子对象”,不能对它用 memcpy 整块复制,见 C++20 草案 [basic.types]/2。
7. this 调整:thunk 在中间做了什么
第二个 vtable 里的秘密
Stream 的 vtable 其实是两张表拼起来的
Vtable for 'Stream' (11 entries).
0 | offset_to_top (0)
1 | Stream RTTI
-- (Reader, 0) vtable address --
-- (Stream, 0) vtable address --
2 | Stream::~Stream() [complete]
3 | Stream::~Stream() [deleting]
4 | int Stream::read()
5 | int Stream::write()
6 | offset_to_top (-16)
7 | Stream RTTI
-- (Writer, 16) vtable address --
8 | Stream::~Stream() [complete]
[this adjustment: -16 non-virtual] method: Writer::~Writer()
9 | Stream::~Stream() [deleting]
[this adjustment: -16 non-virtual] method: Writer::~Writer()
10 | int Stream::write()
[this adjustment: -16 non-virtual] method: int Writer::write()第 0–5 项给 Reader 子对象(也是 Stream 自己)用,偏移 0 处的 vptr 指向第 2 项。第 6–10 项给 Writer 子对象用,偏移 16 处的 vptr 指向第 8 项。
注意第二部分:
offset_to_top (-16):从Writer子对象回到完整对象,要往回走 16 字节。dynamic_cast<void*>就是靠它找到对象开头的。- 每个条目都标着
this adjustment: -16:调用前,要先把this减去 16。
thunk:一小段负责改 this 的跳板
这个“先减 16”由一段叫 thunk 的小函数完成,它放在 vtable 第 10 项里,而不是直接放 Stream::write。为了让 thunk 显眼一点,把 Stream::write 改成调用一个外部函数,避免被优化掉:
int flush(Stream&);
int Stream::write() { return flush(*this); }
用 clang++ -std=c++20 -O2 -target x86_64-linux-gnu -masm=intel -S 生成汇编,再用 c++filt 还原函数名。本文的汇编片段都省略了 .cfi_* 等汇编指示,只保留指令:
Stream::write():
jmp flush(Stream&)@PLT
non-virtual thunk to Stream::write():
add rdi, -16
jmp flush(Stream&)@PLT在 x86-64 Linux 的调用约定里,this 通过 rdi 寄存器传递。thunk 先把 rdi 减去 16,让它指回 Stream 的开头,然后执行和 Stream::write 一样的代码。
所以完整的调用链是:通过 Writer& 调用 write() → 取出偏移 16 处的 vptr → 找到第 10 项,也就是 thunk → thunk 调整 this → 执行真正的函数体。
指针转换本身也有成本
指针转换要判空,引用转换不用
Writer* to_writer_ptr(Stream* s) { return s; }
Writer& to_writer_ref(Stream& s) { return s; }
to_writer_ptr(Stream*):
lea rax, [rdi + 16]
test rdi, rdi
cmove rax, rdi
ret
to_writer_ref(Stream&):
lea rax, [rdi + 16]
ret两个函数都把地址加 16,但指针版本多了两条指令:test 检查 s 是否为空,cmove 在为空时把结果改回原值。空指针转换后必须仍然是空指针,不能变成 0x10;而引用不可能为空,所以不需要这个检查。
单继承且基类是多态类时,主基类在偏移 0,这些转换都不需要指令。不在偏移 0 的基类(多继承中的非主基类,或上一节那种没有 vptr 的基类)转换时多一次加法,指针还要多一次判断。
8. 虚析构函数:delete 怎么找到整个对象
通过基类指针 delete,只析构了一半
先看现象
前面每个基类都写了 virtual ~X() = default。去掉 virtual 会怎样?
#include <cstdio>
struct Base {
virtual void f() {}
~Base() { std::puts("~Base"); }
};
struct Derived : Base {
~Derived() { std::puts("~Derived"); }
};
int main() {
Base* p = new Derived;
delete p;
}
用 clang++ -std=c++20 -O2 -Wall 编译,编译器会给出警告:
warning: delete called on non-final 'Base' that has virtual functions but non-virtual destructor [-Wdelete-non-abstract-non-virtual-dtor]运行结果只有一行:
~Base~Derived 没有执行。delete p 时,编译器只看 p 的静态类型 Base*,而 ~Base 不是虚函数,所以直接调用 ~Base。如果 Derived 里有一个 std::string 或 std::vector 成员,它的内存就泄漏了。
把 ~Base 改成 virtual ~Base(),输出变成:
~Derived
~Base编译器不一定会提醒你
把 Base 里的 virtual void f() {} 也删掉,再用 -Wall -Wextra 编译,一个警告都没有,运行结果依然只有 ~Base。
Clang 的这个警告只在 Base 有虚函数时触发:有虚函数说明这个类打算被多态使用,析构函数却不是虚的,很可能是忘了。基类完全没有虚函数时,编译器认为你本来就不打算通过基类指针删除对象,于是不再提醒。
和第 5 节的布局合起来:直接崩溃
释放了一个错误的地址
第 5 节最后的 Base / Derived 里,Base 在偏移 8。对它做同样的事:
#include <cstdio>
struct Base { int x = 0; };
struct Derived : Base {
virtual void f() {}
int y = 0;
};
int main() {
Derived* d = new Derived;
Base* p = d;
std::printf("new returned %p\n", static_cast<void*>(d));
std::printf("delete gets %p\n", static_cast<void*>(p));
std::fflush(stdout);
delete p;
std::puts("after delete");
}
-Wall 依然没有警告(Base 没有虚函数)。运行结果:
new returned 0x1032ad8b0
delete gets 0x1032ad8b8然后进程直接终止,after delete 没有打印出来,shell 里看到的退出码是 133(128 + 5,即进程收到了 SIGTRAP)。-O0 和 -O2 结果相同。
原因看汇编就清楚了。Base 不是多态类时,delete p 编译成:
void destroy(Base* p) { delete p; }
destroy(Base*):
test rdi, rdi
je .LBB0_1
mov esi, 4
jmp operator delete(void*, unsigned long)@PLT编译器把 p 原样交给 operator delete,大小按 sizeof(Base) 传了 4。可是 new 返回的是 d,p 比它大 8,operator delete 拿到的根本不是一块分配出来的内存的起始地址。macOS 生成的崩溃报告(~/Library/Logs/DiagnosticReports/ 下)显示,进程停在 libsystem_malloc.dylib 的 free 路径里:内存分配器发现这个地址不对,主动触发了 trap。
deleting destructor 就是为此存在的
给 Base 加上虚析构函数,delete p 变成:
struct Base {
virtual ~Base();
int x = 0;
};
void destroy(Base* p) { delete p; }
destroy(Base*):
test rdi, rdi
je .LBB0_1
mov rax, qword ptr [rdi]
jmp qword ptr [rax + 8]这就是一次虚调用:读 vptr,取出第二个析构函数槽位,也就是第 4 节 vtable 里的 [deleting] 那一项。它由对象的实际类型提供,所以知道三件事:
- 要析构的是完整对象,先调用
~Derived,再调用各个基类的析构函数。 - 完整对象从哪里开始。如果
p指向的是非主基类,vtable 里的 thunk 会先把this调回对象开头,和第 7 节一样。 - 完整对象有多大,释放时传给
operator delete的是正确的地址和大小。
delete 需要的信息,只有对象的实际类型知道,所以它只能通过虚函数拿到。
这是未定义行为,不是“只析构一半”
上面看到的“只打印 ~Base”和“崩溃”都只是一次运行的表现。标准 [expr.delete]/3 规定:被删除对象的静态类型和动态类型不同时,静态类型必须是动态类型的基类,并且有虚析构函数,否则行为未定义。
所以判断规则很简单:一个类只要可能被通过基类指针 delete,它的析构函数就必须是 virtual。不打算这样用的基类,可以把析构函数设为 protected 且非虚,让 delete p 直接编译失败。
9. 虚调用在汇编里长什么样
两次读内存,一次间接跳转
虚调用
struct Shape {
virtual ~Shape() = default;
virtual double area() const;
int id = 0;
};
double call_virtual(const Shape& s) { return s.area(); }
call_virtual(Shape const&):
mov rax, qword ptr [rdi]
jmp qword ptr [rax + 16]只有两条指令,正好对应前面的模型:
mov rax, [rdi]:rdi是s的地址,读出偏移 0 处的 vptr。jmp [rax + 16]:从 vptr 指向的位置往后 16 字节取出函数地址,然后跳过去。16 字节就是两个析构函数槽位之后的第三个槽位,也就是 vtable 打印输出里的第 4 项area。
这里用的是 jmp 而不是 call,因为 area() 的返回值直接作为 call_virtual 的返回值,编译器做了尾调用优化。
final:让编译器确定调用目标
struct Square final : Shape {
double area() const override;
double side = 1;
};
double call_final(const Square& s) { return s.area(); }
call_final(Square const&):
jmp Square::area() const@PLTfinal 告诉编译器,Square 不会再有派生类。既然 s 一定就是 Square,s.area() 一定是 Square::area,编译器就不再查表,直接跳到确定的函数。这叫去虚化(devirtualization)。
虚调用的成本到底在哪?
对比两段汇编,虚调用多出来的东西有:
- 两次依赖的内存读取:先读 vptr,再读函数地址,第二次读取要等第一次完成。vtable 不在缓存里时,代价会明显变大。
- 间接跳转:跳转目标要运行时才知道,依赖 CPU 的间接分支预测。同一个调用点上对象类型来回变化时,预测更容易失败。
- 挡住内联:这一点往往影响最大。编译器不知道调用哪个函数,就没法把函数体内联进来,后续的常量传播、向量化等优化也随之失效。
这里只是从汇编推断成本的来源,没有测量具体慢多少。虚调用和 CRTP 静态多态的 benchmark 对比,会在模板专题里单独做。
10. 检验:合上文章画一遍
不看前文,画出布局
每题先在纸上画,再展开对照
下面的答案都来自本文实验环境中的 -fdump-record-layouts 输出。画的时候标出每个成员和 vptr 的偏移,以及 sizeof。
Quiz 1:struct Record { bool valid; double score; int count; bool dirty; }; 的布局和 sizeof?怎样重排能变小?
valid @ 0,score @ 8,count @ 16,dirty @ 20,sizeof 为 24。valid 后面有 7 字节填充,末尾有 3 字节填充。
按对齐值从大到小重排成 double score; int count; bool valid; bool dirty; 后:score @ 0,count @ 8,valid @ 12,dirty @ 13,sizeof 为 16。
Quiz 2:Circle 有几个 vptr?把 Circle* 转成 Shape*,地址会变吗?
一个。Shape 是主基类,放在偏移 0,Circle 和它共用 vptr。所以转换后地址不变,也不需要任何指令。
Quiz 3:画出 Stream 的布局。Stream 对象里有几个 vptr?
两个。Reader 子对象在 0(vptr @ 0,rfd @ 8),Writer 子对象在 16(vptr @ 16,wfd @ 24),buffered @ 28,sizeof 为 32。
buffered 能放在 28,是因为它复用了 Writer 子对象末尾的填充。
Quiz 4:通过 Writer& 调用 write() 时,this 是怎样变回指向 Stream 开头的?
Writer 子对象的 vptr 指向 Stream vtable 的第二部分,其中 write 的槽位放的不是 Stream::write,而是一个 thunk。thunk 先把 this 减去 16(x86-64 上是 add rdi, -16),再执行 Stream::write 的函数体。
Quiz 5(面试题):sizeof(Empty) 为什么是 1?什么情况下空类可以不占空间?
C++ 要求不同对象有不同的地址,大小为 0 会让数组里的元素地址重合,所以空类至少占 1 字节。
作为基类时,空基类优化允许它不占空间;C++20 起,成员加上 [[no_unique_address]] 也可以不占空间。
Quiz 6(面试题):虚函数调用比普通调用慢在哪里?怎样让编译器去虚化?
多了两次依赖的内存读取(vptr 和函数地址)和一次间接跳转,更重要的是编译器无法内联,后续优化也做不了。
给类或函数加 final,或者让编译器能确定对象的动态类型(比如直接对一个局部对象调用),编译器就能直接调用确定的函数。
Quiz 7:struct Base { int x; }; struct Derived : Base { virtual void f() {} }; 中,Base* p = new Derived; delete p; 会发生什么?-Wall 会警告吗?
不会警告,因为 Base 没有虚函数。
- 布局:
Base不是多态类,不能当主基类,Derived的 vptr 在偏移 0,Base子对象被放到偏移 8。 - 转换:
Base* p = new Derived时,指针加了 8。 - 释放:
~Base不是虚函数,delete p把p原样交给operator delete,释放的地址比new返回的大 8。这是未定义行为,本文的实验环境里进程直接终止。
Quiz 8:struct A { int a; }; struct B { virtual void f(); int b; }; struct D : A, B { int d; }; 中,D* 转成 A* 和 B*,哪个要改地址?
B 是第一个多态基类,当主基类放在偏移 0,D* 转 B* 地址不变。A 被排到偏移 12,住进 B 的尾部填充,D* 转 A* 要加 12,指针版本还要判空。sizeof(D) 是 24。
11. 一套可以复用的判断方法
拿到一个类,按顺序问这几个问题
从成员到调用
| 要回答的问题 | 怎么判断 |
|---|---|
| 有没有 vptr? | 有虚函数(包括继承来的)就有,放在对象开头 |
| 成员放在哪里? | 当前位置向上取到对齐值的整数倍 |
sizeof 是多少? | 补齐到最大对齐值的整数倍 |
| 有空基类吗? | 空基类通常不占空间(EBO) |
| 偏移 0 放哪个基类? | 第一个非虚的多态基类,不一定是声明顺序里的第一个 |
| 派生类成员、后一个基类从哪开始? | 看前一个基类的 dsize,非 C 风格基类的尾部填充可以复用 |
| 有几个空基类? | 不同类型的空基类可以叠在同一个偏移,同类型的空对象必须错开 |
| 有几个 vptr? | 每个带虚函数的非主基类各带一个 |
| 转换指针要调整吗? | 基类不在偏移 0(非主基类,或没有 vptr 的基类)就要加偏移,指针还要判空 |
能通过基类指针 delete 吗? | 只有基类析构函数是 virtual 时才行 |
| 虚调用怎么走? | 读 vptr → 按槽位取函数地址 → 必要时经过 thunk 调整 this |
几个值得留下的判断
- 布局由 ABI 决定,标准只给了顺序等少数约束。讨论布局时先说清楚编译器和平台。
- 成员顺序会影响大小,按对齐值从大到小排通常最省。
- 不确定时不要猜,让编译器打印出来:
-fdump-record-layouts看布局,-fdump-vtable-layouts看虚表,-S看汇编。 - 会被多态使用的基类,析构函数写成
virtual;不打算多态删除的基类,析构函数设为protected。 - 虚函数的代价主要不在那两条指令,而在于挡住了内联。性能敏感的路径上,可以考虑
final或静态多态。
延伸阅读
遇到具体问题时,从这里查
- Itanium C++ ABI:本文所有布局和 vtable 结构的权威来源,第 2 章讲数据布局和虚表。
- C++20 草案 [basic.align]:对齐的语言规则。
- C++20 草案 [class.mem]:成员的声明顺序与地址顺序。
- C++20 草案 [dcl.attr.nouniqueaddr]:
[[no_unique_address]]的规则。 - Compiler Explorer:不方便本地生成 x86-64 汇编时,可以在线对比不同编译器的输出。
下一步可以沿着两个方向继续:一是虚继承,它解决菱形继承的重复基类问题,布局会再复杂一层;二是用 benchmark 比较虚调用和 CRTP 静态多态,把本文从汇编推断出的成本变成测量数据。