使用 lambda 创建 std::function 会导致多余的 lambda 对象复制 - 为什么？

Question

当我用捕获值的 lambda 构造 std::function 时，它会额外复制（移动）这些参数（实际上是我猜的整个 lambda 对象）。 代码：

#include <iostream>
#include <functional>

// Testing class - just to see constructing/destructing.
class T {
private:
    static int idCounter; // The global counter of the constructed objects of this type.
public:
    const int id; // Unique object ID 

    inline T() : id(++idCounter) { 
        std::cout << "  Constuctor Id=" << id << std::endl;
    };
    inline T(const T& src) : id(++idCounter) {
        std::cout << "  Copy constructor Id=" << id << std::endl;
    }
    inline T(const T&& src) : id(++idCounter) {
        std::cout << "  Move constructor Id=" << id  << std::endl;
    }
    inline void print() const {
        std::cout << "  Print is called for object with id=" << id << std::endl;
    }
    inline ~T() {
        std::cout << "  Destructor Id=" << id << std::endl;
    }
};

int T::idCounter=0; 

// Declare type of the std::function to store our lambda.
typedef std::function<int (void)> Callback;

int main()
{ 
    std::cout << "Let's the game begin!" << std::endl;
    T obj; // Custruct the first object.
    std::cout << "Let's create a pointer to the lambda." << std::endl;
    // Make a labmda with captured object. (The labmda prints and returns object's id).
    // It should make one (local) copy of the captured object but it makes it twice - why?!
    const Callback* pcb= new Callback( [obj]() -> int { 
        obj.print();
        return obj.id; 
    } );
    std::cout << "Now let's print lambda execution result."  << std::endl;
    std::cout << "The functor's id is " << (*pcb)() << std::endl;
    std::cout << "Destroying the lambda." << std::endl;
    delete pcb;
    std::cout << "Terminating." << std::endl;
    return 0;

}

输出是：

让我们的游戏开始！ 构造函数 ID=1 让我们创建一个指向 lambda 的指针。 复制构造函数 ID=2 移动构造函数 Id=3 析构函数 ID=2 现在让我们打印 lambda 执行结果。 为 id=3 的对象调用打印 函子的 id 是 3 销毁 lambda。 析构函数 ID=3 终止。 析构函数 ID=1

我用捕获的对象制作了一个带有 lambda 的 std:function。它应该为 lambda 制作对象的本地副本，但它会复制两次（查看移动构造函数调用 - 以粗体突出显示）。实际上它会复制整个 lambda 对象。为什么？我怎样才能避免这种情况？ 我正在使用 lambdas 进行线程间事件处理，它们可能会捕获大量的日期，所以我试图找到一种方法来避免不必要的复制。所以任务很简单——以最少的费用将构造的 lambda 传递给函数——如果它会为每个构造的 lambda 复制两次数据，我会寻找另一种处理事件的方法。
我正在使用强制 GNU C++11 的 GCC v4.7.2。

Answer 1

好吧，输出令人困惑，因为编译器执行了一次复制省略。所以为了理解行为，我们需要暂时禁用复制省略。编译代码时使用-fno-elide-constructors标志：

$ g++ -std=c++11 -fno-elide-constructors main.cpp

现在它给出了这个输出 (demo-without-copy-elision)：

Let's create a pointer to the lambda.
  Copy constructor Id=2
  Move constructor Id=3
  Move constructor Id=4
  Destructor Id=3
  Destructor Id=2

嗯，这是意料之中的。 copy 在创建 lambda 时完成：

 [obj]() -> int { 

//^^^^ COPY!

    obj.print();
    return obj.id; 
}

嗯，这太明显了！

现在来到不明显的事情：两个移动操作！

first move是在将lambda传递给std::function的构造函数时完成的，因为lambda是一个rvalue，因此move -构造函数被调用。请注意，-fno-elide-constructors 也禁用了移动省略（毕竟这只是所谓的更快的复制版本！）。

second move 完成，当在构造函数初始化中写入（当然是moving）std::function 的成员数据时-列表。

到目前为止一切顺利。

现在，如果您删除 -fno-elide-constructors，编译器会优化掉 first move（因为它不会调用 move 构造函数），这就是为什么输出是这样的：

Let's create a pointer to the lambda.
  Copy constructor Id=2
  Move constructor Id=3
  Destructor Id=2

见demo-with-copy-elision。

现在你看到的 move 是因为将 lambda 移动到 std::function 的成员数据中。你不能避免这个移动。

另请注意，复制/移动 lambda 也会导致复制/移动捕获的数据（即递归复制/移动）。

无论如何，如果您担心复制捕获的对象（假设它是一个巨大的对象），那么我建议您使用new 创建捕获的对象，以便复制捕获的对象意味着复制指针（4或 8 个字节！）。那应该很好用！

希望对您有所帮助。

Answer 2

它不会复制两次。搬家被认为是一种廉价的操作，实际上在 99% 的情况下都是如此。对于“计划旧数据”类型（结构、整数、双精度、...），双重复制不是问题，因为大多数编译器会消除冗余副本（数据流分析）。对于容器来说，移动是一种非常便宜的操作。

Answer 3

正如 cmets 中的Nawaz 所提到的，当 lambda 表达式移动到 std::function<int(void)>（类型定义为 Callback )。

const Callback* pcb= new Callback( [obj]() -> int { 
    obj.print();
    return obj.id; 
} );

这里的对象obj是通过值（复制构造）传递给lambda表达式，但另外，整个lambda表达式作为r值传递给Callback（std::function）的构造函数，并且是因此移动复制到 std::function 对象中。移动 lambda 时，所有状态也必须一起移动，因此 obj 也被移动（实际上涉及 obj 的两个移动构造，但其中一个通常由编译器优化）。

等效代码：

auto lambda = [obj]() -> int {                        // Copy obj into lambda.
    obj.print();
    return obj.id; 
};

const Callback* pcb= new Callback(std::move(lambda)); // Move lambda (and obj).

移动操作被认为是廉价的，不会导致任何昂贵的数据复制（在大多数情况下）。

您可以在此处阅读有关移动语义的更多信息：What are move semantics?。

最后如果您不想复制obj，那么只需在 lambda 中通过 reference 捕获它：

const Callback* pcb= new Callback( [&obj]() -> int { 
    obj.print();
    return obj.id; 
} );