先看两个现场。第一个是人畜无害的配置结构体:一个 char、一个 int、再一个 char、一个 double,字段大小加起来 14 字节,可 sizeof 稳定打印 24。第二个是协议解析:设备发来 7 字节状态头,同事照着协议文档写了结构体,memcpy 进来直接读字段,结果 type 对,seq 读成 0x00010211,len 永远是 0。

两件事看着不像同一类问题,根子上是一个:C++ 的对象在内存里怎么摆,不是「按字段名字挨个排」这么朴素。编译器要按对齐要求往中间塞空洞,空洞不属于任何字段,却真实占着字节。按字段之和算大小,或者拿结构体去对协议字节,都会在这块空地上翻车。

这篇要解决的就是这层「看不见的摆放」:类型的宽度到底谁定;变量和对象有什么区别;sizeof、alignof、offsetof 怎么读出一张字节地图;字段顺序怎么影响大小;以及把结构体直接当线上格式用时,代价在哪。中间有一个能把 7 字节帧正确解出来的完整程序,最后是一张「现象 / 真实原因 / 第一步查什么」的表。

本文按 C++20 写。示例在本机 Windows + MinGW g++ 16.2.0 上以 -std=c++20 -Wall -Wextra 实际编译运行,输出照抄。Windows 用 LLP64 模型,Linux 用 LP64,宽度不同的地方会单独标注;没有在本机验证过的结论会写明。

类型宽度:标准只管下限

很多人以为 int 就是 4 字节。标准里没有这句话。它规定的是相对关系:short 至少 16 位,int 至少和 short 一样宽,long 至少 32 位,long long 至少 64 位,而 char 恰好 1 字节。这里的「字节」是 C++ 的字节,等于 CHAR_BIT 位,主流平台是 8 位。真正落到几个字节,是由编译器面向的目标 ABI 决定的。

本机跑一个小程序,把这几个宽度打出来,顺便把几个常用库类型也量了:

类型本机 sizeof说明
char / short / int1 / 2 / 4最常见的组合,不是标准保证
long4Windows 是 LLP64;Linux 的 LP64 下是 8
long long8标准要求至少 64 位
指针 void*864 位进程;32 位进程是 4
int32_t / int64_t4 / 8来自 <cstdint>,宽度固定
std::string32对象自身大小,与字符串多长无关
std::vector<int>24三个指针:头、尾、容量尾
std::string_view16一个指针加一个长度
空结构体1标准要求每个对象有唯一地址,不能是 0

结论很直接:只要数据要跨平台、跨编译器,或者要落到文件、发到网络上,就别拿 int、long 这种宽度会漂移的类型当格式。要用 <cstdint> 里的 int32_t、uint16_t、uint64_t。它们不是新类型,是对「恰好这么多位、没有填充位」的底层类型的别名。平台若没有这种宽度,这个别名根本不存在,编译期就报错——比运行到客户现场才读错强得多。

还有一个逃不掉的名字:std::size_t。它是 sizeof 的返回类型,定义成「足够装下任何对象大小」的无符号整数。64 位平台上通常是 64 位无符号,这也是后面「符号陷阱」那节的起因。

变量与对象:名字不等于存储

平时这两个词混着用,出问题时区别很关键。对象是「一块存储 + 一个类型 + 一段生命周期」;变量是给对象起的名字。int x = 42; 创建了一个 int 对象,名字叫 x;new int(42) 也创建了一个对象,但没有名字,只能靠返回的指针去访问;v[0] 同样是一个对象,名字是用下标算出来的。

为什么值得掰开:名字不携带存储。上表里 std::string 是 32 字节,你写 std::string s = "hi";,sizeof(s) 永远是 32,字符「hi」要么在对象内部的短字符串缓冲区里,要么在堆上另开的一块内存里。这 32 字节装的是「怎么找到那段字符」的信息,而不是字符本身。std::vector<int> 是 24 字节,三个指针指向堆上的元素数组,元素不在这 24 字节里。

这解释了一个常见的误判:看到 sizeof(Container) 很小,就以为拷贝它很便宜。拷贝 vector 会把元素一份一份复制过去,代价和元素个数成正比;而拷贝 std::string_view 真的只是复制 16 字节,因为它不拥有字符。同样大小,语义完全不同。

生命周期也是对象自带的属性。栈上的对象在作用域结束时销毁,堆上的对象靠 delete 或智能指针销毁,静态存储期的对象活到程序结束。指针只记地址,不记生命周期——这正是下一篇要展开的坑:对象没了,地址还在,指针就悬空了。

sizeof、alignof 与填充

sizeof 不是字段大小求和。规则可以压成三句话:每个类型有对齐要求 alignof,对象的地址必须是它的整数倍;结构体里每个字段的偏移,必须是该字段 alignof 的整数倍,不够就插填充;结构体自己的 alignof 取所有字段里最大的,最后 sizeof 要向上取整到它的倍数。

