Why isn't std::function template constructor using universal reference?

Question

I think that constructor with universal reference parameter has better performance than the one without reference.

From cppreference (https://en.cppreference.com/w/cpp/utility/functional/function/function), we can see that the template constructor for std::function is not using reference.

template< class F > function( F f );

Is it a mistake? If not, why the standard doesn't requires the constructor use universal reference?

EDIT:

Let's think about two cases.

1. F is a built-in type, here a function pointer whose size is 4 bytes.

Using universal reference:

lvalue case: 4 bytes are copied.

rvalue case: 4 bytes are copied. (Will you apply a std::move to built-in type?)

Passing by value:

all cases: 4 bytes are copied.

2. F is a type with non-trivial copy constructor, ex. a lambda type which captures a std::string by value. This example stands for most cases, do you agree?

Using universal reference:

lvalue case: copy constructor is invoked once

rvalue case: move constructor is invoked once

Passing by value:

lvalue case: a move and a copy

rvalue case: a move

Is this classification complete? If so, we can run into the conclusion that universal reference is no worse then passing by value. Then it returns to the original question.

EDIT again:

Maybe lambdas without captures are the most common cases, where passing by value is actually passing nothing while passing by reference is passing a pointer. This may be the key. LWG 2774 is related to this question. See it in comments.

Answer 1

Because that constructor moves its argument, accepting a reference is pointless. This comes down to the usual advice on when to take values.

If you pass a primitive, like an int, passing by reference is a pessimisation. If you pass a complex type, like a std::string, you can already std::move it into the argument (and, if you don't, then that's because you wanted a copy anyway). You get the best of both worlds.

// Bog-standard choice between value and ref; original value only observed

void foo(const int& x) { cout << x << '\n'; }
void foo(const int x) { cout << x << '\n'; }  // Better!

void foo(const std::string& x) { cout << x << '\n'; }  // Better!
void foo(const std::string x) { cout << x << '\n'; }


// When we want to store

void storeACopy(int);
void foo(const int& x) { storeACopy(x); }
void foo(const int x) { storeACopy(x); }  // Better!

void storeACopy(std::string);
void foo(const std::string& x) { storeACopy(x); }  // Meh
void foo(std::string x) { storeACopy(std::move(x)); }  // Cheap!


// So, best of both worlds:
template <typename T>
void foo(T x) { storeACopy(std::move(x)); }

// This performs a copy when needed, but allows callsite to
// move instead (i.e. total flexibility) *and* doesn't require silly
// refs-to-primitives

It also signals to the call site that the original object will not be modified unless you specifically yield ownership with std::move.

If instead the function took a reference, okay you'd potentially save one move if you want to yield. But, moves are supposed to be super-cheap so we're not concerned about that. And if you didn't want to yield then suddenly you have to go through the rigmaroll of an object copy at the callsite. Ugh!

This pattern is key to making the most out of move semantics.

Answer 2

I think that constructor with universal reference parameter has better performance than the one without reference.

Why do you think that? Have you measured? What if we're talking about passing int? Reference (universal / forwarding or not) is not always a boost for performance.

Is it a mistake?

No, it's the standard convention to pass function objects by value. They are meant to be cheap to copy and when implementing own function objects, you should keep that in mind.

If not, why the standard doesn't requires the constructor use universal reference?

Ultimately, why would it? :)