C++ 内存布局：对象内存结构与对齐

C++ 对象在内存中如何排布，直接影响程序性能、跨平台兼容性以及底层调试能力。理解其内存布局规则，能帮助你写出更高效、更安全的代码。

1. 基础对象的内存结构

创建一个最简单的类：

class Empty {};

即使这个类没有任何成员，它的实例也不能占用 0 字节。C++ 标准规定：每个对象必须有唯一的地址。因此，sizeof(Empty) 通常是 1。

添加普通数据成员后，对象大小等于各成员大小之和（暂不考虑对齐）：

class Point {
public:
    char x;   // 1 字节
    int y;    // 4 字节（假设 int 为 4 字节）
};

直觉上，sizeof(Point) 应该是 5，但实际往往是 8。原因在于 内存对齐。

2. 什么是内存对齐？

现代 CPU 访问内存时，按特定字节边界读取效率最高。例如，32 位系统通常要求 int 类型从 4 字节对齐的地址开始（即地址能被 4 整除）。

如果不对齐，CPU 可能需要两次内存访问才能读取一个 int，甚至某些架构会直接触发硬件异常。

C++ 编译器会自动在成员之间插入“填充字节”（padding），以满足对齐要求。

3. 成员对齐规则

编译器遵循以下核心规则决定对象布局：

1. 每个成员按其自身类型的对齐要求对齐。
2. 整个对象的大小必须是其最大成员对齐值的整数倍。
3. 成员按声明顺序依次排列（虚函数等特殊情况除外）。

以 Point 为例：

• char x 占用第 0 字节。
• int y 需要 4 字节对齐，因此不能紧跟在 x 后（地址 1 不是 4 的倍数）。
• 编译器在 x 后插入 3 字节填充，使 y 从地址 4 开始。
• 对象总大小 = 1（x） + 3（填充） + 4（y） = 8。
• 最大成员对齐值是 4（来自 int），而 8 是 4 的倍数，符合规则。

4. 调整成员顺序可节省内存

重新排列成员顺序能减少填充：

class OptimizedPoint {
public:
    int y;    // 4 字节，从地址 0 开始
    char x;   // 1 字节，从地址 4 开始
};

此时：

• y 占用 0~3 字节。
• x 占用第 4 字节。
• 对象总大小需是最大对齐值（4）的倍数，因此总大小为 8（4+1+3 填充）。

看起来没省？再看这个例子：

class Bad {
    char a;   // 1
    int b;    // 4 → 需 3 填充
    char c;   // 1 → 地址 8
}; // 总大小：12（因最大对齐为 4，1+3+4+1+3=12）

class Good {
    int b;    // 4
    char a;   // 1
    char c;   // 1
}; // 总大小：8（4+1+1+2 填充）

将大对齐成员放前面，小类型集中放置，能显著减少填充。

5. 继承与内存布局

单继承时，派生类对象 = 基类子对象 + 派生类新增成员。

class Base {
    int x;
};

class Derived : public Base {
    char y;
};

内存布局为：

• Base::x（0~3 字节）
• Derived::y（4 字节）
• 总大小为 8（因最大对齐为 4）

注意：空基类优化（EBO）允许编译器将空基类“折叠”，不占额外空间：

class EmptyBase {};
class Derived : public EmptyBase {
    int x;
};

此时 sizeof(Derived) == sizeof(int)（通常是 4），而非 5。

6. 虚函数的影响

一旦类包含虚函数，编译器会为其添加一个隐藏指针——虚表指针（vptr），通常放在对象起始位置。

class Virtual {
public:
    virtual void foo();
    int x;
};

内存布局：

• vptr（8 字节，64 位系统）
• x（4 字节）
• 填充 4 字节（使总大小为 16，因 vptr 对齐要求为 8）

因此 sizeof(Virtual) 通常是 16。

多重继承或虚继承会使布局更复杂，但核心原则不变：vptr 占空间，且影响对齐。

7. 控制对齐：alignas 与 #pragma pack

有时你需要精确控制布局（如网络协议、硬件寄存器映射）。

使用 alignas

struct alignas(1) Packed {
    char a;
    int b;
};

alignas(1) 强制整个结构体按 1 字节对齐，成员间无填充。此时 sizeof(Packed) == 5。

但不要轻易使用：可能引发性能下降或崩溃。

使用 #pragma pack

#pragma pack(push, 1)
struct Packed2 {
    char a;
    int b;
};
#pragma pack(pop)

#pragma pack(1) 告诉编译器所有成员按 1 字节对齐。效果同上。

恢复默认对齐必须用 #pragma pack(pop)，否则会影响后续代码。

8. 查看实际内存布局

编写测试代码验证布局：

#include <iostream>
#include <cstddef>

struct Test {
    char a;
    int b;
    char c;
};

int main() {
    std::cout << "Size: " << sizeof(Test) << "\n";
    Test t{};
    std::cout << "a offset: " << offsetof(Test, a) << "\n";
    std::cout << "b offset: " << offsetof(Test, b) << "\n";
    std::cout << "c offset: " << offsetof(Test, c) << "\n";
}

输出示例（64 位 GCC）：

Size: 12
a offset: 0
b offset: 4
c offset: 8

这说明：

• a 在 0
• b 因对齐跳到 4
• c 在 8
• 总大小 12（因最大对齐为 4，8+1=9 → 补到 12）

9. 常见陷阱与建议

1. 不要假设成员连续：成员间可能有填充，&obj.a + 1 != &obj.b。
2. 跨平台差异：不同编译器、架构（32/64 位）、ABI（如 Windows vs Linux）对齐规则可能不同。
3. 序列化时慎用 memcpy：含填充的对象直接二进制拷贝会包含垃圾数据。
4. 优先使用标准布局类型：若需与 C 兼容或做内存映射，确保类是 standard-layout（无虚函数、单一继承、所有非静态成员同访问权限等）。

可通过 std::is_standard_layout_v<T> 检查。

10. 对齐值参考表

不同类型的典型对齐要求如下（以主流 64 位系统为例）：

注意：对齐值由编译器和平台共同决定，可通过 alignof(T) 查询。

调用 alignof(int) 返回 4，表示 int 的对齐要求是 4 字节。

理解并善用内存布局规则，能让你在性能敏感场景下精准掌控资源，避免隐蔽的内存浪费与兼容性问题。