C语言中能否使用带任意/可变参数的回调函数？如何实现？

你的核心需求是让同一个exec函数能接收不同签名的回调并正确执行，但原实现存在几个关键问题：

• 未传递size参数却在函数内使用，导致编译错误；
• 可变参数中float会被自动提升为double，直接用va_arg(valist, float)会触发未定义行为；
• 回调函数类型不匹配：a/b的固定签名与void(*)(...)的泛型指针不兼容，直接调用会破坏参数传递规则。

以下是几种可行的解决方法：

方法一：用C11 _Generic 实现类型匹配（推荐） #

利用C11的_Generic特性，根据回调函数的类型自动匹配对应的执行逻辑，完全类型安全：

#include <stdio.h>

void a(int pa) { printf("回调a执行：%d\n", pa); }
void b(int pb1, float pb2) { printf("回调b执行：%d, %.1f\n", pb1, pb2); }

// 针对不同签名的回调实现专用执行函数
static void exec_int(void (*func)(int), int arg1) {
    func(arg1);
}

static void exec_int_float(void (*func)(int, float), int arg1, float arg2) {
    func(arg1, arg2);
}

// 用宏自动匹配回调类型
#define exec(...) _Generic((&__VA_ARGS__), \
    void(*)(int)*: exec_int(__VA_ARGS__), \
    void(*)(int, float)*: exec_int_float(__VA_ARGS__) \
)

int main() {
    exec(a, 1);
    exec(b, 1, 2.3f);
    return 0;
}

方法二：结构体封装回调与参数 #

如果不能使用C11特性，可以用结构体+枚举标记的方式封装回调和参数，逻辑清晰且类型安全：

#include <stdio.h>

void a(int pa) { printf("回调a执行：%d\n", pa); }
void b(int pb1, float pb2) { printf("回调b执行：%d, %.1f\n", pb1, pb2); }

// 标记回调类型
typedef enum {
    FUNC_INT,
    FUNC_INT_FLOAT
} FuncType;

// 封装回调和对应参数
typedef struct {
    FuncType type;
    union {
        struct { void (*f)(int); int arg; } int_func;
        struct { void (*f)(int, float); int arg1; float arg2; } int_float_func;
    } data;
} Callback;

void exec(Callback cb) {
    switch (cb.type) {
        case FUNC_INT:
            cb.data.int_func.f(cb.data.int_func.arg);
            break;
        case FUNC_INT_FLOAT:
            cb.data.int_float_func.f(cb.data.int_float_func.arg1, cb.data.int_float_func.arg2);
            break;
        default:
            break;
    }
}

int main() {
    Callback cb1 = {FUNC_INT, .data.int_func = {a, 1}};
    Callback cb2 = {FUNC_INT_FLOAT, .data.int_float_func = {b, 1, 2.3f}};
    exec(cb1);
    exec(cb2);
    return 0;
}

方法三：可变参数宏+辅助函数（兼容C99） #

通过宏传递回调类型标记，在辅助函数中处理可变参数，注意处理float被提升为double的细节：

#include <stdio.h>
#include <stdarg.h>

void a(int pa) { printf("回调a执行：%d\n", pa); }
void b(int pb1, float pb2) { printf("回调b执行：%d, %.1f\n", pb1, pb2); }

static void exec_helper(int func_type, va_list args) {
    if (func_type == 1) {
        void (*func)(int) = va_arg(args, void(*)(int));
        int arg1 = va_arg(args, int);
        func(arg1);
    } else if (func_type == 2) {
        void (*func)(int, float) = va_arg(args, void(*)(int, float));
        int arg1 = va_arg(args, int);
        double arg2 = va_arg(args, double); // 先取提升后的double
        func(arg1, (float)arg2); // 再转成float传给回调
    }
}

// 宏自动生成类型标记
#define exec(func, ...) exec_helper(_Generic((func), \
    void(*)(int): 1, \
    void(*)(int, float): 2 \
), (va_list){&func, __VA_ARGS__})

int main() {
    exec(a, 1);
    exec(b, 1, 2.3);
    return 0;
}

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