摘自：一枚嵌入式码农
链接：https://mp.weixin.qq.com/s/iJDzVfzOv1bm-tkmTLJFag

大多数初学者只把结构体当作简单的"数据打包箱"，把 int、char 放在一起就完事了。但在资源受限的嵌入式系统中，结构体远不止于此——它是内存布局的蓝图，更是软件架构的基石。

今天分享 5 个嵌入式开发中结构体的高级技巧，帮你写出更优雅、高效的代码。

一、内存对齐与压缩 —— 寸土寸金的艺术

为什么 sizeof 的结果总比预期大？

先看一个"反直觉"的例子：

struct Example {
    char  a;   // 1 字节
    int   b;   // 4 字节
    short c;   // 2 字节
};
// 你以为是 7 字节？实际是 12 字节！

这就是内存对齐在作怪。CPU 访问对齐的数据效率更高，所以编译器会自动插入填充字节（Padding）。

优化技巧：大鱼吃小鱼

把大的成员放前面，小的放后面，可以有效减少填充：

struct OptimizedExample {
    int   b;   // 4 字节
    short c;   // 2 字节
    char  a;   // 1 字节
};
// 优化后只有 8 字节！

取消对齐：通信协议必备

定义网络数据包时，必须保证结构体与字节流一一对应：

#pragma pack(1)  // 或 __attribute__((packed))
struct ProtocolPacket {
    uint8_t  header;
    uint32_t timestamp;
    uint16_t length;
    uint8_t  checksum;
};  // 精确 8 字节，无填充
#pragma pack()

⚠️ 避坑提醒：取消对齐会降低 CPU 访问效率，某些 ARM 平台访问非对齐地址甚至会触发硬件异常。只在必要时使用。

二、位域（Bit-fields）—— 榨干每一个比特

用 1 字节存 8 个开关状态

传统做法用 8 个 bool 变量需要 8 字节，位域只需要 1 字节

struct LedControl {
    uint8_t led0 : 1;
    uint8_t led1 : 1;
    uint8_t led2 : 1;
    uint8_t led3 : 1;
    uint8_t led4 : 1;
    uint8_t led5 : 1;
    uint8_t led6 : 1;
    uint8_t led7 : 1;
};  // 仅占 1 字节！

寄存器映射：硬件操作神器

直接用位域映射 MCU 寄存器，代码可读性拉满：

typedef struct {
    uint32_t EN     : 1;   // 使能位
    uint32_t DIR    : 1;   // 方向位
    uint32_t MODE   : 2;   // 模式选择
    uint32_t SPEED  : 3;   // 速度档位
    uint32_t RESERVED : 25;
} GPIO_CR_TypeDef;

// 使用时像操作普通变量一样直观
GPIO->CR.EN = 1;
GPIO->CR.MODE = 2;

⚠️ 高能预警：位域在不同编译器、不同大小端模式下的排列顺序可能不同！跨平台项目慎用，这是面试常考点，也是工程大坑。

三、柔性数组 —— 变长数据包的神器

传统方法的痛点

处理变长数据时，传统做法需要两次 malloc：

struct OldPacket {
    uint16_t length;
    uint8_t *data;  // 指针成员
};
// 需要分别分配结构体和数据，容易造成内存碎片

柔性数组：一次分配，内存连续

struct FlexPacket {
    uint16_t length;
    uint8_t  data[];  // 柔性数组，必须是最后一个成员
};

// 分配时一步到位
struct FlexPacket *pkt = malloc(sizeof(struct FlexPacket) + data_len);
pkt->length = data_len;
memcpy(pkt->data, source, data_len);

// 释放也只需要一次
free(pkt);

应用场景：解析 TLV（Type-Length-Value）格式的通信协议，处理不定长的串口数据帧。

四、C 语言实现"面向对象" —— 继承与多态

谁说 C 语言不能面向对象？结构体完全可以模拟。

模拟继承：结构体嵌套

将"父类"作为"子类"的第一个成员：

// 父类：形状
struct Shape {
    int x, y;  // 坐标
};

// 子类：圆形
struct Circle {
    struct Shape base;  // 继承 Shape
    int radius;         // 新增属性
};

// 强制转换实现多态
struct Circle c = {{10, 20}, 5};
struct Shape *s = (struct Shape *)&c;  // 子类指针转父类

模拟多态：函数指针表

用函数指针实现"虚函数"：

// 定义操作接口
struct StorageOps {
    int (*init)(void);
    int (*read)(uint32_t addr, uint8_t *buf, uint32_t len);
    int (*write)(uint32_t addr, uint8_t *buf, uint32_t len);
};

// SPI Flash 驱动
struct StorageOps spi_flash_ops = {
    .init  = spi_flash_init,
    .read  = spi_flash_read,
    .write = spi_flash_write,
};

// I2C EEPROM 驱动
struct StorageOps i2c_eeprom_ops = {
    .init  = i2c_eeprom_init,
    .read  = i2c_eeprom_read,
    .write = i2c_eeprom_write,
};

// 上层统一调用，不关心底层是什么存储器
struct StorageOps *storage = &spi_flash_ops;
storage->read(0x1000, buffer, 256);

应用场景：编写硬件抽象层（HAL），统一不同外设的操作接口。

五、container_of —— Linux 内核的黑魔法

问题：已知成员地址，如何反推结构体首地址？

这在链表操作、回调函数传参中非常常见。

核心宏定义

#define offsetof(TYPE, MEMBER) ((size_t)&((TYPE *)0)->MEMBER)

#define container_of(ptr, type, member) \
    ((type *)((char *)(ptr) - offsetof(type, member)))

使用示例

struct Device {
    int id;
    char name[16];
    struct ListNode node;  // 链表节点
};

// 遍历链表时，拿到的是 node 的地址
// 用 container_of 反推出 Device 的地址
struct Device *dev = container_of(node_ptr, struct Device, node);
printf("Device ID: %d\n", dev->id);

这是阅读 Linux 内核源码的必备知识，几乎所有内核子系统都在用这个技巧。

总结

结构体不仅仅是数据的集合，更是内存布局的蓝图和软件架构的基石。掌握这些技巧，你的嵌入式代码将更加优雅高效。