【C/C++】详解内存对齐问题，C语言内存对齐整理

struct Example1 
{
    char a;      // 1字节
    int b;       // 4字节（需要从4的倍数地址开始）
    short c;     // 2字节
};
// 大小可能是12字节（1 + 3填充 + 4 + 2 + 2填充）

// 优化前(12字节)
struct bad_layout 
{
    char a;
    int b;
    short c;
};

// 优化后(8字节)
struct good_layout 
{
    int b;
    char a;
    short c;
};

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

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

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

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

__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)

alignas(16) int aligned_array[4];  // 16字节对齐

struct alignas(8) MyStruct 
{
    char a;
    int b;
};

#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;
};

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

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

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

// 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;
}

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)));

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

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

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

// 测试对齐访问的性能差异
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() 
{
    // 对比两个函数的执行时间
}

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