19、typedef简化函数指针：使用typedef定义函数指针类型别名

说实话，函数指针的语法在C语言里算是个「异类」。你看普通变量声明：int a;，多清爽。再看函数指针：int (*p)(int, int);——这括号套括号的，我第一次看差点没认出来这是个指针。

我在项目里带过不少新人，十个人里有八个会被函数指针的声明绕晕。更别提在回调函数、状态机、插件系统这些场景里，函数指针类型反复出现，每次都要写一长串，既容易出错，又让代码变得臃肿。

这时候，typedef就是我们的救星。它能把那些复杂的函数指针类型「包装」成一个简洁的名字。你想想看，写代码时直接拿名字用，多省心。

19.1 为什么需要typedef简化函数指针

先看一个典型场景。假设你要定义一个回调函数类型，用于比较两个整数：

// 没有typedef的写法
int compare_int(void *a, void *b);
int compare_string(void *a, void *b);

// 声明一个函数指针变量
int (*cmp)(void *, void *) = compare_int;

这还算简单。但如果你要声明一个函数指针数组呢？或者函数指针作为结构体成员呢？

// 函数指针数组
int (*cmp_funcs[10])(void *, void *);

// 结构体中的函数指针
struct handler {
    char *name;
    int (*process)(int, char *);
};

嗯，这里要注意——每次写这种声明，你都得小心翼翼地数括号。我曾经在维护一个老项目时，看到有人把函数指针数组的声明写错了，结果编译器报了一堆看不懂的错误，排查了整整一个下午。

用typedef之后，世界就清净了：

typedef int (*CompareFunc)(void *, void *);

CompareFunc cmp = compare_int;
CompareFunc cmp_funcs[10];  // 数组，清爽！

19.2 typedef定义函数指针类型的基本语法

语法其实很简单，就是把函数指针声明中的变量名换成类型别名：

typedef 返回类型 (*类型别名)(参数列表);

举个例子：

// 定义一个函数指针类型，指向返回int、接受两个int参数的函数
typedef int (*BinaryOp)(int, int);

// 现在可以用这个类型了
BinaryOp add = NULL;   // 声明一个函数指针变量
BinaryOp ops[4];       // 声明一个函数指针数组

我个人习惯把类型别名写成PascalCase风格，比如CompareFunc、CallbackHandler。这样一眼就能看出这是个类型，而不是变量。当然，也有人喜欢全小写加下划线，看团队规范。

19.3 实际应用：回调函数中的typedef

回调函数是函数指针最经典的应用场景。用typedef能让回调接口变得非常清晰。

看一个排序函数的例子：

#include <stdio.h>
#include <stdlib.h>

// 定义比较函数类型
typedef int (*CompareFunc)(const void *, const void *);

// 比较整数
int compare_int(const void *a, const void *b) {
    return (*(int *)a - *(int *)b);
}

// 比较浮点数
int compare_float(const void *a, const void *b) {
    float diff = *(float *)a - *(float *)b;
    return (diff > 0) ? 1 : (diff < 0) ? -1 : 0;
}

// 通用的排序函数，接受比较函数作为参数
void sort_array(void *arr, size_t n, size_t size, CompareFunc cmp) {
    // 这里用冒泡排序做演示，实际项目请用qsort
    for (size_t i = 0; i < n - 1; i++) {
        for (size_t j = 0; j < n - i - 1; j++) {
            char *base = (char *)arr;
            if (cmp(base + j * size, base + (j + 1) * size) > 0) {
                // 交换
                for (size_t k = 0; k < size; k++) {
                    char tmp = base[j * size + k];
                    base[j * size + k] = base[(j + 1) * size + k];
                    base[(j + 1) * size + k] = tmp;
                }
            }
        }
    }
}

int main() {
    int int_arr[] = {5, 3, 8, 1, 9};
    float float_arr[] = {3.14, 1.41, 2.71, 0.618};
    
    sort_array(int_arr, 5, sizeof(int), compare_int);
    sort_array(float_arr, 4, sizeof(float), compare_float);
    
    // 打印结果...
    return 0;
}

