Why `std::function::operator=(F &&)` is required to make a temporary `std::function`?

Question

Apparently std::function::operator=(F &&f) is required to behave exactly as std::function(std::forward<F>(f)).swap(*this);.

Unless I'm missing something, this definition causes some superfluous moving:

#include <functional>
#include <iostream>

struct A
{
    A() {std::cout << "A()\n";}
    A(const A &) {std::cout << "A(const A &)\n";}
    A(A &&) {std::cout << "A(A &&)\n";}
    A &operator=(const A &) {std::cout << "A &operator=(const A &)\n"; return *this;}
    A &operator=(A &&) {std::cout << "A &operator=(A &&)\n"; return *this;}
    ~A() {std::cout << "~A()\n";}
    void operator()() const {}
};

int main()
{
    std::function<void()> f;
    f = A{};
}

Prints:

A()        // Created by `A{}`
A(A &&)    // Moved into temporary `std::function`, but what's the point?
A(A &&)    // Moved into `f`
~A()       
~A()
~A()

^{(tested on GCC 7.2 and Clang 3.8)}

Question: Why can't we eliminate one move, by copying/moving (depending on value category) directly into LHS storage?

Edit: I'm not asking why the move is not optimized away, but rather why it's made in the first place.

Do you question why extra move required or why it was not removed by optimization? — Slava, Mar 07 '18 at 14:43
Also, I wonder why said move doesn't reuse the heap-allocated buffer with `A`? — HolyBlackCat, Mar 07 '18 at 14:56

score 1 · Answer 1 · edited Jun 20 '20 at 09:12

1

Why are there two moves?

When constructing the temporary of std::function, the called constructor is

template< class F > 
function( F f );

which is pass-by-value, so the first move is in fact a move into the parameter of this constructor, while the second move is the move into the temporary. Basically, typical implementation of std::function stores a pointer to its callable target, so swapping the pointer is sufficient for its swap function, which will not involve in any copy/move of its callable target.

Why not directly copy/move RHS into LHS storage?

Because the type of the stored callable target in LHS may be different from that of RHS, you cannot directly perform a copy/move.

Why is `swap()` involved in?

This is called copy-and-swap idiom, which behaves as an assignment with strong exception safety.

edited Jun 20 '20 at 09:12

Community

1
1

answered Mar 07 '18 at 18:28

xskxzr

12,442
12
37
77

But one could copy/move into freshly allocated object, and if it doesn't throw, delete the old object and replace the pointer. Is this somehow worse than copy-and-swap apart from requiring slightly more code (which shouldn't concern standard library developers anyway)? – HolyBlackCat Mar 07 '18 at 18:47
Also, your explanation for two moves doesn't look right to me. `std::function f(A{});` produces a single move, which apparently means that the compiler is smart enough to elide move to the parameter and move directly to the internal buffer. So the first move is into the temporary, and the second one seems to be because of the swap. – HolyBlackCat Mar 07 '18 at 19:49
@HolyBlackCat For your first question, I think it needs more words to describe the behavior for the specification, so it's worse (at least no better). For your second question, the compiler can elide the move from `A{}`, but it cannot elide the move from `std::forward(f)` because `f` is an already existed object, not a temporary. You can see an evidence by calling `swap` directly, like [this](https://wandbox.org/permlink/uMpxtLrutJX1iJZN), to see whether there is a move. – xskxzr Mar 08 '18 at 02:03
@HolyBlackCat In addition to your first question, note we are talking about the specification of cppreference (or of the standard), and it does not prevent a real implementation from doing so under as-if rule. – xskxzr Mar 08 '18 at 02:57

Why `std::function::operator=(F &&)` is required to make a temporary `std::function`?

1 Answers1

Why are there two moves?

Why not directly copy/move RHS into LHS storage?

Why is swap() involved in?

Why is `swap()` involved in?