拿开头那个结构体实际量一下。字段是 char flag、int id、char tag、double score,本机的字节地图是这样:

偏移 0:flag,1 字节
偏移 1 到 3:填充 3 字节,为了让 id 落在 4 的倍数上
偏移 4 到 7:id,4 字节
偏移 8:tag,1 字节
偏移 9 到 15:填充 7 字节,为了让 score 落在 16(8 的倍数)
偏移 16 到 23:score,8 字节

14 字节的字段,占 24 字节,10 字节是填充。这不是编译器偷懒,是为了让 8 字节的 double 落在 8 的倍数上。x86 对未对齐访问通常能忍,只是慢一点;ARM 的某些配置直接触发异常,这条没在本机验证。标准不保证未对齐访问可用,编译器也就不敢赌。

把同样四个字段按大小从大到小排:double 在 0、int 在 8、两个 char 在 12 和 13、尾部补 2 字节,总共 16。省下 8 字节,字段一个没少。字段顺序不影响语义,但会改变布局;一旦这个结构体被写进文件、发给别人、或者被别的模块按偏移读,重排就是一次破坏性的接口变更。

从字段声明到最终字节数
按声明顺序排字段
每个字段前按 alignof 补空洞
整体 alignof 取字段最大值
sizeof 向上取整到该对齐

完整走查:把 7 字节帧解对

协议文档写得很清楚:状态头 7 字节,type 1 字节、seq 4 字节小端、len 2 字节小端,紧凑排列。很多人第一反应就是照抄成结构体,然后 memcpy。下面这段程序就是那条路,以及正确的做法:

// frame_demo.cpp
#include <cstdint>
#include <cstdio>
#include <cstring>

struct Wire {
  uint8_t type;
  uint32_t seq;
  uint16_t len;
};

int main() {
  // A device sends this 7-byte header: type=1, seq=0x11223344, len=0x0102
  unsigned char frame[7] = {0x01, 0x44, 0x33, 0x22, 0x11, 0x02, 0x01};

  Wire w{};
  std::memcpy(&w, frame, sizeof(frame));
  std::printf("struct: type=%u seq=0x%08x len=%u\n",
              static_cast<unsigned>(w.type), static_cast<unsigned>(w.seq),
              static_cast<unsigned>(w.len));

  uint8_t type = frame[0];
  uint32_t seq = static_cast<uint32_t>(frame[1]) |
                 (static_cast<uint32_t>(frame[2]) << 8) |
                 (static_cast<uint32_t>(frame[3]) << 16) |
                 (static_cast<uint32_t>(frame[4]) << 24);
  uint16_t len = static_cast<uint16_t>(frame[5]) |
                 (static_cast<uint16_t>(frame[6]) << 8);
  std::printf("manual: type=%u seq=0x%08x len=%u\n",
              static_cast<unsigned>(type), static_cast<unsigned>(seq),
              static_cast<unsigned>(len));
  return 0;
}

编译并运行:

g++ -std=c++20 -Wall -Wextra frame_demo.cpp -o app.exe
.\app.exe

本机输出:

struct: type=1 seq=0x00010211 len=0
manual: type=1 seq=0x11223344 len=258

为什么结构体读到的是 0x00010211?因为 seq 的偏移是 4,不是 1。memcpy 把 7 个字节铺在偏移 0 到 6 上:偏移 4 拿到 0x11,偏移 5 拿到 0x02,偏移 6 拿到 0x01,偏移 7 没人填,还是 0。小端拼起来就是 0x00010211。而 len 的偏移是 8,7 个字节根本没碰到它,所以是 0。只有 type 恰好在偏移 0,蒙对了。

顺带一提,sizeof(Wire) 是 12,不是 7,偏移分别是 0、4、8,中间有 3 字节填充。也就是说这个结构体的形状和协议压根不是一回事,凑巧读对一个字段纯属运气。

手动解的那段代码看起来笨,却是唯一稳的:每个字节的偏移和字节序都写在明处,换平台、换编译器、换字节序,行为都可预期。真要把这种编解码写很多次,最好集中放一个文件,配 static_assert 和单元测试,而不是散落在业务代码里。

聚合初始化与 C++20 指定初始化

结构体是聚合类型,可以用花括号按顺序初始化。C++20 起支持「指定成员名」的写法,把字段名写在花括号里,可读性比一串位置参数好太多,也不容易在字段重排时悄悄错位:

#include <iostream>
#include <string>

struct Config {
  std::string host;
  int port;
  bool tls;
};

int main() {
  Config cfg{.host = "127.0.0.1", .port = 8080, .tls = false};
  std::cout << "config " << cfg.host << ":" << cfg.port
            << " tls=" << cfg.tls << "\n";
  return 0;
}

