在std :: function operator（）和std :: forward中发生了什么？

Question

I was looking at the std::function implementation and its call operator()

template<typename Ret, typename... ArgTypes>
Ret function< Ret (ArgTypes...)>::operator()(ArgTypes...args) const
{
  // some stuff
  return invoker(functor, std::forward<ArgTypes>(args)...);
}

I was particularly wondering, why it uses std::forward here? Does this anything have to do with perfect forwarding? Because perfect forwarding could only be done if operator() is a template with a variadic template declaration template<typename... Args> (which it is not, the declaration is a partial specialization of std::function ). What is the intention of using std::forward here? I am confused :-)?

Answer 1

You are correct that this is not your typical "perfect forwarding" scenario. A brief example can help illustrate the motivation. Assume a type A with instrumented constructors and destructor:

#include "A.h"
#include <functional>
#include <iostream>

int
main()
{
    A a1{1};
    A a2{2};
    std::function<void(A, A&)> f{[](A x, A& y){}};
    f(a1, a2);
}

This will output:

A(int state): 1
A(int state): 2
A(A const& a): 1
A(A&& a): 1
~A(1)
~A(-1)
~A(2)
~A(1)

Explanation:

a1 and a2 are constructed on the stack. Then when passed into the function invoker, a1 is first copied to bind to the first by-value parameter, and then std::forward<A> is called on a1 which moves it from the by-value parameter into the lambda.

In contrast, a2 need not be copied to bind to the function A& parameter, and then std::forward<A&>(a2) is called, which forwards a2 as an lvalue instead of rvalue, and this binds to the A& parameter of the lambda.

Then things get destructed. The ~A(-1) indicates the destruction of an A in a move-constructed-from state with this instrumented A .

In summary, even though ArgTypes isn't deduced as in the usual perfect forwarding idiom, we still want to forward by-value ArgTypes as rvalues, and by-reference ArgTypes as lvalues. So std::forward just happens to do exactly what we want here.

Answer 2

I think you are confused by many things here.

First, perfect forwarding has nothing to do with variadic templates. You could create a wrapper class that has a function that takes one argument and forward it to the wrapped object :

template<typename T>
struct Wrapper {
    template<typename Arg>
    decltype(auto) test(Arg&& arg) {
        return t.test(std::forward<Arg>(arg));
    }

    T t;
};

Notice the use of perfect forwarding here without any variadic templates. If t.test would require a move only type as parameter, it would not be possible to call it without the forward<Arg>(arg) .

---

The second thing happening here is the parameter not being followed by && . Adding && to ArgTypes would be a mistake and would make some cases fail to compile. Consider this simple case :

std::function<void(int)> f;
int i = 0;
f(i);

That would fail to compile. If you add && to ArgTypes , every parameters that are not reference (eg. int ) would become an rvalue reference on the call operator (in our case, int&& ). Since all parameter types are already qualified correctly in the std::function argument list, what you want to recieve in the call operator is exactly those types, not transformed.

The why you need std::forward if you don't use && ? Because even though you don't need to infer value categories, you still need to not copy every arguments to the contained function. If one of the std::function 's parameter is int& , you don't want to move it. But if one of the parameter is std::unique_ptr<int> , you must move it! And this is exactly what std::forward is for. Moving only what should be moved.

Answer 3

std::forward只是将rvalue引用附加到类型，因此考虑引用折叠规则，它有效地传递引用参数as-is并移动对象参数。