6、函数指针数组：定义函数指针数组，实现跳转表/状态机

好，咱们今天聊点硬核的。函数指针数组，说白了就是「把一堆函数指针塞进数组里」。你可能会问：我直接调用函数不香吗？干嘛要绕这么一圈？

嗯，我当年刚接触这个特性时也有同样的疑惑。直到我在一个嵌入式项目里，面对一堆按键处理逻辑，if-else 写了整整两百行……那感觉，就像用勺子挖隧道。后来改用函数指针数组，代码瞬间清爽了。

6.1 什么是函数指针数组？

先看定义。函数指针数组，就是数组的每个元素都是一个函数指针。语法长这样：

// 定义一个函数指针类型
typedef void (*cmd_handler_t)(void);

// 声明一个函数指针数组
cmd_handler_t cmd_table[10];

这里 cmd_handler_t 是一个类型，代表「指向返回值为 void、参数为 void 的函数的指针」。然后 cmd_table[10] 就是一个能装 10 个这种指针的数组。

我个人习惯用 typedef 先定义类型，这样代码读起来舒服很多。你想想看，如果每次写函数指针都写一遍完整的声明，那得多痛苦。

6.2 跳转表：用数组下标代替 if-else

跳转表（Jump Table）是函数指针数组最经典的应用。它的核心思想是：用数据驱动代码执行。

举个例子。假设你有一个命令解析器，收到命令 0 就执行 A 操作，命令 1 执行 B 操作……传统写法是这样的：

void process_command(int cmd) {
    if (cmd == 0) {
        do_a();
    } else if (cmd == 1) {
        do_b();
    } else if (cmd == 2) {
        do_c();
    }
    // ... 继续写下去
}

这种代码，我见过有人写了 30 多个 else if。每次新增命令都要改这个函数，而且很容易漏掉 break 或者搞错逻辑。说实话，维护起来挺崩溃的。

用函数指针数组改写：

// 定义处理函数
void do_a(void) { /* ... */ }
void do_b(void) { /* ... */ }
void do_c(void) { /* ... */ }

// 构建跳转表
typedef void (*cmd_handler_t)(void);
cmd_handler_t cmd_table[] = {
    do_a,   // 命令 0
    do_b,   // 命令 1
    do_c    // 命令 2
};

// 处理函数
void process_command(int cmd) {
    if (cmd < sizeof(cmd_table) / sizeof(cmd_table[0])) {
        cmd_table[cmd]();  // 直接跳转
    }
}

看到了吗？核心逻辑就一行：cmd_table[cmd]()。新增命令时，只需要加一个函数，然后在数组里注册一下就行。process_command 函数永远不用改。

6.3 状态机：用函数指针数组管理状态

状态机是嵌入式开发里的家常便饭。按键消抖、通信协议解析、任务调度……到处都有它的影子。

传统状态机用 switch-case 实现，状态一多，代码就变得又臭又长。而且每个状态的处理逻辑都挤在一个函数里，耦合度很高。

用函数指针数组实现状态机，思路是这样的：每个状态对应一个处理函数，状态切换就是更换函数指针。

看一个简单的按键状态机例子：

// 状态枚举
typedef enum {
    STATE_IDLE,
    STATE_DEBOUNCE,
    STATE_PRESSED,
    STATE_RELEASE,
    STATE_COUNT
} key_state_t;

// 状态处理函数
void state_idle(void) {
    if (key_pressed()) {
        set_state(STATE_DEBOUNCE);
    }
}

void state_debounce(void) {
    static uint32_t timer = 0;
    if (++timer >= 5) {  // 消抖延时
        timer = 0;
        if (key_pressed()) {
            set_state(STATE_PRESSED);
        } else {
            set_state(STATE_IDLE);
        }
    }
}

void state_pressed(void) {
    // 处理按键按下事件
    key_event = KEY_DOWN;
    set_state(STATE_RELEASE);
}

void state_release(void) {
    if (!key_pressed()) {
        set_state(STATE_IDLE);
    }
}

// 函数指针数组（状态跳转表）
typedef void (*state_handler_t)(void);
state_handler_t state_table[STATE_COUNT] = {
    state_idle,
    state_debounce,
    state_pressed,
    state_release
};

// 当前状态
key_state_t current_state = STATE_IDLE;

// 状态机主循环
void key_state_machine(void) {
    state_table[current_state]();
}

// 状态切换函数
void set_state(key_state_t new_state) {
    current_state = new_state;
}

这个结构的好处是：每个状态的处理逻辑完全独立，互不干扰。想加一个新状态？写一个函数，在 state_table 里注册一下就行。我曾经在一个通信协议栈里用这种方式管理了 20 多个状态，代码依然清晰可读。

6.4 避坑指南

函数指针数组虽然好用，但坑也不少。我踩过的几个，分享给你：

• 数组越界：调用 cmd_table[cmd]() 之前，一定要检查下标是否合法。否则一旦越界，程序直接飞掉。我建议用 sizeof 计算数组长度，不要硬编码。
• 函数签名不一致：数组里所有函数指针的类型必须完全一致。返回值、参数个数、参数类型，一个都不能差。否则编译器会报错，或者更糟——不报错但运行时崩溃。
• 空指针调用：如果数组某个元素没有初始化（比如 NULL），调用时就会触发异常。我习惯在初始化时把所有元素都赋一个默认的「空处理函数」，至少保证不会崩溃。
• 状态机死循环：如果某个状态处理函数忘了调用 set_state，状态机就会卡死。我一般会在每个状态函数的末尾加一个断言，检查状态是否发生了切换。

6.5 性能与内存考量

函数指针数组在嵌入式系统里很受欢迎，因为它几乎没有额外开销。调用 cmd_table[cmd]() 本质上就是一次数组寻址加一次函数调用，比 switch-case 的跳转表还快（switch-case 有时会生成二分查找代码）。

内存方面，每个函数指针占用 4 字节（32 位系统）或 8 字节（64 位系统）。一个 10 个元素的数组，也就 40 字节。这点开销，几乎可以忽略不计。

但要注意：函数指针数组是放在 RAM 里的（除非你用 const 修饰并放到 Flash 里）。如果你的 RAM 非常紧张，可以考虑把数组声明为 const，让编译器把它分配到只读区域。

// 放到 Flash 中，节省 RAM
const cmd_handler_t cmd_table[] = {
    do_a,
    do_b,
    do_c
};

6.6 小结

函数指针数组，说白了就是「用数组管理函数」。它让代码从「面向过程」变成了「面向数据」，结构更清晰，扩展更方便。

跳转表适合处理「命令-动作」映射，状态机适合处理「状态-行为」切换。两者本质上是同一个思想：把逻辑判断转化为数组索引。

嗯，我建议你找个实际项目练练手。比如写一个简单的菜单系统，或者一个 LED 灯效控制器。用函数指针数组实现一遍，再对比传统的 if-else 写法，你就能体会到它的威力了。