C++ 使用参数传递函数并将值返回给另一个函数

是否可以使用如下参数传递函数：

int func(int num)
{
 return num;
}

void func()
{}

为此职能：

        template<class T>
        auto addTask(T task) -> std::future<decltype(task())>
        {
            auto wrapper = std::make_shared<std::packaged_task<decltype(task()) ()>>(std::move(task));
            {
                std::unique_lock<std::mutex> lock(mEventMutex);
                mTasks.emplace([=] {
                    (*wrapper)();
                });
            }
            mEventVar.notify_one();
            return wrapper->get_future();            
        }

addTask([some_value]()
{
    func(some_value);
});

它将只是：

addTask(func);

但是找不到放置args的位置。有可能吗？

您可以使用调用该函数的：

        template<class T>
        auto addTask(T task) -> std::future<decltype(task())>
        {
            auto wrapper = std::make_shared<std::packaged_task<decltype(task()) ()>>(std::move(task));
            {
                std::unique_lock<std::mutex> lock(mEventMutex);
                mTasks.emplace([=] {
                    (*wrapper)();
                });
            }
            mEventVar.notify_one();
            return wrapper->get_future();            
        }

addTask([some_value]()
{
    func(some_value);
});

---

或重写

addTask

以用于可能的参数：

template<typename Func, typename ...Args>
auto addTask(Func task, Args... arguments) -> std::future<decltype(task(arguments...))>
{
    auto wrapper = std::make_shared<std::packaged_task<decltype(task(arguments...)) (Args...)>>(std::move(task));
    {
        std::unique_lock<std::mutex> lock(mEventMutex);
        mTasks.emplace([=] {
            (*wrapper)(std::forward<Args>(arguments)...);
        });
    }
    mEventVar.notify_one();
    return wrapper->get_future();         
}

addTask(func, some_value);

模板
自动添加任务（Func任务、参数…参数）->std:：future
{
自动包装器=std:：make_shared（std:：move（task））；
{
标准：唯一的锁（mEventMutex）；
mTasks.emplace（[=]{
（*包装器）（std:：forward（参数）…）；
});
}
mEventVar.notify_one（）；
返回包装器->获取未来（）；
}
addTask（func，某些值）；

您可以使用调用该函数的：

        template<class T>
        auto addTask(T task) -> std::future<decltype(task())>
        {
            auto wrapper = std::make_shared<std::packaged_task<decltype(task()) ()>>(std::move(task));
            {
                std::unique_lock<std::mutex> lock(mEventMutex);
                mTasks.emplace([=] {
                    (*wrapper)();
                });
            }
            mEventVar.notify_one();
            return wrapper->get_future();            
        }

addTask([some_value]()
{
    func(some_value);
});

---

或重写

addTask

以用于可能的参数：

template<typename Func, typename ...Args>
auto addTask(Func task, Args... arguments) -> std::future<decltype(task(arguments...))>
{
    auto wrapper = std::make_shared<std::packaged_task<decltype(task(arguments...)) (Args...)>>(std::move(task));
    {
        std::unique_lock<std::mutex> lock(mEventMutex);
        mTasks.emplace([=] {
            (*wrapper)(std::forward<Args>(arguments)...);
        });
    }
    mEventVar.notify_one();
    return wrapper->get_future();         
}

addTask(func, some_value);

模板
自动添加任务（Func任务、参数…参数）->std:：future
{
自动包装器=std:：make_shared（std:：move（task））；
{
标准：唯一的锁（mEventMutex）；
mTasks.emplace（[=]{
（*包装器）（std:：forward（参数）…）；
});
}
mEventVar.notify_one（）；
返回包装器->获取未来（）；
}
addTask（func，某些值）；

答案很好，但当我编译它时，我有一个错误：

错误：调用“forward（const int&）”时没有匹配的函数。

。我还尝试了

（*wrapper）（std:：forward（arguments）…）但仍有错误：
将类型为'std:：remove_reference:：type&'{aka'int&'}的引用绑定到'const int'丢弃限定符
。哪里会有问题？@ADV老实说，我自己没有试过，也没有那么多完美转发的经验。我确实对答案进行了更新，希望能解决您的错误。答案很好，但当我编译它时，出现了错误：
错误：没有与调用“forward（const int&）”匹配的函数。
。我还尝试了
（*wrapper）（std:：forward（arguments）…）但仍有错误：
将类型为'std:：remove_reference:：type&'{aka'int&'}的引用绑定到'const int'丢弃限定符
。哪里会有问题？@ADV老实说，我自己没有试过，也没有那么多完美转发的经验。我确实更新了答案，希望能解决你的错误。