内存对齐与 padding 优化 ​

面试考点 ​

内存对齐是 C++ 底层面试的常考题。面试官通常给你一个 struct,让你算 sizeof,或者问你怎么调整成员顺序来减少 padding 浪费。

核心概念 ​

CPU 访问对齐的内存地址更快。编译器会在 struct 成员之间插入 padding(填充字节),确保每个成员的地址是其对齐要求的倍数。struct 总大小也必须是最大对齐要求的倍数。

对齐规则 ​

规则说明
成员对齐每个成员的偏移量是 alignof(成员类型) 的倍数
结构体对齐总大小是最大成员对齐值的倍数
基本类型对齐通常 alignof(T) == sizeof(T),但不超过指针大小

基本示例 ​

cpp
#include <iostream>
#include <cstddef>
#include <cstdint>

// ============================
// 示例1:padding 产生的原因
// ============================

struct Bad {
    char a;    // 偏移 0,大小 1
    // padding 3 字节(对齐 int 到偏移 4)
    int b;     // 偏移 4,大小 4
    char c;    // 偏移 8,大小 1
    // padding 7 字节(对齐 double 到偏移 16)
    double d;  // 偏移 16,大小 8
    char e;    // 偏移 24,大小 1
    // padding 7 字节(总大小必须是 8 的倍数)
};
// sizeof(Bad) = 32
// 实际数据只有 1+4+1+8+1 = 15 字节,浪费了 17 字节!

// ============================
// 示例2:调整顺序减少 padding
// ============================

struct Good {
    double d;  // 偏移 0,大小 8
    int b;     // 偏移 8,大小 4
    char a;    // 偏移 12,大小 1
    char c;    // 偏移 13,大小 1
    char e;    // 偏移 14,大小 1
    // padding 1 字节(总大小必须是 8 的倍数)
};
// sizeof(Good) = 16
// 节省了 16 字节(50%)

// ============================
// 示例3:用 offsetof 验证布局
// ============================

void layout_demo() {
    std::cout << "=== Bad 布局 ===" << std::endl;
    std::cout << "sizeof(Bad) = " << sizeof(Bad) << std::endl;
    std::cout << "a 偏移: " << offsetof(Bad, a) << std::endl;
    std::cout << "b 偏移: " << offsetof(Bad, b) << std::endl;
    std::cout << "c 偏移: " << offsetof(Bad, c) << std::endl;
    std::cout << "d 偏移: " << offsetof(Bad, d) << std::endl;
    std::cout << "e 偏移: " << offsetof(Bad, e) << std::endl;

    std::cout << "\n=== Good 布局 ===" << std::endl;
    std::cout << "sizeof(Good) = " << sizeof(Good) << std::endl;
    std::cout << "d 偏移: " << offsetof(Good, d) << std::endl;
    std::cout << "b 偏移: " << offsetof(Good, b) << std::endl;
    std::cout << "a 偏移: " << offsetof(Good, a) << std::endl;
    std::cout << "c 偏移: " << offsetof(Good, c) << std::endl;
    std::cout << "e 偏移: " << offsetof(Good, e) << std::endl;
}

// ============================
// 示例4:alignof 和 alignas
// ============================

void alignof_demo() {
    // alignof 获取类型的对齐要求
    std::cout << "alignof(char)   = " << alignof(char) << std::endl;    // 1
    std::cout << "alignof(short)  = " << alignof(short) << std::endl;   // 2
    std::cout << "alignof(int)    = " << alignof(int) << std::endl;     // 4
    std::cout << "alignof(double) = " << alignof(double) << std::endl;  // 8
    std::cout << "alignof(void*)  = " << alignof(void*) << std::endl;   // 8(64位)
}

// alignas 指定对齐要求
struct alignas(64) CacheLine {
    // 整个结构体对齐到 64 字节(缓存行大小)
    int data[4];
};
// sizeof(CacheLine) = 64(对齐到 64 字节边界)

