指针与位操作：用指针操作二进制位、位域与指针、内存对齐与指针

说实话，指针和位操作放在一起讲，很多初学者会觉得这是两个世界的东西。一个管内存地址，一个管二进制位，能有什么交集？

我在嵌入式项目里摸爬滚打这么多年，可以负责任地告诉你：指针是操作位的最高效手段。寄存器配置、协议解析、内存压缩，哪样都离不开它。

一、用指针操作二进制位

C语言里，最小的可寻址单位是字节。但硬件寄存器经常是某一位或某几位有意义。比如一个32位的GPIO控制寄存器，可能第3位控制输出使能，第7-10位控制驱动能力。

这时候，指针就派上用场了。

1. 位操作基础回顾

先看几个基本操作：

// 置位某一位
*(volatile uint32_t *)0x40020C00 |= (1 << 3);

// 清零某一位
*(volatile uint32_t *)0x40020C00 &= ~(1 << 3);

// 读取某一位
uint8_t bit = (*(volatile uint32_t *)0x40020C00 >> 3) & 0x01;

嗯，这里要注意：volatile关键字不能少。我踩过这个坑——编译器优化后，寄存器读出来永远是同一个值，排查了半天。

2. 用指针批量操作位域

有时候我们需要操作连续的几位。比如一个状态寄存器，位4到位7表示错误码：

#define STATUS_REG  ((volatile uint32_t *)0x40021000)

// 读取错误码（位4-7）
uint8_t err_code = (*STATUS_REG >> 4) & 0x0F;

// 写入错误码
*STATUS_REG = (*STATUS_REG & ~(0x0F << 4)) | (new_code << 4);

我个人习惯把这种操作封装成宏，避免到处写魔法数字：

#define GET_BITS(reg, start, len) \
    (((*(volatile uint32_t *)(reg)) >> (start)) & ((1 << (len)) - 1))

#define SET_BITS(reg, start, len, val) \
    (*(volatile uint32_t *)(reg) = \
     (*(volatile uint32_t *)(reg) & ~(((1 << (len)) - 1) << (start))) | \
     ((val) << (start)))

二、位域与指针

C语言提供了位域（bit-field）这个语法糖，让你可以直接定义结构体成员的位宽。听起来很美，但实际用起来有不少坑。

1. 位域的基本用法

struct {
    uint32_t enable : 1;   // 位0
    uint32_t mode   : 2;   // 位1-2
    uint32_t status : 4;   // 位3-6
    uint32_t        : 3;   // 填充位7-9
    uint32_t data   : 22;  // 位10-31
} reg_t;

// 通过指针访问
volatile reg_t *p = (volatile reg_t *)0x40020C00;
p->enable = 1;
p->mode = 2;

你看，代码确实简洁了。但为什么很多嵌入式老手不推荐位域？

2. 位域的陷阱

说白了，位域是编译器相关的。不同编译器对位域的布局规则不一样：

• 位域是从低位开始排，还是从高位开始排？——ARM和x86不一样
• 相邻位域能否合并成一个字？——有些编译器会拆开
• 位域跨字节边界怎么处理？——没有统一标准

3. 位域与指针的交互

位域成员没有地址，你不能取它的指针：

// 错误！不能取位域的地址
uint32_t *p = &reg_t->enable;

// 正确做法：通过指针操作整个寄存器
uint32_t val = *(volatile uint32_t *)p;
val |= (1 << 0);  // 手动操作位0
*(volatile uint32_t *)p = val;

你想想看，位域本质上只是编译器的语法糖，底层还是位运算。既然不能取地址，那指针就派不上用场了。所以我的建议是：位域只用在单平台、非跨编译器的项目中。

三、内存对齐与指针

内存对齐这个话题，说大不大，说小不小。但指针操作一旦涉及对齐问题，轻则性能下降，重则直接崩溃。

1. 什么是对齐？

简单说，就是数据在内存中的起始地址必须是其大小的整数倍。比如：

• uint16_t 的地址必须是2的倍数
• uint32_t 的地址必须是4的倍数
• uint64_t 的地址必须是8的倍数

为什么会这样？因为CPU读取内存时，是一次读一个字（比如4字节）。如果数据跨了两个字，CPU就得读两次，再拼接。性能损失很大。

2. 指针操作与对齐违规

当你用指针强制转换时，最容易出问题：

uint8_t buffer[10] = {0};
uint32_t *p = (uint32_t *)&buffer[1];  // 地址是奇数，不对齐！
*p = 0x12345678;  // 可能崩溃！

在ARM Cortex-M上，这种不对齐访问会触发硬件异常。x86上虽然能运行，但性能会下降好几倍。

3. 结构体对齐与指针偏移

结构体成员之间会有填充字节，这直接影响指针运算：

struct {
    uint8_t  a;   // 偏移0
    // 填充3字节
    uint32_t b;   // 偏移4
    uint16_t c;   // 偏移8
    // 填充2字节（结构体对齐到4字节边界）
} s;

// 用指针访问成员
uint32_t *pb = (uint32_t *)((uint8_t *)&s + 4);  // 手动计算偏移

我个人习惯用offsetof宏来获取偏移量，避免硬编码：

#include <stddef.h>
uint32_t *pb = (uint32_t *)((uint8_t *)&s + offsetof(struct s, b));

4. 对齐控制

有些场景下，我们需要手动控制对齐。比如DMA传输要求缓冲区对齐到缓存行：

// GCC属性指定对齐
uint8_t dma_buffer[1024] __attribute__((aligned(32)));

// 或者用对齐分配
#include <stdlib.h>
void *buf = aligned_alloc(32, 1024);

知识体系图

总结

指针和位操作结合，是嵌入式开发的必修课。我总结了几条实用原则：

1. 能用宏就别用位域——宏是跨平台的，位域不是
2. 指针转换时检查对齐——不对齐的指针是定时炸弹
3. volatile不能省——硬件寄存器必须加，否则编译器优化会坑你
4. 结构体布局要心里有数——填充字节会影响指针偏移计算

记住一句话：指针给了你操作内存的自由，位操作给了你操作硬件的自由。两者结合，就是嵌入式开发的终极自由。但自由越大，责任越大——每个字节、每个位，都要清清楚楚。

---

公众号:蓝海资料掘金营，微信deep3321