4、嵌入式C语言基础：指针与内存管理、结构体与联合体、位运算技巧、volatile关键字的使用场景

嵌入式开发里，C语言是绕不开的硬功夫。说实话，很多刚入行的朋友觉得C语言就是语法，背一背就完了。但真正到了低功耗设备上，你会发现——内存就那么大，时钟就那么多，一个指针用错了，系统可能就挂了。今天咱们就聊聊嵌入式C语言里最核心的几个点，都是我这些年踩坑踩出来的经验。

4.1 指针与内存管理：别让指针“飞”了

指针这东西，说白了就是“地址的搬运工”。但在嵌入式里，它比PC上要敏感得多。为什么？因为你的RAM可能只有几KB，甚至几百字节。

我个人的习惯是：每次声明指针，一定初始化。要么指向合法地址，要么赋NULL。你想想看，一个野指针在PC上可能只是段错误，在嵌入式设备上可能就是死机、重启，甚至烧坏外设。

// 错误示范：野指针
int *p;
*p = 100;  // 危险！p指向哪里？不知道！

// 正确做法：明确指向
int value;
int *p = &value;  // 指向栈上的变量

// 或者动态分配（注意检查返回值）
int *p = (int *)malloc(sizeof(int));
if (p != NULL) {
    *p = 100;
    // 用完后记得释放
    free(p);
    p = NULL;  // 避免悬空指针
}

在低功耗场景下，我建议你尽量少用动态内存分配。为什么？因为malloc/free是不确定时间的操作，而且容易产生碎片。对于小内存设备，静态分配 + 内存池是更稳妥的选择。

4.2 结构体与联合体：数据打包的艺术

结构体和联合体，是嵌入式里组织数据的利器。尤其是当你需要和硬件寄存器打交道时，它们几乎是标配。

结构体用来把相关的数据打包在一起。比如一个传感器的数据包：

typedef struct {
    uint8_t  id;       // 传感器ID
    uint16_t value;    // 采样值
    uint8_t  crc;      // 校验码
} SensorData_t;

// 使用
SensorData_t data;
data.id = 0x01;
data.value = 1024;
data.crc = calculate_crc(&data, sizeof(data) - 1);

联合体就更有意思了。它让同一块内存可以被不同方式解读。我在项目中经常用它来做数据解析：

typedef union {
    uint32_t raw;           // 原始32位数据
    struct {
        uint8_t byte0;
        uint8_t byte1;
        uint8_t byte2;
        uint8_t byte3;
    } bytes;                // 按字节拆分
    struct {
        uint16_t low;
        uint16_t high;
    } words;                // 按半字拆分
} Data32_t;

// 实际应用：从SPI读取一个32位寄存器
Data32_t reg;
reg.raw = spi_read_32bit(REG_ADDR);
// 现在你可以用 reg.bytes.byte0 访问最低字节
// 或者用 reg.words.low 访问低16位

不过要注意，结构体和联合体的内存对齐问题。编译器可能会在成员之间插入填充字节，导致结构体大小不是你想象的那样。我建议你显式使用 __attribute__((packed)) 来禁止对齐，尤其是在和硬件寄存器或通信协议打交道时。

typedef struct __attribute__((packed)) {
    uint8_t  a;
    uint16_t b;
    uint32_t c;
} PackedStruct_t;  // 大小 = 1 + 2 + 4 = 7字节，没有填充

4.3 位运算技巧：用最少的指令做最多的事

位运算是嵌入式工程师的“瑞士军刀”。在低功耗设备上，一次位运算可能比一次乘除法快几十倍，而且省电。

常用的位运算场景：

• 置位： REG |= (1 << 3); // 将第3位置1
• 清零： REG &= ~(1 << 3); // 将第3位清0
• 翻转： REG ^= (1 << 3); // 将第3位取反
• 读取： if (REG & (1 << 3)) // 判断第3位是否为1

我个人特别喜欢用宏定义来封装位操作，让代码更清晰：

#define BIT(n)          (1UL << (n))
#define SET_BIT(reg, n) ((reg) |= BIT(n))
#define CLR_BIT(reg, n) ((reg) &= ~BIT(n))
#define GET_BIT(reg, n) (((reg) >> (n)) & 0x01)

// 使用示例：控制GPIO
SET_BIT(GPIOA->ODR, 5);   // PA5输出高电平
CLR_BIT(GPIOA->ODR, 5);   // PA5输出低电平

还有一个技巧：用位域来压缩数据。比如你只需要存储0-7的值，用3个bit就够了，没必要用int8_t浪费5个bit。

typedef struct {
    uint8_t temperature : 7;  // 0-127度，用7位
    uint8_t sign       : 1;   // 符号位，用1位
} TempData_t;  // 总共只占1字节

4.4 volatile关键字：别让编译器“优化”掉你的逻辑

volatile可能是嵌入式C里最容易被忽视的关键字。它的作用就一句话：告诉编译器，这个变量的值可能会被意外改变，不要优化它。

什么时候必须用volatile？

• 硬件寄存器：比如GPIO的输入输出寄存器，值随时可能被硬件改变
• 中断服务程序中修改的变量：主循环和中断共享的变量
• 多线程/多任务共享的变量：在RTOS中，不同任务访问的全局变量

我举个例子，你就明白为什么需要volatile了：

// 错误示范：没有volatile
int flag = 0;

void interrupt_handler() {
    flag = 1;  // 中断中修改flag
}

void main_loop() {
    while (flag == 0) {
        // 等待中断发生
    }
    // 处理事件
}

你猜怎么着？编译器可能会把 flag 优化到寄存器里，然后 while 循环永远读寄存器里的旧值，根本看不到中断修改后的新值。结果就是——程序卡死在循环里。

正确做法：

volatile int flag = 0;  // 告诉编译器：别优化我！

void interrupt_handler() {
    flag = 1;
}

void main_loop() {
    while (flag == 0) {
        // 每次循环都从内存读取flag
    }
}

还有一个容易忽略的点：volatile不能保证原子性。比如对一个32位变量赋值，在8位MCU上可能需要多条指令。如果中断恰好在中间发生，可能会读到半新半旧的值。这时候你需要用关中断或原子操作来保护。

// 非原子操作示例
volatile uint32_t counter;

void interrupt_handler() {
    counter++;  // 在8位MCU上，这可能是3条指令
}

// 正确做法：关中断保护
uint32_t read_counter() {
    uint32_t val;
    __disable_irq();
    val = counter;
    __enable_irq();
    return val;
}

小结

这四个知识点，是嵌入式C语言的基石。指针和内存管理决定了你的程序会不会崩，结构体和联合体决定了你的数据好不好管，位运算决定了你的代码快不快，volatile决定了你的逻辑对不对。

嗯，说实话，这些内容看起来简单，但真正用好需要大量实践。我建议你每学一个知识点，都去自己的开发板上试一试。比如写一个用位运算控制LED的程序，或者用结构体封装一个传感器数据。只有亲手写过，这些知识才是你的。

下一章，我们会聊聊中断和定时器，那又是另一个有意思的话题了。