C/C++ 内存对齐详解与结构体优化

优化原则：

1. 按对齐值从大到小排列成员。
2. 相同类型的成员尽量集中放置。

5. 内存布局示例

5.1 示例 1：基本结构体

struct S1 {
    char a;      // 偏移 0
                 // 3 字节填充
    int b;       // 偏移 4
    short c;     // 偏移 8
                 // 2 字节填充（使总大小为 12，是 4 的倍数）
};               // sizeof(S1) == 12

5.2 示例 2：调整成员顺序优化空间

struct S2 {
    int b;       // 偏移 0
    char a;      // 偏移 4
    short c;     // 偏移 6
                 // 无填充（总大小 8，已是 4 的倍数）
};               // sizeof(S2) == 8

6. 控制对齐方式

6.1 编译器指令

• GCC/Clang：__attribute__((aligned(n))) 或 __attribute__((packed))

// 强制 4 字节对齐
struct __attribute__((aligned(4))) aligned_struct {
    char a;
    int b;
};

// 取消对齐 (packed)
struct __attribute__((packed)) packed_struct {
    char a;
    int b;
};

• MSVC：__declspec(align(n))

__declspec(align(16)) struct aligned_struct {
    char a;
    int b;
};

• 通用演示：

// 强制 16 字节对齐
struct alignas(16) AlignedStruct {
    int a;
    double b;
};

// 取消对齐（可能降低性能但节省空间）
#pragma pack(push, 1)
struct PackedStruct {
    char a;
    int b;
    short c;
};
#pragma pack(pop)

6.2 C++11 后的标准方式

alignas(16) int aligned_array[4]; // 16 字节对齐
struct alignas(8) MyStruct {
    char a;
    int b;
};

6.3 跨平台写法

#if defined(_MSC_VER)
#define ALIGN(n) __declspec(align(n))
#else
#define ALIGN(n) __attribute__((aligned(n)))
#endif

ALIGN(8) struct cross_platform_struct {
    int a;
    char b;
};

7. 实际开发中的注意事项

1. 网络传输：传输结构体前应序列化或使用 #pragma pack(1)。
2. 文件 IO：直接读写结构体要考虑对齐差异。
3. 跨平台开发：不同平台对齐要求可能不同。
4. 性能敏感代码：合理安排结构体成员顺序。
5. SIMD 编程：必须保证数据对齐。

8. 实际应用场景

8.1 网络协议处理

#pragma pack(push, 1) // 1 字节对齐
struct network_packet {
    uint16_t header;
    uint32_t length;
    char data[256];
};
#pragma pack(pop) // 恢复默认对齐

8.2 硬件寄存器映射

struct hw_register {
    volatile uint32_t CTRL ALIGN(4);
    volatile uint32_t STATUS ALIGN(4);
    volatile uint32_t DATA ALIGN(4);
};

8.3 性能优化

// 缓存行对齐 (通常 64 字节)
struct cache_line_aligned {
    int data ALIGN(64);
};

9. 检测对齐的方法

// C++11
static_assert(alignof(int) == 4, "int must be 4-byte aligned");

// 运行时检查
bool is_aligned(const void* p, size_t alignment) {
    return (reinterpret_cast<uintptr_t>(p) % alignment) == 0;
}

10. 常见问题与解决方案

10.1 问题 1：非对齐访问导致崩溃（ARM 平台）

char buffer[100];
int *p = (int *)(buffer + 1); // 非对齐指针
*p = 42; // 在 ARM 上可能崩溃

解决方案：确保指针类型转换后的对齐要求。

// 方法 1：使用 memcpy
int value = 42;
memcpy(buffer + 1, &value, sizeof(value));

// 方法 2：确保对齐
int *p = (int *)(buffer + (4 - ((uintptr_t)buffer % 4)));

10.2 问题 2：结构体大小意外过大

解决方案：重新排列成员顺序，把大对齐成员放前面。

10.3 问题 3：跨平台数据不一致

解决方案：使用序列化代替直接内存拷贝。

10.4 问题 4：跨平台结构体大小不一致

解决方案：

1. 使用编译器指令统一对齐方式。
2. 避免直接读写结构体二进制，改用序列化。

11. 调试与检测

11.1 查看对齐值

#include <stddef.h>
printf("int alignment: %zu\n", _Alignof(int));

11.2 检查指针是否对齐

int is_aligned(const void *ptr, size_t alignment) {
    return ((uintptr_t)ptr % alignment) == 0;
}

11.3 静态断言 (C11)

_Static_assert(_Alignof(double) == 8, "double must be 8-byte aligned");

12. 性能影响实测示例

示例一：

// 测试对齐访问的性能差异
void test_aligned_access() {
    const int SIZE = 1000000;
    // 非对齐内存
    char* unaligned = new char[SIZE * 4 + 1];
    int* data1 = reinterpret_cast<int*>(unaligned + 1); // 强制非对齐
    // 对齐内存
    int* data2 = new int[SIZE];
    // 性能测试...
}

示例二：

#include <stdio.h>
#include <time.h>
#define SIZE 10000000

void test_aligned() {
    _Alignas(16) int array[SIZE];
    // 测试对齐访问性能...
}

void test_unaligned() {
    char buffer[SIZE * 4 + 1];
    int *array = (int *)(buffer + 1); // 故意不对齐
    // 测试非对齐访问性能...
}

int main() {
    // 对比两个函数的执行时间
}

13. 高级话题：缓存行对齐

对于多线程编程，避免 false sharing（伪共享）：

struct alignas(64) CacheLineAligned {
    // 典型缓存行大小 64 字节
    int data;
    // 填充剩余空间
};