如何为现有无类型线程池编写类型化任务包装器？

我有一个采用轮询方式分配任务的简单线程池，任务定义如下：

using TaskFn = void (*)(void*);

struct Task {
    TaskFn fn;
    void* args;
};

该任务仅包含两个指针：一个指向接收void*参数的函数，另一个指向参数本身。线程池调用Task::fn并传入Task::args，目前运行正常。

但我想为此编写一个类型化包装器，以便能像这样使用：

Task some_task = MakeTask([](int a, int b){
        // Task body
}, 123, 456);

我不需要支持闭包。我编写了一段无法编译的代码：

template <typename Function, typename ... Args>
void DoCall(Function f, std::tuple<Args...>* args) {
    auto callable = [args, f](){
        std::apply(f, *args);
    };
    callable();
}

template <typename Function, typename ... Args>
Task MakeTask(Function f, Args ... args) {
    Task task;
             
    std::tuple<Args...>* args_on_heap = new std::tuple<Args...>(args...);
    task.args = (void*) args_on_heap;

    TaskFn fn = [](void* ptr){
        // The problem here is that I can’t pass `f` here without creating a closure.
        // But if I create a closure, the signature will be different. 
        // In theory, everything that is needed is known at the compilation stage. 
        // But how to curb the compiler?
        DoCall<Function, Args...>(f, (std::tuple<Args...>*) ptr);
    };

    task.fn = fn;
    return task;
    
    // P.S I know that args_on_heap leaks.
}

提出的问题 #

1. 是否可以实现我设想的功能？
2. 若可以，该如何实现？需要探索哪些方向？哪些C++语言特性能帮助我实现？
3. 若无法实现，有哪些替代方案？

1. 可以实现 #

完全可以实现你想要的类型化包装器功能，核心是把函数和参数的类型信息在编译期固化，让适配函数能正确识别并调用目标逻辑。

2. 实现方案与用到的C++特性 #

你的代码问题在于：lambda捕获f后不再是普通函数指针（不符合TaskFn的签名要求），且模板参数Function和Args...在lambda内部无法直接访问。解决思路是将函数与参数打包到同一堆对象中，或者利用类型擦除统一调用逻辑，以下是两种可行方案：

方案一：打包函数与参数到堆对象 #

把函数对象和参数元组打包成一个结构体，一起分配到堆内存，适配函数只需将void*转为该结构体指针，就能同时拿到函数和参数：

#include <tuple>
#include <utility>
#include <functional>

using TaskFn = void (*)(void*);

struct Task {
    TaskFn fn;
    void* args;
};

// 通用适配函数，负责拆包并调用目标函数
template<typename Func, typename... Args>
void TaskAdaptor(void* ptr) {
    auto* data = static_cast<std::pair<Func, std::tuple<Args...>>*>(ptr);
    std::apply(data->first, data->second);
    delete data; // 释放堆内存，避免泄漏
}

template<typename Func, typename... Args>
Task MakeTask(Func f, Args&&... args) {
    // 打包函数和参数到堆上
    auto* task_data = new std::pair<Func, std::tuple<Args...>>{
        std::move(f),
        std::make_tuple(std::forward<Args>(args)...)
    };
    return {
        &TaskAdaptor<Func, Args...>, // 取模板实例化后的函数指针
        static_cast<void*>(task_data)
    };
}

// 使用示例
int main() {
    Task task = MakeTask([](int a, int b){
        // 任务逻辑
    }, 123, 456);
    // 线程池调用逻辑
    task.fn(task.args);
    return 0;
}

用到的C++特性：

• 模板参数推导：自动推导Func和Args...的具体类型
• std::tuple与std::apply：打包参数并自动拆包调用函数
• 函数模板实例化：TaskAdaptor<Func, Args...>会生成符合TaskFn签名的具体函数指针
• 完美转发：std::forward<Args>(args)减少不必要的参数拷贝损耗

方案二：利用std::function做类型擦除 #

如果不想手写模板适配函数，可以用std::function封装绑定后的调用逻辑，实现更简洁的代码：

#include <functional>

using TaskFn = void (*)(void*);

struct Task {
    TaskFn fn;
    void* args;
};

// 统一的包装函数，调用std::function
void FunctionWrapper(void* ptr) {
    auto* func = static_cast<std::function<void()>*>(ptr);
    (*func)();
    delete func;
}

template<typename Func, typename... Args>
Task MakeTask(Func f, Args&&... args) {
    // 绑定参数，生成无参的std::function
    auto* bound_func = new std::function<void()>(
        std::bind(std::forward<Func>(f), std::forward<Args>(args)...)
    );
    return {&FunctionWrapper, static_cast<void*>(bound_func)};
}

这种方式更简洁，但std::function有轻微的性能开销，适合对性能要求不极致的场景。用到的特性：

• std::function类型擦除：将任意可调用对象转换成统一类型
• std::bind：绑定参数，生成无参的可调用对象

3. 替代方案 #

如果因某些限制无法使用模板，可选择以下替代方案：

• 手动编写适配函数：为每个任务类型写对应的TaskFn适配函数，手动转换参数类型并调用目标函数，但扩展性差、重复代码多
• 修改线程池接口：将Task改为直接存储std::function<void()>，无需手动写包装器，但需要修改原有线程池的任务定义
• C风格回调+上下文：把函数指针和参数放到一个自定义结构体中，用C风格写法实现适配，不依赖C++模板特性

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