本机跑出来是 config 127.0.0.1:8080 tls=0。注意 tls 打印成 0 是因为 std::cout 默认把 bool 输出成 0/1,不是值错了。

指定初始化有一条硬规则:书写顺序必须与声明顺序一致,可以跳过某些字段,但不能倒着写。拿一个两字段的结构体 P 试了下,倒着写编译器直接拒绝,本机报的是:

error: designator order for field 'P::x' does not match declaration order in 'P'

花括号初始化还有个好处:它禁止窄化转换。把 3.14 塞进 int,圆括号赋值可能只给一条警告,花括号直接编译失败,本机报:

error: narrowing conversion of '3.1400000000000001e+0' from 'double' to 'int' [-Wnarrowing]

这条错误看着烦,实际是在帮你——它把「精度悄悄丢了」变成一次编译失败。写常量、写配置、写测试数据时,尽量用花括号,别用 = 加圆括号。

聚合初始化里没写的成员会被值初始化:内置类型是 0,类类型调用默认构造。-Wextra 下的 -Wmissing-field-initializers 会提示漏了成员,但这条警告对「故意只填几个字段」的写法也会响,按情况判断,不要一关了之。

int 与 size_t:符号位惹的祸

容器大小、下标、sizeof 的返回类型都是无符号的 size_t。业务代码里习惯用 int,两边一混,比较就会出事。看这段:

#include <iostream>
#include <vector>

int main() {
  std::vector<int> v{1, 2, 3};
  int idx = -1;
  std::cout << (idx < v.size()) << "\n";   // 打印 0
  if (idx < v.size()) {
    std::cout << "branch taken\n";
  }
  return 0;
}

任何人读这行都会觉得条件成立:-1 当然比 3 小。可本机打印出来的比较结果是 0,也就是条件为假。原因在类型转换:int 和 size_t 比较时,int 被转成无符号,-1 变成 2 的 64 次方减一,反而比 3 大。这次「不进入分支」看着没事,但如果这段逻辑的本意是「用负下标表示非法、非法就跳过」,判断就正好反了。同一类错位还会出现在 v.size() - 1 上:空容器时它回绕成最大值,循环立刻越界。本机同时收到了这条警告:

warning: comparison of integer expressions of different signedness: 'int' and
'std::vector<int>::size_type' {aka 'long long unsigned int'} [-Wsign-compare]

更隐蔽的是倒序循环。很多人写 for (size_t i = v.size() - 1; i >= 0; --i),i 是无符号,减到 0 之后再减一就回绕成最大值,条件永远成立,循环停不下来。C++20 提供了 std::ssize(v),返回有符号长度,倒着遍历就写 for (auto i = std::ssize(v) - 1; i >= 0; --i),或者干脆用反向迭代器。

实践里的处理办法:凡是下标和长度,统一用 size_t 或 std::ptrdiff_t,别在中间转成 int;确实要存差值、可能为负,就用有符号类型;打开 -Wsign-compare(-Wextra 已包含),看到一条就改一条。这类警告不会误报太多,压下去比修起来贵。

auto 推的是什么

auto 只做一件事:用初始化表达式推导类型。它不会帮你选「更合适的类型」,也不会保留引用和顶层 const。三条规则记牢:

  • auto n = v.size(); 推出的是 size_t,和手写没区别;auto m = 0; 推出的是 int。本机验证过,两者 sizeof 都对得上。
  • auto s = str; 是拷贝,代价按类型算;auto& s = str; 才是引用,改它等于改原对象。
  • auto 会丢掉顶层 const:const int x = 1; auto y = x; 的 y 是 int,可以改。想保持只读,写 const auto&。

auto 最常见的用处是 range-for 和迭代器:for (const auto& item : items) 既避免拷贝,也不会误改;for (auto item : items) 每个元素都复制一份,元素是 std::string 时成本立竿见影。看到别人写 auto,先问一句「这个表达式本身是什么类型」,而不是猜。

现象、原因、先查什么

布局类问题的麻烦在于它不报错,只是结果不对。下面这张表按「你看到什么」分类,给出第一个该查的点。

你看到的现象真实原因第一步查什么
sizeof 比字段之和多 2、4、8 字节对齐填充,字段之间和尾部有空洞打印 alignof 和每个字段的 offsetof,看空洞落在哪
按结构体解析二进制帧,第一个字段对、其余全错结构体有填充,协议是紧凑排列,偏移根本对不上把 offsetof 和协议字段偏移并排比,别先怀疑字节序
写出去的结构体里混着随机字节填充字节没初始化就整体拷贝或写文件检查 memcpy/fwrite 是否整块搬结构体;改成逐字段序列化
-Wsign-compare 警告,比较结果反常int 与 size_t 混比,负数被当成巨大无符号统一成 size_t,或改用 std::ssize,别只加 static_cast 糊过去
同一结构体在两台机器上大小不同long/指针宽度或对齐规则不同(LP64 与 LLP64)改用定宽类型,并加 static_assert(sizeof(...) == N)
指定初始化报 designator order 错成员书写顺序和声明顺序不一致按声明顺序重写;顺序依赖本身说明这段代码以后不能随便重排字段
auto 之后改对象没生效,或性能突然变差auto 推成了拷贝,并不是引用检查是否漏了 & 和 const,必要时用 static_assert 或 IDE 提示确认类型

