c++ 什么时候/为什么构造/销毁按值捕获的变量

Question

我无法理解调用 C(const C&) 和 ~C() 时发生了什么

因此，我制作了一个按值捕获的 lambda，然后将其返回。 据我了解，每个返回的 lambda 都有自己的上下文（跟踪与该声明一致）。

然而，根据 stroustrup 将 lambda 描述为 function object 快捷方式（在 C++ 第 4 版的 11.4.1 中），我希望只为捕获的变量制作一份副本，但事实并非如此。

这是我的代码

//g++  5.4.0
#include <functional>
#include <iostream>
using namespace std;

class C{
    float f; 
  public:
    C(float f): f(f){ cout << "#build C(" << f << ")\n"; }
    C(const C& c): f(c.f+0.1){ cout << "#copy C(" << f << ")\n"; }
    ~C(){ cout << "#destroy C(" << f << ")\n"; }
    void display() const { cout << "this is C(" << f << ")\n"; }
};

std::function<void(void)> make_lambda_val(int i){
    C c{i};
    return [=] () -> void { c.display(); } ;
}

int main(){
    cout << "/**trace\n\n";
    cout << "---  ??  ---\n";
    {
        auto l0 = make_lambda_val(0);
        auto l1 = make_lambda_val(1);
        auto l2 = make_lambda_val(2);
        cout << "ready\n";
        l0();
        l1();
        l2();
    }
    cout << "\n*/\n";
}

以及相应的痕迹：（附上我的评论）

/**trace

---  ??  ---
#build C(0)
#copy C(0.1)     <<--|  2 copies ??
#copy C(0.2)     <<--|  
#destroy C(0.1)  <----  one of which is already discarded ?
#destroy C(0)
#build C(1)
#copy C(1.1)
#copy C(1.2)
#destroy C(1.1)
#destroy C(1)
#build C(2)
#copy C(2.1)
#copy C(2.2)
#destroy C(2.1)
#destroy C(2)
ready
this is C(0.2)   <---- the second copy is kept ?
this is C(1.2)
this is C(2.2)
#destroy C(2.2)
#destroy C(1.2)
#destroy C(0.2)

*/

Answer 1

您的std::function<void(void)>来自 lambda making function make_lambda_val(int)的返回类型为此分析添加了额外的复制复杂性层，这解释了您在跟踪 output 中标记的额外复制。

为了简化，通过将make_lambda_val(int) function 完全替换为以下 lambda 来替换额外的std::function层，从而使 lambda object（范围在main()中）：

auto make_lambda_val = [](int i){
    C c(i);
    return [=] () -> void { c.display(); };
};

在这种情况下，您的跟踪 output 看起来符合预期：

/**trace

---  ??  ---
#build C(0)
#copy C(0.1)
#destroy C(0)
#build C(1)
#copy C(1.1)
#destroy C(1)
#build C(2)
#copy C(2.1)
#destroy C(2)
ready
this is C(0.1)
this is C(1.1)
this is C(2.1)
#destroy C(2.1)
#destroy C(1.1)
#destroy C(0.1)

*/

Answer 2

我希望只为捕获的变量制作一份副本

事实上，捕获的变量被复制了一次。 也就是说，它只是一次复制操作中的源。

std::function不是 lambda。它的初始化涉及复制可调用对象 object。因此，当将lambda复制到std::function时，它按值保存的变量也会被复制。 当 function 返回时，lambda 临时文件被销毁。 您看到的是您创建的 lambda 内部变量的破坏。