17、设计模式：使用位域实现状态机、使用位域实现权限管理

位域这东西，很多人觉得它就是个节省内存的小技巧。说实话，这种看法有点浪费了。我在嵌入式项目里摸爬滚打这么多年，发现位域真正的威力在于——它能帮你写出极其优雅的状态机和权限管理系统。

今天我们就来聊聊，怎么用位域实现这两个经典的设计模式。

17.1 位域实现状态机

状态机在嵌入式系统里太常见了。按键检测、通信协议、任务调度……到处都是它的影子。传统做法是用枚举 + switch-case，代码一长就乱成一锅粥。

我个人习惯用位域来管理状态。为什么？因为位域天然适合表示「一组互斥的状态」和「一组并发的标志」。

17.1.1 状态机的位域设计

先看一个简单的例子：一个设备的状态机，包含空闲、初始化、运行、错误四个状态。

// 状态定义：每个状态占1位
typedef enum {
    STATE_IDLE      = 0x01,  // 0001
    STATE_INIT      = 0x02,  // 0010
    STATE_RUNNING   = 0x04,  // 0100
    STATE_ERROR     = 0x08   // 1000
} device_state_t;

// 状态机结构体
typedef struct {
    union {
        uint8_t state;        // 整个状态字节
        struct {
            uint8_t idle    : 1;  // bit0
            uint8_t init    : 1;  // bit1
            uint8_t running : 1;  // bit2
            uint8_t error   : 1;  // bit3
            uint8_t reserved: 4;  // bit4-bit7
        } bits;
    };
    uint8_t event;            // 当前触发的事件
} state_machine_t;

你可能会问：为什么不用枚举直接赋值？嗯，这里有个关键点——位域允许你同时检查多个状态。这在某些场景下非常有用。

17.1.2 状态切换与事件处理

// 事件定义
#define EVENT_NONE      0
#define EVENT_START     1
#define EVENT_STOP      2
#define EVENT_ERROR     3
#define EVENT_RESET     4

// 状态切换函数
void state_machine_process(state_machine_t *sm, uint8_t event) {
    sm->event = event;
    
    // 清空当前状态
    sm->bits.idle = 0;
    sm->bits.init = 0;
    sm->bits.running = 0;
    sm->bits.error = 0;
    
    switch(event) {
        case EVENT_START:
            sm->bits.init = 1;      // 进入初始化状态
            break;
        case EVENT_STOP:
            sm->bits.idle = 1;      // 回到空闲
            break;
        case EVENT_ERROR:
            sm->bits.error = 1;     // 错误状态
            break;
        case EVENT_RESET:
            sm->bits.idle = 1;      // 复位到空闲
            break;
        default:
            // 保持当前状态不变
            break;
    }
}

17.1.3 状态机的可视化

下面这张图展示了位域状态机的核心逻辑。每个状态对应一个独立的位，切换时只需修改对应的位即可。

17.2 位域实现权限管理

权限管理是另一个位域大显身手的领域。你想想看，一个系统里可能有读、写、执行、删除、修改……一堆权限。如果用布尔变量，每个权限一个字段，结构体得膨胀成什么样？

用位域就优雅多了。每个权限占1位，一个uint8_t就能管理8种权限，一个uint32_t能管32种。这在资源受限的嵌入式系统里简直是救命稻草。

17.2.1 权限定义与结构体设计

// 权限位定义
#define PERM_READ       (1 << 0)  // 0000 0001
#define PERM_WRITE      (1 << 1)  // 0000 0010
#define PERM_EXECUTE    (1 << 2)  // 0000 0100
#define PERM_DELETE     (1 << 3)  // 0000 1000
#define PERM_MODIFY     (1 << 4)  // 0001 0000
#define PERM_ADMIN      (1 << 5)  // 0010 0000

// 权限结构体
typedef struct {
    union {
        uint8_t permission;       // 整个权限字节
        struct {
            uint8_t read    : 1;  // 可读
            uint8_t write   : 1;  // 可写
            uint8_t execute : 1;  // 可执行
            uint8_t delete  : 1;  // 可删除
            uint8_t modify  : 1;  // 可修改
            uint8_t admin   : 1;  // 管理员权限
            uint8_t reserved: 2;  // 保留位
        } bits;
    };
} permission_t;

17.2.2 权限检查与设置

// 设置权限
void permission_set(permission_t *perm, uint8_t perm_mask) {
    perm->permission |= perm_mask;
}

// 清除权限
void permission_clear(permission_t *perm, uint8_t perm_mask) {
    perm->permission &= ~perm_mask;
}

// 检查权限
bool permission_check(permission_t *perm, uint8_t perm_mask) {
    return (perm->permission & perm_mask) == perm_mask;
}

// 使用示例
void example_usage() {
    permission_t user_perm = {0};
    
    // 给用户赋予读+写权限
    permission_set(&user_perm, PERM_READ | PERM_WRITE);
    
    // 检查是否有执行权限
    if (permission_check(&user_perm, PERM_EXECUTE)) {
        // 允许执行
    } else {
        // 拒绝执行
    }
    
    // 检查是否有读+写权限
    if (permission_check(&user_perm, PERM_READ | PERM_WRITE)) {
        // 允许读写操作
    }
}

17.2.3 权限组合与角色管理

实际项目中，我们经常需要定义不同的角色，每个角色对应一组权限。用位域实现起来非常直观：

// 角色定义
#define ROLE_GUEST      (PERM_READ)                          // 仅可读
#define ROLE_USER       (PERM_READ | PERM_WRITE | PERM_EXECUTE)  // 读+写+执行
#define ROLE_MODERATOR  (PERM_READ | PERM_WRITE | PERM_EXECUTE | PERM_DELETE | PERM_MODIFY)
#define ROLE_ADMIN      (PERM_READ | PERM_WRITE | PERM_EXECUTE | PERM_DELETE | PERM_MODIFY | PERM_ADMIN)

// 角色分配
void assign_role(permission_t *perm, uint8_t role_mask) {
    perm->permission = role_mask;
}

// 检查角色
bool is_admin(permission_t *perm) {
    return permission_check(perm, PERM_ADMIN);
}

17.3 位域状态机 vs 位域权限管理

这两种模式虽然都用位域，但设计思路完全不同：

对比维度	状态机	权限管理
位的关系	互斥（同一时刻只有1位为1）	独立（多个位可以同时为1）
操作方式	清空所有位，再设置目标位	按位或/与/非操作
典型应用	设备状态、协议状态	用户权限、文件权限
位域数量	通常4-8个状态	可以扩展到32个权限
调试难度	低（一眼看出当前状态）	中（需要位掩码计算）

17.4 避坑指南

用位域实现这些模式，有几个坑我踩过，分享给你：

• 位域的内存布局是编译器相关的——不同编译器可能把位域从高位到低位排列，也可能反过来。跨平台项目要小心。
• 位域不能取地址——你不能对位域成员使用&操作符。如果需要指针操作，用联合体里的整型字段。
• 位域操作不是原子操作——在多线程或中断环境下，读-改-写操作可能被中断打断。需要加锁或使用原子操作。
• 位域类型要用无符号整型——用int可能导致符号扩展问题，我吃过这个亏。

好了，位域在状态机和权限管理中的应用就聊到这里。这两种模式在实际项目中非常实用，尤其是资源受限的嵌入式系统。下次你写状态机或权限管理时，不妨试试位域方案——代码会更简洁，运行效率也更高。

---

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