函数指针指向参数为不同指针类型的函数，是否属于未定义行为？

首先直接给结论：这段代码中转换func2的函数指针并调用的行为，确实属于C标准定义的未定义行为——哪怕你测试的所有编译器都能正常运行，所有指针大小也一致，也不能依赖这种行为的正确性。

为什么是未定义行为？ #

根据C标准（比如C17 §6.3.2.3 关于函数指针的规定）：

• 函数指针可以在不同类型之间转换，再转换回原类型时是安全的；
• 但当你通过转换后的函数指针调用函数时，指针的类型必须和函数的实际类型兼容。

函数类型兼容的核心要求是：参数列表中的每个对应参数类型必须兼容。int(void*)和int(struct Test*)的参数类型并不兼容——void*是通用对象指针，struct Test*是指向具体结构体的指针，二者属于不同的类型，因此这两个函数类型不兼容。

即使在绝大多数系统中，所有对象指针的大小和对齐方式都相同，C标准也没有保证这种跨类型的函数调用是安全的。编译器可能会基于函数签名进行参数传递优化（比如某些架构下不同指针类型的传递方式有差异），导致运行时出现不可预料的问题。

针对类型安全回调系统的替代方案 #

既然你想避免void*的类型不安全问题，降低维护成本，这里提供几个可行的方案：

方案1：为每种回调场景定义专属函数指针类型 #

这是最直接的类型安全方案，完全不需要类型转换，编译器会帮你做类型检查：

#include <stdio.h>
struct Test { int value; };

// 定义Test类型专属的回调指针
typedef int (*TestCallback)(struct Test*);

int func2(struct Test *userData) {
    printf("func2: %i\n", userData->value);
    return 0;
}

// 类型安全的回调调用逻辑
void run_test_callback(TestCallback cb, struct Test* data) {
    cb(data);
}

int main() {
    struct Test test = {9};
    run_test_callback(func2, &test);
    return 0;
}

方案2：用结构体封装带类型标记的回调 #

如果需要统一管理多种类型的回调，可以结合枚举标记和联合体，调用时做类型匹配：

#include <stdio.h>
struct Test { int value; };
struct OtherData { float val; };

// 回调类型枚举，标记当前回调对应的参数类型
typedef enum {
    CB_TYPE_TEST,
    CB_TYPE_OTHER
} CallbackType;

// 封装回调函数和类型标记
typedef struct {
    CallbackType type;
    union {
        int (*test_cb)(struct Test*);
        int (*other_cb)(struct OtherData*);
    } func;
} Callback;

// 统一的回调调用入口
int invoke_callback(Callback cb, void* data) {
    switch(cb.type) {
        case CB_TYPE_TEST:
            return cb.func.test_cb((struct Test*)data);
        case CB_TYPE_OTHER:
            return cb.func.other_cb((struct OtherData*)data);
        default:
            return -1;
    }
}

// 示例回调函数
int func_test(struct Test* t) {
    printf("Test value: %d\n", t->value);
    return 0;
}

int main() {
    struct Test test = {9};
    Callback cb = {.type = CB_TYPE_TEST, .func.test_cb = func_test};
    invoke_callback(cb, &test);
    return 0;
}

方案3：用C11泛型实现类型安全的通用回调 #

如果想保留通用的回调接口，同时在编译期保证类型安全，可以用C11的_Generic特性生成类型匹配的包装函数：

#include <stdio.h>

struct Test { int value; };

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

// 包装宏，自动匹配对应类型的包装函数
#define WRAP_CALLBACK(func) \
    _Generic((func), \
        int(*)(struct Test*): wrap_test_cb, \
        default: NULL)(func)

// Test类型的包装函数，做编译期类型检查
static int wrap_test_cb(int (*cb)(struct Test*), void* data) {
    _Static_assert(_Generic(data, struct Test*: 1, default: 0), "Data type mismatch for Test callback");
    return cb((struct Test*)data);
}

// 示例回调函数
int func2(struct Test* t) {
    printf("func2: %d\n", t->value);
    return 0;
}

int main() {
    struct Test test = {9};
    GenericCallback cb = (GenericCallback)WRAP_CALLBACK(func2);
    cb(&test);
    return 0;
}

总结 #

你的测试代码虽然能运行，但属于未定义行为，不适合用于生产环境。上面的方案都能帮你实现类型安全的回调系统，避免void*带来的类型隐患，同时降低代码维护成本。

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