// ============================
// 示例5:#pragma pack 紧凑布局
// ============================

#pragma pack(push, 1)  // 设置对齐为 1 字节
struct Packed {
    char a;    // 偏移 0
    int b;     // 偏移 1(不对齐!)
    char c;    // 偏移 5
    double d;  // 偏移 6(不对齐!)
};
#pragma pack(pop)      // 恢复默认对齐
// sizeof(Packed) = 14(没有 padding)
// 但访问 b 和 d 可能更慢(未对齐访问)

// ============================
// 示例6:位域的对齐
// ============================

struct Flags {
    uint32_t active : 1;    // 1 位
    uint32_t visible : 1;   // 1 位
    uint32_t dirty : 1;     // 1 位
    uint32_t priority : 4;  // 4 位
    uint32_t reserved : 25; // 25 位
};
// sizeof(Flags) = 4(32 位正好一个 uint32_t)

// ============================
// 示例7:C++20 [[no_unique_address]]
// ============================

struct Empty {};

struct WithEmpty {
    Empty e;     // 占 1 字节 + padding
    int x;
};
// sizeof(WithEmpty) = 8

struct WithNoUnique {
    [[no_unique_address]] Empty e;  // 允许不占空间
    int x;
};
// sizeof(WithNoUnique) = 4(Empty 不占空间)

void size_demo() {
    std::cout << "\n=== 各种大小 ===" << std::endl;
    std::cout << "sizeof(CacheLine) = " << sizeof(CacheLine) << std::endl;
    std::cout << "sizeof(Packed) = " << sizeof(Packed) << std::endl;
    std::cout << "sizeof(Flags) = " << sizeof(Flags) << std::endl;
    std::cout << "sizeof(WithEmpty) = " << sizeof(WithEmpty) << std::endl;
    std::cout << "sizeof(WithNoUnique) = " << sizeof(WithNoUnique) << std::endl;
}

int main() {
    layout_demo();
    alignof_demo();
    size_demo();
    return 0;
}

常见类型的大小和对齐(64 位系统) ​

类型sizeofalignof
char11
short22
int44
long long88
float44
double88
指针88

常见问题 ​

怎么快速估算 struct 的大小?

经验法则:把成员按对齐要求从大到小排列,然后计算。每个成员的偏移必须是其 alignof 的倍数,总大小是最大 alignof 的倍数。

#pragma pack 有什么风险?

紧凑布局会导致未对齐的内存访问。在 x86 上可能只是变慢,在 ARM 等架构上可能直接崩溃。而且紧凑布局的对象不能安全地用于原子操作。

alignas 有什么用?

常见用途是对齐到缓存行(64 字节),避免多线程中的伪共享(false sharing)。也用于 SIMD 指令要求的对齐(如 SSE 需要 16 字节对齐,AVX 需要 32 字节对齐)。

适用场景 ​

  • 网络协议解析(固定格式的数据包)
  • 内存敏感的数据结构(大量对象时节省空间)
  • 多线程中避免伪共享
  • SIMD 操作的对齐要求

注意事项 ​

  • 按从大到小排列成员是减少 padding 的简单策略
  • 不要随意使用 #pragma pack,除非你明确知道后果
  • C++ 标准保证成员按声明顺序排列(同一访问级别内)
  • 编译器可以用 -Wpadded 警告 padding
  • 空基类优化(EBO)和 [[no_unique_address]] 可以消除空类的开销

总结 ​

内存对齐是编译器为了 CPU 访问效率自动添加的 padding。按从大到小的顺序声明成员可以减少 padding 浪费。面试中常考的操作:给定一个 struct,算出 sizeof(注意成员对齐和尾部对齐)。工具方面,alignof 查看对齐要求,alignas 指定对齐,offsetof 查看偏移,#pragma pack 强制紧凑(有风险)。C++20 的 [[no_unique_address]] 解决了空成员占空间的问题。