如何更优雅地在数组中存储不同签名的回调函数指针？

你提到的union方案确实能解决问题，但手动类型转换不仅不优雅，还容易埋下未定义行为的隐患——毕竟C标准里不同签名的函数指针转换属于未定义行为（虽然很多编译器能正常运行，但风险始终存在）。这里有两个更靠谱的方案，兼顾优雅和类型安全：

方案一：通用回调+参数结构体包装 #

核心思路是统一所有回调的签名为void(*)(void*)，然后把每个回调需要的参数打包成结构体，注册时把回调函数和参数指针绑定在一起。这样既不用类型转换，还能清晰管理每个回调的参数。

示例代码：

#include <stdio.h>

// 通用回调类型
typedef void (*generic_callback_t)(void*);

// 每个事件的参数结构体
typedef struct {
    signed char direction;
} event1_params_t;

typedef struct {
    // EVENT2不需要参数，这里可以留空或者加个标记
} event2_params_t;

// 回调数组存储的是回调函数+参数指针
typedef struct {
    generic_callback_t func;
    void* params;
} callback_entry_t;

typedef enum { EVENT1, EVENT2, MAX_EVENTS } event_t;
callback_entry_t callback_entries[MAX_EVENTS] = {0};

// 实际回调函数，接收对应参数结构体指针
void event_func1(void* params) {
    event1_params_t* p = (event1_params_t*)params;
    printf("success rotated: %d\n", p->direction);
}

void event_func2(void* params) {
    (void)params; // 无参数，忽略
    printf("success button pressed\n");
}

// 注册函数，绑定回调和参数
void register_callback(event_t event, generic_callback_t func, void* params) {
    if (event >= MAX_EVENTS) return;
    callback_entries[event].func = func;
    callback_entries[event].params = params;
}

int main(void) {
    // 准备参数（可以是栈上或堆上的，注意生命周期）
    event1_params_t event1_params = {1};
    event2_params_t event2_params = {0};

    // 注册回调，不用类型转换
    register_callback(EVENT1, event_func1, &event1_params);
    register_callback(EVENT2, event_func2, &event2_params);

    // 调用回调
    if (callback_entries[EVENT1].func != NULL) {
        callback_entries[EVENT1].func(callback_entries[EVENT1].params);
    }
    if (callback_entries[EVENT2].func != NULL) {
        callback_entries[EVENT2].func(callback_entries[EVENT2].params);
    }

    return 0;
}

这个方案的好处是完全类型安全，编译期就能检查参数是否匹配，而且代码可读性强，每个回调的参数结构清晰。唯一需要注意的是参数的生命周期——如果用栈上变量，要确保调用回调时变量还存在。

方案二：用C11 _Generic实现类型安全的宏封装 #

如果不想改回调的原始签名，还可以用C11的_Generic特性，在编译期自动匹配对应的回调类型，避免手动类型转换。这个方案能保留你原来的回调函数签名，同时让注册和调用过程更安全。

示例代码：

#include <stdio.h>

typedef enum { EVENT1, EVENT2, MAX_EVENTS } event_t;

// 原始回调签名
typedef void (*callback_s_char_t)(signed char);
typedef void (*callback_void_t)(void);

// 用结构体存储不同类型的回调（比union更清晰，避免类型重叠问题）
typedef struct {
    union {
        callback_s_char_t cb_s_char;
        callback_void_t cb_void;
    } func;
    // 标记回调类型，调用时用这个判断
    enum { CB_S_CHAR, CB_VOID } type;
} callback_entry_t;

callback_entry_t callback_entries[MAX_EVENTS] = {0};

// 注册宏，用_Generic自动匹配类型
#define REGISTER_CALLBACK(event, cb) do { \
    if ((event) >= MAX_EVENTS) break; \
    callback_entries[event].type = _Generic((cb), \
        callback_s_char_t: CB_S_CHAR, \
        callback_void_t: CB_VOID \
    ); \
    _Generic((cb), \
        callback_s_char_t: (callback_entries[event].func.cb_s_char = (cb)), \
        callback_void_t: (callback_entries[event].func.cb_void = (cb)) \
    ); \
} while(0)

// 调用宏，根据类型自动调用对应签名的回调
#define CALL_CALLBACK(event, ...) do { \
    if ((event) >= MAX_EVENTS) break; \
    switch(callback_entries[event].type) { \
        case CB_S_CHAR: \
            if (callback_entries[event].func.cb_s_char != NULL) { \
                callback_entries[event].func.cb_s_char(__VA_ARGS__); \
            } \
            break; \
        case CB_VOID: \
            if (callback_entries[event].func.cb_void != NULL) { \
                callback_entries[event].func.cb_void(); \
            } \
            break; \
        default: break; \
    } \
} while(0)

// 原始回调函数，不用修改签名
void event_func1(signed char direction) {
    printf("success rotated: %d\n", direction);
}

void event_func2(void) {
    printf("success button pressed\n");
}

int main(void) {
    // 注册回调，不用手动类型转换，编译期检查类型
    REGISTER_CALLBACK(EVENT1, event_func1);
    REGISTER_CALLBACK(EVENT2, event_func2);

    // 调用回调，参数不匹配会编译报错！
    CALL_CALLBACK(EVENT1, 1);
    CALL_CALLBACK(EVENT2);

    return 0;
}

这个方案的优势是保留原始回调签名，而且_Generic会在编译期检查传入的回调函数类型是否合法，如果传错类型（比如给EVENT1传无参数的回调），编译器直接报错，避免了运行时错误。缺点是需要C11及以上标准支持。

为什么原来的union方案不够优雅？ #

你的union方案虽然能运行，但存在几个问题：

• 手动类型转换是未定义行为：C标准明确规定，不同签名的函数指针之间的转换是未定义行为（除非转换回原类型），虽然很多编译器支持，但移植性不好。
• 没有类型检查：注册时如果传错了回调类型，编译期不会报错，只会在运行时出现奇怪的问题，难以排查。

以上两个方案都解决了这些问题，你可以根据项目的C标准支持情况和需求选择：如果需要兼容老编译器，选方案一；如果想保留原始回调签名且用C11，选方案二。

内容的提问来源于stack exchange，提问作者user1160713