20、回调函数进阶：函数指针数组，状态机实现。

好，咱们继续深入。上一章聊了回调函数的基本用法，说白了就是把函数当参数传。但实际项目里，尤其是嵌入式系统，需求往往更复杂。你可能会遇到这种情况：根据不同的条件，要调用不同的处理函数。用一堆 if-else 或者 switch-case 去判断？代码会变得又臭又长，维护起来想哭。

这时候，函数指针数组就派上大用场了。它跟状态机结合，简直是嵌入式开发的黄金搭档。我个人习惯，只要状态切换逻辑超过 5 个，我肯定上这个组合。

20.1 函数指针数组：把函数放进表格里

先看个基础概念。函数指针数组，就是一个数组，里面的每个元素都是一个函数指针。说白了，就是一张“函数表格”。

定义方式有点绕，但记住这个模板就行：

// 定义一个函数指针类型，指向返回值为int，参数为int的函数
typedef int (*func_ptr_t)(int);

// 声明一个函数指针数组，包含3个元素
func_ptr_t func_table[3];

嗯，这里要注意。用 typedef 把函数指针类型起个别名，代码会清爽很多。不然每次写 int (*p[3])(int) 这种，自己都容易看花眼。

初始化也很直接：

int add_one(int x) { return x + 1; }
int double_it(int x) { return x * 2; }
int square_it(int x) { return x * x; }

func_ptr_t func_table[3] = {
    add_one,
    double_it,
    square_it
};

// 调用：通过索引选择函数
int result = func_table[1](5);  // 结果是 10

你看，这样就把“选择执行哪个函数”变成了“选择数组下标”。是不是有点像查表？

核心思想：函数指针数组的本质，是用数据驱动逻辑。把“判断-分支”的流程，变成了“查表-执行”。

20.2 状态机：嵌入式里的万能框架

状态机（State Machine）这个概念，做嵌入式的应该都不陌生。一个系统有若干状态，每个状态下遇到事件，会执行特定动作，然后跳转到下一个状态。

传统的实现方式，就是嵌套的 switch-case：

switch(current_state) {
    case STATE_IDLE:
        if(event == EVT_START) {
            // 执行动作
            current_state = STATE_RUNNING;
        }
        break;
    case STATE_RUNNING:
        // ...
        break;
}

这种写法，状态少的时候还行。一旦状态超过 10 个，事件超过 5 个，代码就变成一坨“意大利面条”了。我曾经在一个项目里接手过这种代码，一个 switch 分支写了 800 行，改一个 bug 要翻半天。

那怎么优化？用函数指针数组 + 状态表。

20.3 状态表驱动：把状态机变成一张二维表

我们把每个状态下的“事件处理函数”存到一张二维表里。行是当前状态，列是触发事件。表格里的每个格子，就是一个函数指针。

先定义状态和事件：

typedef enum {
    STATE_IDLE,
    STATE_RUNNING,
    STATE_PAUSED,
    STATE_ERROR,
    STATE_COUNT  // 状态总数，用于数组大小
} state_t;

typedef enum {
    EVT_START,
    EVT_STOP,
    EVT_PAUSE,
    EVT_RESUME,
    EVT_ERROR,
    EVT_COUNT   // 事件总数
} event_t;

然后定义状态处理函数。每个函数都做三件事：执行动作、返回下一个状态。

// 函数指针类型：接收事件，返回新状态
typedef state_t (*state_handler_t)(event_t);

// 空闲状态处理
state_t idle_handler(event_t evt) {
    switch(evt) {
        case EVT_START:
            printf("启动设备\n");
            return STATE_RUNNING;
        case EVT_ERROR:
            return STATE_ERROR;
        default:
            return STATE_IDLE;
    }
}

// 运行状态处理
state_t running_handler(event_t evt) {
    switch(evt) {
        case EVT_STOP:
            printf("停止设备\n");
            return STATE_IDLE;
        case EVT_PAUSE:
            printf("暂停设备\n");
            return STATE_PAUSED;
        case EVT_ERROR:
            return STATE_ERROR;
        default:
            return STATE_RUNNING;
    }
}

// 暂停状态处理
state_t paused_handler(event_t evt) {
    switch(evt) {
        case EVT_RESUME:
            printf("恢复运行\n");
            return STATE_RUNNING;
        case EVT_STOP:
            return STATE_IDLE;
        case EVT_ERROR:
            return STATE_ERROR;
        default:
            return STATE_PAUSED;
    }
}

// 错误状态处理
state_t error_handler(event_t evt) {
    // 只有复位事件能退出错误状态
    if(evt == EVT_STOP) {
        printf("复位设备\n");
        return STATE_IDLE;
    }
    return STATE_ERROR;
}

