QuanZhou's Wiki
更新于

C++ 对象内存布局:从 sizeof 到虚函数表

~/ C/C++#C++特性#对象模型#内存布局

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.cpp
Vtable 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() = 2

r 和 &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@PLT

final 告诉编译器,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 或静态多态。

延伸阅读

遇到具体问题时,从这里查

下一步可以沿着两个方向继续:一是虚继承,它解决菱形继承的重复基类问题,布局会再复杂一层;二是用 benchmark 比较虚调用和 CRTP 静态多态,把本文从汇编推断出的成本变成测量数据。