Does std::function support perfect forwarding?

Question

Does std::function support perfect forwarding of arguments? I decided to test it:

struct Widget
{
    void operator()(int const&)
    {
        std::cout << "lvalue";
    }

    void operator()(int&&)
    {
        std::cout << "rvalue";
    }
};

std::function<void(int)> f{Widget()};
int x = 5;
f(x);

Guess which operator() gets called - the one taking rvalue reference. It seems that it is by design. What is the rationale behind this behavior?

Answer 1

Yes and no. Yes, the arguments are forwarded. But no, overload resolution is not done based on the arguments you provide at the point of the call - it's done based on the template arguments to std::function.

std::function<void(int)> means you have a callable that takes an int, which implicitly is an int rvalue. Calling Widget with an rvalue of type int prefers the int&& overload over the int const& overload, which is why that one is selected. It doesn't matter how you invoke the actual function object, once you selected that you want void(int) - that's the preferred overload.

The actual call operator behaves as if:

struct widget_function {
    void operator()(int arg) const {
//  ~~~~~           ~~~~
        w_(std::forward<int>(arg));
//                      ~~~
    }

    Widget w_;
};

The underlined portions come from the signature you provide to std::function. You can see that both f(x) and f(5) end up calling the same operator() from Widget.

---

In short, std::function<Sig> type erases one single overload that satisfies Sig. It does not type erase an entire overload set. You asked for void(int), so you get void(int) and only void(int).