能否推导成员函数指针模板参数的参数类型？

嘿，这个问题我太有共鸣了——C风格回调的样板代码确实烦人，你已经摸到门道了，再往前一步就能让编译器帮你搞定参数推导！下面分几种方案给你参考：

C++17 及以后的最优方案：auto非类型模板参数+自动推导 #

C++17引入的auto非类型模板参数可以直接捕获成员函数指针的完整类型，不用手动写参数列表。我们可以重构dispatcher，让它自动从成员函数指针里提取类类型和参数类型：

#include <utility>

// 核心辅助类：从成员函数指针提取类型信息
template <auto MemFunc>
struct dispatcher;

// 特化版本，匹配任意参数的非const成员函数
template <typename T, typename... Args, void (T::*MemFunc)(Args...)>
struct dispatcher<MemFunc> {
    static void call(void* user_data, Args... args) {
        T& obj = *reinterpret_cast<T*>(user_data);
        // 用forward保持参数值类别（可选，根据你的需求调整）
        (obj.*MemFunc)(std::forward<Args>(args)...);
    }
};

// 方便调用的别名，直接生成回调函数指针
template <auto MemFunc>
constexpr auto make_dispatcher = &dispatcher<MemFunc>::call;

现在用起来就清爽多了！结合你的测试bench：

struct my_type {
    void callback(int, char, float) { }
};

void register_callback(void (*cb)(void*, int, char, float), void* user_data) {
    cb(user_data, 42, 'X', 3.14f);
}

int main() {
    my_type obj;
    // 直接传成员函数指针，编译器自动推导所有类型！
    register_callback(make_dispatcher<&my_type::callback>, &obj);
}

这里的关键是dispatcher<MemFunc>的特化逻辑，编译器会自动从传入的成员函数指针里解析出类T和参数Args...，完全不用你手动指定，是不是省心多了？

C++14 兼容方案：类型萃取+宏简化 #

如果还在用C++14，没法用auto非类型模板参数，那可以借助类型萃取工具来提取成员函数的参数：

#include <tuple>

// 萃取成员函数的类型信息
template <typename MemFunc>
struct mem_func_traits;

template <typename T, typename... Args>
struct mem_func_traits<void (T::*)(Args...)> {
    using class_type = T;
    using args_types = std::tuple<Args...>;
};

// 重构dispatcher
template <typename MemFunc>
struct dispatcher;

template <typename T, typename... Args>
struct dispatcher<void (T::*)(Args...)> {
    template <void (T::*MemFunc)(Args...)>
    static void call(void* user_data, Args... args) {
        T& obj = *reinterpret_cast<T*>(user_data);
        (obj.*MemFunc)(args...);
    }
};

// 用宏简化调用（C++14没有auto非类型模板参数，只能靠宏减少重复）
#define MAKE_DISPATCHER(mem_func) \
    &dispatcher<decltype(mem_func)>::call<mem_func>

调用的时候直接用宏：

int main() {
    my_type obj;
    register_callback(MAKE_DISPATCHER(&my_type::callback), &obj);
}

虽然需要一个宏，但至少不用手动写长长的参数列表了，也算减少了样板代码。

Boost 方案：Boost.FunctionTypes 类型萃取 #

如果你能用到Boost，Boost.FunctionTypes库专门用来处理函数类型的萃取，能更优雅地解决这个问题：

#include <boost/function_types/parameter_types.hpp>
#include <boost/function_types/member_function_pointer.hpp>

namespace ft = boost::function_types;

template <typename MemFunc>
struct dispatcher {
    // 从成员函数指针里提取类类型
    using class_type = typename ft::member_function_pointer<MemFunc>::class_type;
    // 提取参数类型
    using args_types = typename ft::parameter_types<MemFunc>::type;

    template <MemFunc MF>
    static void call(void* user_data, typename ft::parameter_types<MemFunc>::type... args) {
        class_type& obj = *reinterpret_cast<class_type*>(user_data);
        (obj.*MF)(args...);
    }
};

// 宏简化调用
#define BOOST_MAKE_DISPATCHER(mem_func) \
    &dispatcher<decltype(mem_func)>::call<mem_func>

调用方式和C++14的宏版本类似，Boost的类型萃取工具更成熟，还能处理带const/volatile限定的成员函数，适配场景更全。

轻量临时方案：直接用lambda捕获（C++11及以后） #

其实你提到过lambda，这里补充一个更简洁的写法——C++11开始可以用lambda，但要注意：C风格回调要求函数指针不能有捕获，不过我们可以把对象指针塞到user_data里，写一个无捕获的lambda：

int main() {
    my_type obj;
    register_callback(
        [](void* user_data, int a, char b, float c) {
            reinterpret_cast<my_type*>(user_data)->callback(a, b, c);
        },
        &obj
    );
}

这种写法不需要任何模板辅助，直接写lambda就行，虽然还是有点重复，但对于偶尔使用的场景足够简单，不用维护额外的模板代码。

总结一下，C17及以后的auto非类型模板参数方案是最优雅的，完全消除了手动指定类型的麻烦；C14可以用类型萃取+宏；Boost也有成熟的工具链；lambda则是轻量的临时解决方案。

备注：内容来源于stack exchange，提问作者TypeIA