你看，CompareFunc这个类型名一出现，函数的意图就非常明确——它需要一个比较函数。调用者也知道该传什么类型的函数进去。

19.4 复杂场景：函数指针作为结构体成员

在嵌入式开发中，我经常用函数指针来实现「面向对象」的效果。比如一个设备驱动：

// 定义设备操作函数类型
typedef int (*InitFunc)(void);
typedef int (*ReadFunc)(uint8_t *buf, uint32_t len);
typedef int (*WriteFunc)(const uint8_t *buf, uint32_t len);
typedef void (*DeinitFunc)(void);

// 设备结构体
typedef struct {
    char        *name;
    uint32_t    address;
    InitFunc    init;
    ReadFunc    read;
    WriteFunc   write;
    DeinitFunc  deinit;
} Device;

// 实例化一个SPI Flash设备
Device spi_flash = {
    .name    = "W25Q64",
    .address = 0x00000000,
    .init    = spi_flash_init,
    .read    = spi_flash_read,
    .write   = spi_flash_write,
    .deinit  = spi_flash_deinit,
};

这样做的好处是，你可以把不同硬件的驱动统一成同一个结构体类型。上层代码只需要操作Device结构体，不用关心底层是SPI Flash还是I2C EEPROM。

19.5 避坑指南：typedef函数指针的常见错误

我用typedef处理函数指针这么多年，踩过不少坑。分享几个最常见的：

// 错误！这定义了一个返回int*的函数类型，不是函数指针
typedef int *FuncPtr(int, int);

// 正确
typedef int (*FuncPtr)(int, int);

// #define只是文本替换，容易出问题
#define FuncPtr int (*)(int, int)

// typedef是类型定义，更安全
typedef int (*FuncPtr)(int, int);

// 区别在于：typedef可以用于声明多个变量
FuncPtr a, b;  // a和b都是函数指针
// 如果用#define，展开后变成：
// int (*)(int, int) a, b;  // 语法错误！

// 先写变量声明
int (*p)(int, int);

// 把p换成类型别名，前面加typedef
typedef int (*MyFunc)(int, int);

19.6 进阶：typedef与函数指针数组

函数指针数组在状态机、命令解析器里很常见。用typedef能让代码可读性提升一个档次。

// 定义命令处理函数类型
typedef int (*CommandHandler)(int argc, char *argv[]);

// 命令表
typedef struct {
    char           *name;
    CommandHandler handler;
    char           *help;
} Command;

// 具体的处理函数
int cmd_help(int argc, char *argv[]) { /* ... */ }
int cmd_reset(int argc, char *argv[]) { /* ... */ }
int cmd_status(int argc, char *argv[]) { /* ... */ }

// 命令表数组
Command cmd_table[] = {
    {"help",   cmd_help,   "显示帮助信息"},
    {"reset",  cmd_reset,  "复位系统"},
    {"status", cmd_status, "查看系统状态"},
    {NULL,     NULL,       NULL}  // 结束标记
};

// 查找并执行命令
int execute_command(char *cmd_name, int argc, char *argv[]) {
    for (int i = 0; cmd_table[i].name != NULL; i++) {
        if (strcmp(cmd_name, cmd_table[i].name) == 0) {
            return cmd_table[i].handler(argc, argv);
        }
    }
    return -1;  // 命令未找到
}

这种写法在嵌入式CLI（命令行接口）里非常常见。每个命令就是一个函数，通过函数指针数组来管理。新增一个命令只需要写一个处理函数，然后在表里加一行——完全不用改框架代码。

19.7 知识体系：typedef与函数指针的关系

下面这张图梳理了本章的核心逻辑：

19.8 总结

typedef简化函数指针，说白了就是给复杂类型起个「外号」。这个外号让你写代码时不用再纠结括号和星号，让代码意图更清晰。

我个人建议，只要函数指针类型在代码中出现超过两次，就应该用typedef给它起个名字。这不是偷懒，而是代码质量的一部分。你想想看，半年后你自己回来看代码，看到CompareFunc和看到int (*)(const void *, const void *)，哪个更省脑细胞？

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