关键来了——定义状态表：

// 状态表：行 = 当前状态，列 = 事件
// 每个格子是一个处理函数
state_handler_t state_table[STATE_COUNT][EVT_COUNT] = {
    // STATE_IDLE 行
    {
        idle_handler,   // EVT_START
        NULL,           // EVT_STOP (空闲状态不处理停止)
        NULL,           // EVT_PAUSE
        NULL,           // EVT_RESUME
        error_handler   // EVT_ERROR
    },
    // STATE_RUNNING 行
    {
        NULL,           // EVT_START
        running_handler,// EVT_STOP
        running_handler,// EVT_PAUSE
        NULL,           // EVT_RESUME
        error_handler   // EVT_ERROR
    },
    // STATE_PAUSED 行
    {
        NULL,           // EVT_START
        paused_handler, // EVT_STOP
        NULL,           // EVT_PAUSE
        paused_handler, // EVT_RESUME
        error_handler   // EVT_ERROR
    },
    // STATE_ERROR 行
    {
        NULL,           // EVT_START
        error_handler,  // EVT_STOP
        NULL,           // EVT_PAUSE
        NULL,           // EVT_RESUME
        NULL            // EVT_ERROR (错误中再出错，忽略)
    }
};

最后，状态机引擎就极其简洁了：

state_t current_state = STATE_IDLE;

void process_event(event_t evt) {
    state_handler_t handler = state_table[current_state][evt];
    if(handler != NULL) {
        current_state = handler(evt);
    }
    // 如果 handler 为 NULL，表示当前状态不处理该事件，直接忽略
}

你想想看，整个状态机的核心逻辑，就浓缩在这几行代码里。要增加新状态或新事件？只需要：

  1. 在枚举里加一项
  2. 写一个新的处理函数
  3. 在状态表里填上对应的格子

完全不需要改动引擎代码。这就是开闭原则的体现——对扩展开放，对修改关闭。

我的经验：在实际项目中，我习惯把状态表定义成 const 常量，放在 Flash 里。这样既节省 RAM，又防止运行时被意外修改。对于资源紧张的 MCU，这招很管用。

20.4 状态机结构图

下面这张图，展示了我们刚才实现的状态机结构。你看，状态表就像一个二维网格，驱动着整个系统的行为。

函数指针数组驱动状态机结构图 状态表 (state_table[STATE_COUNT][EVT_COUNT]) 行 = 当前状态 STATE_IDLE STATE_RUNNING STATE_PAUSED STATE_ERROR EVT_START EVT_STOP EVT_PAUSE EVT_RESUME EVT_ERROR idle_handler NULL NULL NULL error_handler NULL running_handler running_handler NULL error_handler NULL paused_handler NULL paused_handler error_handler NULL error_handler NULL NULL NULL 状态机引擎 (process_event 函数) handler = state_table[current_state][evt]; if(handler) current_state = handler(evt); 输出：新状态 (current_state 更新) 有效处理函数 NULL (忽略事件)

20.5 避坑指南与实战建议

这种模式我用了很多年，踩过一些坑，分享给你：

我曾经犯过一个低级错误：状态表里的函数指针，跟实际函数的签名不匹配。比如表里声明的是 int (*)(int)，但实际函数是 void (*)(void)。编译器不一定报错，但运行时调用栈就乱了。所以，一定要用 typedef 统一类型，并且保持严格一致。

另外几个实用建议：

  • NULL 检查不能省：调用函数指针前，务必判断是否为 NULL。不然一个空指针就让你系统崩溃。
  • 状态表用 const 修饰：放在只读区域，防止意外篡改。这在 RTOS 多任务环境下尤其重要。
  • 善用枚举：状态和事件都用枚举定义，不要用魔数。枚举值变了，数组索引也跟着变，编译器能帮你检查。
  • 调试技巧：在 process_event 函数里加个日志宏，每次状态切换都打印出来。我调试复杂状态机时，全靠这个日志定位问题。

说白了，函数指针数组 + 状态表，就是把“过程式”的 if-else 逻辑，变成了“声明式”的数据配置。代码量少了，可读性高了，扩展性也强了。你想想看，以后加一个新状态，只需要写一个处理函数，然后在表里填一行。主逻辑一行代码都不用改。

嗯，这就是我理解的“回调函数进阶”。从单个回调，到函数指针数组，再到状态机驱动。每一步都是为了让代码更灵活、更健壮。希望这些经验对你有帮助。

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

← 上一章 📖 返回目录 下一章 →