这张表里最值得记住的是第二条。协议解析错位时,人第一反应往往是「大小端搞反了」,可实际上字段偏移、填充这些布局问题更常见。先量偏移,再谈字节序。

边界与代价:什么时候能忍,什么时候不能

对齐和填充不是缺陷,是换取访问效率的代价。把好处和代价摆清楚,才知道什么时候该接受:

按对齐排布,直接用结构体

代码最自然,字段名直接访问,同进程内传参、临时缓存都合适。代价是可能有大量填充:字段越多越小,浪费越明显。十万个实例的结构体,多 8 字节就是 800 KB。

紧凑排布,手工编解码

字节数和协议一一对应,跨平台、跨语言都稳。代价是代码变长,每个字段的偏移和字节序都要自己负责,写错一位没人替你拦。适合做对外接口和持久化格式,不适合进程内到处用。

几个具体的边界,踩过才知道疼:

  • #pragma pack(1) 不是免费午餐。它能让结构体贴合 7 字节的协议,但成员可能落在奇数地址上,非对齐访问在 x86 只是慢,在某些 ARM 配置上会直接异常(未在本机验证)。另外,对 packed 结构体的成员取地址在标准里是病态用法,GCC 会给 -Waddress-of-packed-member 警告。真要用,只在编解码边界的最小范围内用。
  • 结构体不能当跨编译器 ABI。同一条声明,换个编译器、换个标准库版本、甚至加个 -fpack-struct,布局就可能变。跨团队、跨语言的二进制接口要回到纯 C 结构加定宽类型,或者干脆用显式的字节协议。
  • sizeof 是编译期常量,只描述类型,不描述运行时实际占用。容器对象大小和它管理的元素内存是两回事,别拿 sizeof 估内存占用。
  • 重排字段有隐性成本。省空间的收益是真的,但已有序列化代码、配置文件、测试里的字节快照都会跟着变;项目一旦上线,布局就成了一项需要维护的契约。
  • 把结构体整体写文件会泄漏填充内容。填充字节的值是未指定的,本机把 {1, 0x11223344, 0x0102} 这个结构体整块拷贝出来,字节是 01 f0 ba 68 44 33 22 11 02 01 00 00,偏移 1 到 3 是残留的栈数据。发到网络上,等于把进程里的垃圾数据带出去了。
用 memcmp 比较两个结构体是否相等,是另一个常见的坑:填充字节不参与语义,却参与比较,两个字段完全相同的对象可能被判为不相等。判断相等要逐字段比,或者给结构体写 operator==(C++20 可以 = default,编译器生成的比较只比成员,不碰填充)。

当天能验证的练习

这些都不需要额外工具,本机就能跑完:

  • 挑自己项目里两个结构体,打印 sizeof、alignof 和每个字段的 offsetof,把空洞标出来;试着重排字段把大小降下来,同时想清楚这次改动会不会破坏已有的序列化。
  • 把上面的帧解码程序改成 #pragma pack(1) 版本,确认 sizeof(Wire) 变成 7、解出的值也对了;然后回答一个问题:既然这样能对,为什么生产代码里仍不建议默认这么写。
  • 写 int i = -1; if (i < v.size()),打开 -Wextra 看警告,再把比较结果打印出来;然后写 for (size_t i = v.size() - 1; i >= 0; --i),观察死循环和编译器的提示。
  • 给一个打包结构体加 static_assert(sizeof(Wire) == 7) 和 static_assert(offsetof(Wire, seq) == 1),看哪一条先失败,体会「把布局变成编译期检查」的写法。
  • 用指定初始化写一个 5 字段配置,故意把顺序打乱,抄下完整报错;再改成正确顺序,编译通过。

小结

三句话收尾:类型宽度由平台 ABI 决定,跨边界的数据一律用 <cstdint> 的定宽类型;sizeof 大于字段之和是因为对齐填充,用 alignof 和 offsetof 把布局量出来;结构体是给同一程序内部用的,不是协议格式,二进制帧要按字节显式编解码。

布局讲清了「东西放在哪、占多大」,紧接着的问题是「怎么找到它、怎么保证找到的还是原来那个对象」。下一篇从 vector 扩容后旧指针全部失效讲起,把这层地址与生命周期讲透。