C语言联合体与枚举：内存共享与类型安全实践

markdown复制## 1. 联合体：内存共享的艺术与陷阱

联合体（union）是C语言中一种特殊的数据结构，它允许在同一内存位置存储不同的数据类型。与结构体不同，联合体的所有成员共享同一块内存空间，其大小由最大的成员决定。

### 1.1 联合体的内存布局解析

假设我们定义如下联合体：
```c
union Data {
    int i;
    float f;
    char str[20];
};

这个联合体在内存中的实际占用情况是：

• 总大小为20字节（由char str[20]决定）
• 三个成员变量i/f/str从同一内存地址开始存储
• 修改任一成员都会影响其他成员的值

重要提示：联合体成员的访问必须与最后一次写入的类型一致，否则会导致未定义行为。这是许多隐蔽bug的根源。

1.2 联合体的典型应用场景

场景1：协议解析
在网络通信中，同一个字段可能携带不同类型的数据：

c复制union Packet {
    struct {
        uint8_t type;
        union {
            int32_t int_val;
            float float_val;
            char text[16];
        } payload;
    };
    uint8_t raw_data[20];
};

场景2：寄存器访问
在嵌入式开发中，经常需要以不同方式访问同一硬件寄存器：

c复制union StatusReg {
    uint32_t raw;
    struct {
        uint8_t error_code : 4;
        uint8_t reserved : 3;
        uint8_t ready_flag : 1;
    } bits;
};

1.3 联合体使用中的坑点实录

1. 字节序问题：在跨平台开发时，联合体中整型成员的字节序可能不同

c复制union EndianTest {
    uint32_t num;
    uint8_t bytes[4];
};
// 在小端机器和大端机器上bytes数组的顺序相反

2. 类型混淆风险：没有机制记录当前活跃成员，容易误用

c复制union Data data;
data.f = 3.14;
printf("%d", data.i); // 错误！此时应使用float类型访问

3. 内存对齐陷阱：某些架构下联合体可能有意外padding

c复制union BadAlign {
    char c;
    double d; // 可能导致7字节padding
};

2. 枚举：从魔数到类型安全

枚举（enum）为整型常量提供了更有意义的命名方式，是现代C代码中替代魔数（magic number）的首选方案。

2.1 枚举的底层实现细节

定义示例：

c复制enum Color { RED, GREEN, BLUE = 5, YELLOW };

内存特性：

• 每个枚举常量本质是int类型
• 默认从0开始递增
• 可以显式指定值（BLUE=5）
• YELLOW会自动设为6（前值+1）

2.2 枚举的高级用法技巧

技巧1：位标志枚举

c复制enum FilePerm {
    READ = 1 << 0,    // 0001
    WRITE = 1 << 1,   // 0010 
    EXEC = 1 << 2     // 0100
};
// 使用：
int perm = READ | WRITE; // 0011

技巧2：枚举与switch的完美配合

c复制enum State { IDLE, RUNNING, ERROR };

void handle_state(enum State s) {
    switch(s) {
        case IDLE:    /*...*/ break;
        case RUNNING: /*...*/ break;
        // 编译器会警告是否遗漏case
    }
}

2.3 枚举的现代C用法

C11标准引入了强类型枚举特性：

c复制enum Color : uint8_t { // 指定底层类型
    RED,
    GREEN,
    BLUE
};

实际经验：在大型项目中，给枚举添加前缀可以避免命名冲突，如：

c复制enum LogLevel {
    LOG_DEBUG,
    LOG_INFO,
    LOG_ERROR
};

3. typedef：类型系统的扩展工具

typedef关键字用于为现有类型创建别名，它不创建新类型，只是提供更有语义的类型名称。

3.1 typedef的典型应用模式

模式1：简化复杂类型声明

c复制typedef int (*Comparator)(const void*, const void*);
// 之后可以这样使用：
Comparator cmp = &strcmp;

模式2：平台无关类型定义

c复制typedef uint32_t size_t;  // 标准库中的经典用法
typedef int32_t  errno_t;

模式3：结构体简化

c复制typedef struct {
    int x, y;
} Point;
// 现在可以直接用Point声明变量，而不需要写struct关键字

3.2 typedef的陷阱与争议

1. 过度使用问题：有些项目规范禁止为基本类型创建typedef

   • 反例：typedef int INT32; （没有增加实际价值）

2. 指针类型的困惑：

c复制typedef int* IntPtr;
const IntPtr p1;  // 等同于int *const p1
const int* p2;    // 完全不同！

3. 作用域问题：typedef具有块作用域，可能导致意外覆盖

c复制typedef int MyInt;
{
    typedef double MyInt; // 内层覆盖外层定义
}

4. 位运算：硬件级的高效操作

位运算允许直接操作数据的二进制表示，在系统编程、嵌入式开发等领域至关重要。

4.1 位运算基础回顾

4.2 位运算的实战技巧

技巧1：位掩码应用

c复制#define MASK 0x20
// 设置位
flags |= MASK;  
// 清除位
flags &= ~MASK;
// 切换位
flags ^= MASK;
// 检查位
if (flags & MASK) {...}

技巧2：高效乘除法

c复制x = y << 3;   // 等价于 y * 8
x = y >> 1;   // 等价于 y / 2

技巧3：交换变量值

c复制a ^= b;
b ^= a;
a ^= b;
// 无需临时变量即可交换a和b的值

4.3 位字段：精确控制内存布局

位字段允许定义占用特定位数的结构体成员：

c复制struct {
    unsigned int is_admin : 1;
    unsigned int role : 3;
    unsigned int : 4;  // 无名位域，用于填充
    unsigned int count : 8;
} User;

注意事项：位字段的可移植性问题

• 位字段的分配顺序（从左到右还是从右到左）由实现定义
• 跨平台代码应避免依赖位字段的内存布局

5. 内存管理：从malloc到自定义分配器

C语言的内存管理是开发者的责任，理解内存运作原理对写出健壮程序至关重要。

5.1 动态内存分配全解析

malloc/calloc/realloc对比表

正确使用模式

c复制int *arr = malloc(10 * sizeof(*arr)); // 推荐写法
if (!arr) {
    // 必须检查返回值
    perror("malloc failed");
    exit(EXIT_FAILURE);
}
// 使用内存...
free(arr);
arr = NULL; // 避免悬空指针

5.2 内存池实现实战

对于频繁分配释放固定大小内存的场景，自定义内存池可以大幅提升性能：

c复制#define BLOCK_SIZE 1024
#define POOL_SIZE 100

typedef struct MemoryBlock {
    struct MemoryBlock *next;
    char data[BLOCK_SIZE];
} MemoryBlock;

typedef struct {
    MemoryBlock *free_list;
    MemoryBlock blocks[POOL_SIZE];
} MemoryPool;

void pool_init(MemoryPool *pool) {
    pool->free_list = &pool->blocks[0];
    for (int i = 0; i < POOL_SIZE-1; i++) {
        pool->blocks[i].next = &pool->blocks[i+1];
    }
    pool->blocks[POOL_SIZE-1].next = NULL;
}

void* pool_alloc(MemoryPool *pool) {
    if (!pool->free_list) return NULL;
    void *block = pool->free_list;
    pool->free_list = pool->free_list->next;
    return block;
}

void pool_free(MemoryPool *pool, void *block) {
    MemoryBlock *mb = block;
    mb->next = pool->free_list;
    pool->free_list = mb;
}

5.3 内存错误排查指南

常见内存问题及其表现：

调试技巧：

• 在Linux下使用mtrace()记录malloc/free调用
• GCC编译选项：-fsanitize=address启用地址检查
• 自定义malloc包装器记录分配信息：

c复制void* debug_malloc(size_t size, const char* file, int line) {
    void *p = malloc(size);
    printf("Allocated %zu bytes at %p (%s:%d)\n", size, p, file, line);
    return p;
}
#define malloc(s) debug_malloc(s, __FILE__, __LINE__)

6. 综合应用：协议解析器实现

结合本章所有知识点，我们实现一个简单的网络协议解析器：

c复制typedef enum {
    CMD_GET = 0x01,
    CMD_SET = 0x02,
    CMD_DEL = 0x03
} CommandType;

typedef enum {
    RESP_OK = 0x00,
    RESP_ERROR = 0x80,
    RESP_NOT_FOUND = 0x81
} ResponseCode;

typedef union {
    struct {
        uint32_t int_val;
        double float_val;
        char str_val[16];
    };
    uint8_t raw_data[20];
} Payload;

typedef struct __attribute__((packed)) {
    uint8_t magic;      // 协议魔数 0xAA
    CommandType cmd;    // 命令类型
    uint16_t key;       // 键
    uint8_t payload_len;// 负载长度
    Payload payload;    // 负载数据
    uint8_t checksum;   // 校验和
} ProtocolPacket;

bool validate_packet(const ProtocolPacket *pkt) {
    if (pkt->magic != 0xAA) return false;
    
    uint8_t sum = 0;
    const uint8_t *data = (const uint8_t*)pkt;
    for (size_t i = 0; i < sizeof(*pkt)-1; i++) {
        sum ^= data[i];  // 简单的异或校验
    }
    
    return sum == pkt->checksum;
}

void process_packet(ProtocolPacket *pkt) {
    if (!validate_packet(pkt)) {
        send_error(RESP_ERROR);
        return;
    }
    
    switch (pkt->cmd) {
        case CMD_GET:
            handle_get(pkt->key);
            break;
        case CMD_SET:
            handle_set(pkt->key, &pkt->payload, pkt->payload_len);
            break;
        // ...其他命令处理
    }
}

这个实现展示了：

• 枚举用于命令和响应码定义
• 联合体处理不同类型的负载数据
• 位运算用于校验和计算
• 结构体打包协议格式
• 严格的内存访问控制

7. 性能优化与可移植性考量

7.1 数据对齐优化

现代CPU对非对齐内存访问有性能惩罚，甚至可能引发硬件异常。关键方法：

c复制// 编译器相关属性指定对齐
struct AlignedData {
    uint64_t data1;
    uint32_t data2;
} __attribute__((aligned(8)));  // 8字节对齐

// C11标准方式
#include <stdalign.h>
alignas(16) double critical_array[1024];

7.2 结构体打包技巧

在网络传输和硬件交互场景中，经常需要紧密打包结构体：

c复制#pragma pack(push, 1)  // 保存当前对齐设置，并设置为1字节对齐
typedef struct {
    uint8_t type;
    uint32_t value;
} PackedStruct;
#pragma pack(pop)       // 恢复之前的对齐设置

警告：打包结构体可能导致性能下降，且不同编译器pragma语法可能不同

7.3 跨平台兼容性方案

1. 固定宽度整数类型：

c复制#include <stdint.h>
uint32_t platform_independent;  // 总是32位无符号整型

2. 字节序转换函数：

c复制uint32_t ntohl(uint32_t netlong);  // 网络字节序转主机字节序
uint16_t htons(uint16_t hostshort); // 主机字节序转网络字节序

3. 可移植位操作：

c复制// 代替直接移位操作
uint32_t rotate_left(uint32_t x, uint8_t shift) {
    return (x << shift) | (x >> (32 - shift));
}

8. 深度调试技巧与工具链集成

8.1 GDB高级调试技巧

对于复杂数据结构，GDB可以自定义打印格式：

gdb复制# 在.gdbinit中添加：
define print_packet
    printf "Magic: 0x%02X\n", $arg0.magic
    printf "Command: %d\n", $arg0.cmd
    # ...其他字段
end

8.2 静态分析工具集成

推荐工具链配置：

1. 编译时检查：

   bash复制gcc -Wall -Wextra -Werror -fsanitize=undefined
   

2. Clang静态分析：

   bash复制scan-build make
   

3. 动态分析：

   bash复制valgrind --leak-check=full ./program
   

8.3 自定义内存调试系统

在调试版本中替换标准内存函数：

c复制#ifdef DEBUG
#define malloc(s) debug_malloc(s, __FILE__, __LINE__)
#define free(p) debug_free(p, __FILE__, __LINE__)

typedef struct {
    void *ptr;
    size_t size;
    const char *file;
    int line;
} AllocRecord;

AllocRecord alloc_log[1000];
int alloc_count = 0;

void* debug_malloc(size_t size, const char *file, int line) {
    void *p = malloc(size);
    alloc_log[alloc_count++] = (AllocRecord){p, size, file, line};
    return p;
}

void debug_free(void *p, const char *file, int line) {
    // 检查双重释放等错误
    free(p);
}
#endif

9. 现代C标准中的改进

C11/C17引入了一些对构造数据类型有用的新特性：

9.1 匿名结构体/联合体

c复制struct SensorData {
    int type;
    union {
        struct { float temp, humidity; }; // 匿名结构体
        struct { int x, y, z; };          // 另一个匿名结构体
    };
};

// 使用更简洁：
SensorData data;
data.temp = 23.5;  // 直接访问，不需要中间成员名

9.2 类型泛型表达式

c复制#define cbrt(X) _Generic((X), \
    long double: cbrtl, \
    default: cbrt, \
    float: cbrtf \
)(X)

9.3 对齐内存分配

c复制#include <stdalign.h>
void *aligned_alloc(size_t alignment, size_t size);

10. 项目实战：实现简易数据库存储引擎

结合所有知识点，我们设计一个极简的键值存储引擎：

c复制typedef enum {
    NODE_INTERNAL,
    NODE_LEAF
} NodeType;

#pragma pack(push, 1)
typedef struct {
    uint32_t page_num;
    NodeType node_type;
    uint8_t is_dirty;
    uint16_t cell_count;
    uint32_t right_child;  // 仅内部节点使用
    char data[PAGE_SIZE - 12]; // 实际数据区
} BTreeNode;
#pragma pack(pop)

typedef union {
    struct {
        uint32_t key;
        uint32_t data_offset;
        uint32_t data_length;
    } index_entry;
    char record_data[MAX_RECORD_SIZE];
} Cell;

// 页管理核心函数
BTreeNode* fetch_page(uint32_t page_num) {
    BTreeNode *page = cache_lookup(page_num);
    if (!page) {
        page = aligned_alloc(PAGE_SIZE, PAGE_SIZE);
        disk_read(page_num, page);
        cache_insert(page_num, page);
    }
    return page;
}

// 插入记录
bool insert_record(uint32_t key, const char *value, size_t len) {
    BTreeNode *leaf = find_leaf(key);
    if (leaf->cell_count >= MAX_CELLS_PER_PAGE) {
        split_leaf(leaf);
        leaf = find_leaf(key);
    }
    
    Cell *cell = allocate_cell(leaf);
    cell->index_entry.key = key;
    cell->index_entry.data_offset = ...;
    // 处理value存储...
    
    leaf->is_dirty = 1;
    return true;
}

这个实现展示了：

• 枚举定义节点类型
• 结构体定义磁盘页格式
• 联合体处理不同类型的单元格
• 位标志记录页状态
• 严格的内存对齐控制
• 自定义内存管理策略

11. 性能对比与优化决策

在实际项目中，选择合适的数据结构需要权衡多方面因素：

11.1 结构体vs联合体性能测试

测试场景：处理100万个包含int/float/string的数据项

结论：在内存受限但类型明确的场景，联合体优势明显；在需要频繁访问的场景，结构体更合适

11.2 位字段vs位运算对比

11.3 内存分配策略选择

根据应用场景选择合适的内存管理方式：

1. 通用分配器（malloc/free）：

   • 适合：分配大小、生命周期不可预测
   • 缺点：碎片化，性能不稳定

2. 对象池：

   • 适合：频繁分配释放固定大小对象
   • 实现：预先分配对象数组，空闲链表管理

3. 区域分配器：

   • 适合：阶段性使用的临时对象
   • 特点：批量释放整个区域

4. 栈分配器：

   • 适合：严格LIFO顺序的内存使用
   • 优点：极高性能，无碎片

12. 行业最佳实践与代码规范

12.1 构造数据类型的命名约定

1. 结构体：

   c复制typedef struct customer_s {  // _s后缀表示结构体
       uint32_t id;
       char name[MAX_NAME];
   } customer_t;                // _t后缀表示类型
   

2. 枚举：

   c复制typedef enum color_e {       // _e后缀表示枚举
       COLOR_RED,              // 全大写+前缀
       COLOR_GREEN,
       COLOR_BLUE
   } color_t;
   

3. 联合体：

   c复制typedef union value_u {      // _u后缀表示联合体
       int32_t int_val;
       double float_val;
   } value_t;
   

12.2 防御性编程技巧

1. 结构体验证函数：

   c复制bool customer_valid(const customer_t *c) {
       return c && c->id != 0 && c->name[0] != '\0';
   }
   

2. 枚举范围检查：

   c复制bool color_valid(color_t c) {
       return c >= COLOR_RED && c <= COLOR_BLUE;
   }
   

3. 联合体类型标记：

   c复制typedef struct {
       enum { INT, FLOAT } type;
       union {
           int i;
           float f;
       } value;
   } tagged_union;
   

12.3 跨模块接口设计

在模块边界处，建议：

1. 使用不透明指针隐藏实现细节：

   c复制// 头文件中
   typedef struct database_s database_t;
   database_t* db_open(const char *path);
   void db_close(database_t *db);
   

2. 提供明确的构造/析构函数：

   c复制customer_t* customer_create(uint32_t id, const char *name);
   void customer_destroy(customer_t *c);
   

3. 对复杂结构体提供序列化接口：

   c复制size_t customer_serialize(const customer_t *c, uint8_t *buf, size_t size);
   customer_t* customer_deserialize(const uint8_t *data, size_t size);
   

13. 从C到C++：兼容性考量

虽然本文聚焦C语言，但在混合编程场景下需要注意：

13.1 头文件保护措施

确保头文件在C++中可安全包含：

c复制#ifdef __cplusplus
extern "C" {
#endif

// C语言声明...

#ifdef __cplusplus
}
#endif

13.2 类型兼容性处理

1. 枚举类型：

   • C++中枚举是真正的类型，不能隐式转换为int
   • 解决方案：显式指定底层类型

     c复制enum color : uint8_t { RED, GREEN, BLUE };
     

2. 结构体标签：

   • C中struct tag和typedef是不同的
   • C++中struct Tag可以直接作为类型名使用

3. 内存布局保证：

   • 使用static_assert验证跨语言类型兼容性

     c复制static_assert(sizeof(struct CStruct) == sizeof(CppClass), "Size mismatch");
     

14. 终极挑战：实现类型安全的泛型容器

虽然C语言没有原生泛型支持，但我们可以通过精心设计模拟基本泛型：

c复制// 类型安全的vector实现
#define DECLARE_VECTOR(type) \
    typedef struct { \
        type *data; \
        size_t size; \
        size_t capacity; \
    } vector_##type; \
    \
    void vector_##type##_init(vector_##type *v) { \
        v->data = NULL; \
        v->size = 0; \
        v->capacity = 0; \
    } \
    /* 其他操作函数... */

// 使用示例
DECLARE_VECTOR(int)
DECLARE_VECTOR(float)

int main() {
    vector_int vi;
    vector_int_init(&vi);
    
    vector_float vf;
    vector_float_init(&vf);
}

这种技术结合了：

• 预处理器的代码生成能力
• 结构体封装数据
• 类型安全的接口
• 避免使用void*带来的类型不安全问题

15. 专家级技巧：元编程与代码生成

对于需要大量重复定义的场景，可以考虑使用X-Macro技术：

c复制// 定义数据结构描述
#define COLOR_ENUM \
    X(RED, 0)      \
    X(GREEN, 1)    \
    X(BLUE, 2)

// 生成枚举定义
#define X(name, value) name = value,
typedef enum { COLOR_ENUM } Color;
#undef X

// 生成字符串转换函数
const char* color_to_string(Color c) {
    switch(c) {
        #define X(name, value) case name: return #name;
        COLOR_ENUM
        #undef X
        default: return "UNKNOWN";
    }
}

这种方法特别适合：

• 协议定义
• 状态机实现
• 需要多种表示形式的数据

16. 性能关键型代码的优化

对于性能敏感的场景，需要考虑以下优化策略：

16.1 数据布局优化

原始结构体：

c复制struct BadLayout {
    char c;     // 1字节
                // 3字节padding
    int i;      // 4字节
    double d;   // 8字节
    char s[3];  // 3字节
                // 5字节padding
};              // 总计24字节

优化后结构体：

c复制struct GoodLayout {
    double d;   // 8字节
    int i;      // 4字节
    char s[3];  // 3字节
    char c;     // 1字节
};              // 总计16字节（无padding）

16.2 热点代码的手动优化

对于关键循环中的位操作，可以考虑汇编实现：

c复制uint32_t bit_reverse(uint32_t x) {
    asm volatile (
        "movl %0, %%eax\n"
        "bswap %%eax\n"
        "mov %%eax, %0"
        : "=r" (x)
        : "0" (x)
        : "eax"
    );
    return x;
}

16.3 缓存友好设计

1. 结构体拆分：

   c复制// 原始设计
   struct Entity {
       int id;
       Vector3 position;
       bool active;  // 高频访问
       // ...其他字段
   };
   
   // 优化设计
   struct EntityMeta {
       int id;
       Vector3 position;
       // ...低频访问字段
   };
   
   struct EntityState {
       bool active;  // 单独紧凑存储
       // ...其他高频字段
   };
   

2. 预取模式：

   c复制for (int i = 0; i < count; i += CACHE_LINE_SIZE/sizeof(Item)) {
       __builtin_prefetch(&items[i + PREFETCH_AHEAD]);
       // 处理items[i]...
   }
   

17. 嵌入式系统特殊考量

在资源受限环境中，需要特别注意：

17.1 内存受限环境技巧

1. 联合体复用内存：

   c复制union {
       struct {
           uint8_t rx_buf[128];
       } uart_state;
       struct {
           uint8_t tx_buf[64];
           uint8_t rx_buf[64];
       } spi_state;
   } comm;  // 共用128字节内存
   

2. 位域压缩配置：

   c复制struct {
       unsigned baud_rate : 4;  // 16种可能值
       unsigned parity : 2;     // 无/奇/偶
       unsigned stop_bits : 1;  // 1或2
   } uart_config;
   

17.2 寄存器映射实践

c复制typedef struct {
    volatile uint32_t CR;     // 控制寄存器
    volatile uint32_t SR;     // 状态寄存器
    volatile uint32_t DR;     // 数据寄存器
} UART_Registers;

#define UART0 ((UART_Registers*)0x40001000)

void uart_init() {
    UART0->CR |= (1 << 0);  // 使能UART
}

关键点：volatile关键字防止编译器优化寄存器访问

18. 测试策略与验证方法

确保构造数据类型正确性的方法：

18.1 静态断言检查

c复制// 编译时验证结构体大小
_Static_assert(sizeof(struct Packet) == 32, "Packet size mismatch");

// 验证偏移量
_Static_assert(offsetof(struct Packet, payload) == 8, "Payload offset wrong");

18.2 单元测试模式

c复制void test_union_payload() {
    union Payload p;
    p.int_val = 0x12345678;
    assert(p.bytes[0] == 0x78); // 检查字节序
    // ...其他测试
}

void test_bit_operations() {
    assert(rotate_left(0x1, 4) == 0x10);
    assert(bit_count(0xF0F0) == 8);
    // ...其他测试
}

18.3 模糊测试策略

c复制// 使用随机数据测试协议解析鲁棒性
void fuzz_protocol_parser() {
    uint8_t random_data[1024];
    for (int i = 0; i < 10000; i++) {
        fill_random(random_data, sizeof(random_data));
        ProtocolPacket *pkt = (ProtocolPacket*)random_data;
        process_packet(pkt);  // 不应该崩溃
    }
}

19. 安全编程实践

19.1 防御性内存操作

1. 安全内存复制：

   c复制void safe_copy(void *dest, const void *src, size_t n) {
       if (dest && src && n > 0) {
           size_t i;
           for (i = 0; i < n; i++) {
               ((char*)dest)[i] = ((char*)src)[i];
           }
       }
   }
   

2. 结构体清零：

   c复制void secure_erase(void *ptr, size_t size) {
       if (ptr) {
           volatile uint8_t *p = ptr;
           while (size--) *p++ = 0;
       }
   }
   

19.2 输入验证模式

c复制bool validate_packet(const ProtocolPacket *pkt) {
    // 检查魔数
    if (pkt->magic != PROTOCOL_MAGIC) return false;
    
    // 检查负载长度
    if (pkt->payload_len > MAX_PAYLOAD) return false;
    
    // 检查保留位
    if (pkt->reserved != 0) return false;
    
    // 校验和验证
    return compute_checksum(pkt) == pkt->checksum;
}

20. 现代硬件特性利用

20.1 SIMD指令优化

c复制#include <immintrin.h>

void vector_add(float *a, float *b, float *result, int count) {
    for (int i = 0; i < count; i += 8) {
        __m256 va = _mm256_load_ps(&a[i]);
        __m256 vb = _mm256_load_ps(&b[i]);
        __m256 vresult = _mm256_add_ps(va, vb);
        _mm256_store_ps(&result[i], vresult);
    }
}

20.2 原子操作支持

c复制#include <stdatomic.h>

typedef struct {
    _Atomic uint32_t counter;
} ThreadSafeCounter;

void increment(ThreadSafeCounter *c) {
    atomic_fetch_add(&c->counter, 1);
}

20.3 缓存行对齐

c复制// 保证结构体独占缓存行（通常64字节）
struct CacheAligned {
    uint64_t data[8];  // 64字节
} __attribute__((aligned(64)));