如何实现无需传入默认参数的可变参数异步回调执行函数？

你之前的代码无法编译，核心问题有两个：

1. 直接写T ...args;是无效的C++语法，参数包的变量声明需要正确展开初始化；
2. 用引用捕获[&]会导致悬空引用——exec_async函数返回后，局部变量会被销毁，而异步任务可能还在执行，此时引用指向的是已释放的内存。

下面是两种兼容不同C++标准的正确实现：

C++17及以上版本实现 #

利用C++17的std::apply和参数包展开初始化，代码简洁高效：

#include <future>
#include <tuple>
#include <functional>

template<typename... T, typename F, typename Cb>
void exec_async(F func, Cb callback)
{
    // 值初始化参数包中的每个变量（要求T类型支持默认构造）
    T args...{};
    
    // 将函数、回调和参数移动捕获到lambda中，避免悬空引用
    std::future<void> result = std::async(std::launch::async, 
        [func = std::move(func), callback = std::move(callback), args_tuple = std::make_tuple(std::move(args)...)]() mutable
        {
            // 展开tuple调用数据获取函数
            std::apply(func, args_tuple);
            // 展开tuple调用回调函数
            std::apply(callback, args_tuple);
        });
}

C11/C14兼容版本 #

如果项目还在使用较老的C++标准，可以自己实现tuple展开逻辑：

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

namespace detail {
    // 辅助函数：展开tuple并调用函数
    template<typename F, typename Tuple, std::size_t... Is>
    void apply_impl(F&& func, Tuple&& tuple, std::index_sequence<Is...>)
    {
        std::forward<F>(func)(std::get<Is>(std::forward<Tuple>(tuple))...);
    }
}

// 自定义apply函数，模拟C++17的std::apply
template<typename F, typename Tuple>
void apply(F&& func, Tuple&& tuple)
{
    detail::apply_impl(
        std::forward<F>(func),
        std::forward<Tuple>(tuple),
        std::make_index_sequence<std::tuple_size<typename std::decay<Tuple>::type>::value>{}
    );
}

template<typename... T, typename F, typename Cb>
void exec_async(F func, Cb callback)
{
    // 默认构造tuple，内部每个元素会被默认初始化
    std::tuple<T...> args;
    
    std::future<void> result = std::async(std::launch::async, 
        [func = std::move(func), callback = std::move(callback), args = std::move(args)]() mutable
        {
            ::apply(func, args);
            ::apply(callback, args);
        });
}

使用示例 #

现在调用exec_async时无需传入默认参数，直接指定模板参数即可：

#include <iostream>
#include <string>

void callback_func(const std::string& output)
{
    std::cout << "Output: " << output << std::endl;
}

void exec_func()
{
    auto func = [](std::string& in)
    {
        in = "testing";
    };

    // 无需传入默认的""，直接调用
    exec_async<std::string>(func, &callback_func);
}

int main()
{
    exec_func();
    // 注意：需要等待异步任务完成，否则main可能提前退出
    std::cin.get();
    return 0;
}

关键注意事项 #

• 要求模板参数T必须支持默认构造，如果你的类型无法默认初始化，还是需要传入初始值；
• 使用移动捕获而非引用捕获，彻底避免异步执行时的悬空引用问题；
• std::future对象要保留（比如代码中的result），否则其析构函数会阻塞当前线程，直到异步任务完成，失去异步意义。

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