内存对齐与 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 位系统)
| 类型 | sizeof | alignof |
|---|---|---|
| char | 1 | 1 |
| short | 2 | 2 |
| int | 4 | 4 |
| long long | 8 | 8 |
| float | 4 | 4 |
| double | 8 | 8 |
| 指针 | 8 | 8 |
常见问题
怎么快速估算 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]] 解决了空成员占空间的问题。