在这种情况下如何正确使用 std forward

Question

Here is a class which has queue as private member and addTask() method and when i compile this i have error with std::forward:

#include <iostream>
#include <unistd.h>

#include <functional>
#include <vector>
#include <thread>
#include <condition_variable>
#include <queue>
#include <future>
#include <memory>
#include <utility>

class Pool {
    public:
        using Task = std::function<void()>;

        Pool(){}
        ~Pool(){}

        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...));
                });
            }
            return wrapper->get_future();         
        }

    private:
        std::queue<Task> mTasks;
        std::mutex mEventMutex;
};

and using it like this:

int task_with_argument(int value)
{
 return value;
}

addTask( task_with_argument, 10 );

and i am getting error:

error: no matching function for call to ‘forward(const int&)’

I've also tried this:

(*wrapper)(std::forward<Agrs>(arguments)...);

and again error:

error: binding reference of type ‘std::remove_reference<int>::type&’ {aka ‘int&’} to ‘const int’ discards qualifiers

Where is a problem?

Answer 1

This call:

std::forward(arguments...)

is not the correct way to use std::forward .

Instead, you should take the arguments to the function as forwarding references:

addTask(Func task, Args &&... arguments)

and then use the arguments like this:

std::forward<Args...>(arguments...)

Answer 2

You attempt to apply perfect forwarding, but this does not make sense in your problem solution. To stow away a task and all its arguments, copies of the arguments have to be made. This defeats all perfect forwarding attempts.

Furthermore, you ask your std::future to store a decltype(task(arguments...) , ie to pick an overload that is invoked without perfectly forwarded arguments. It is inconsistent, to say the least, to do the actual call with perfectly forwarded arguments (if that would have made sense).

Just remove std::forward :

mTasks.emplace([=] { (*wrapper)(arguments...); });