为什么需要 `std::function::operator=(F &&)` 来创建临时 `std::function`？

Question

显然std::function::operator=(F &&f) 是required to behave 与std::function(std::forward<F>(f)).swap(*this); 完全相同。

除非我遗漏了什么，否则这个定义会导致一些多余的移动：

#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{};
}

打印：

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

^{（在 GCC 7.2 和 Clang 3.8 上测试）}

问题：为什么我们不能通过直接复制/移动（取决于值类别）到 LHS 存储中来消除一个移动？

---

编辑：我不是在问为什么这个动作没有被优化掉，而是为什么它一开始就被做了。

Answer 1

为什么有两个动作？

在构造std::function的临时值时，调用的构造函数是

template< class F > 
function( F f );

这是传值，所以第一次移动实际上是移动到这个构造函数的参数中，而第二次移动是移动到临时的。基本上，std::function stores a pointer 到其可调用 target 的典型实现，因此交换指针对于其 swap 函数就足够了，它不会涉及其可调用目标的任何复制/移动。

为什么不直接将 RHS 复制/移动到 LHS 存储中？

由于LHS中存储的callable target的类型可能与RHS不同，所以不能直接进行复制/移动。

swap() 为何参与其中？

这称为copy-and-swap idiom，其行为与strong exception safety 的赋值一样。