当在类中使用时，lambda捕获列表中的[this]和[＆]是否等效？

Question

在以下示例中，捕获列表中使用[this]与捕获列表中使用捕获引用[&]相反，如图所示，有什么区别？我已经试过并且他们产生相同的输出。

#include <iostream>               

class Test {                 
public:                  
    int x = 2;                 
    void test1(void) { std::cout << "test1" << std::endl; };     

    void test_lambda(void) {             
     auto lambda = [&]() {            
      std::cout << "x: " << x << " y: " << y << " z: " << z << std::endl; 
      this->test1();               
     };                 

     lambda();                
    }                   

protected:                 
    int y = 3;                 

private:                  
    int z = 4;                 
};                   

int main() {                 
    Test t;                 
    t.test_lambda();               
} 

在C++编程语言，Stroustrop说：

Members are always captured by reference. That is, [this] implies that members are accessed through this rather than copied into the lambda. 

这似乎在暗示，他们可能意味着同样的事情。如果是这样的话，为什么我们需要[这个]？

Answer 1

根据cppreference：

[&]捕获由参考通过引用和当前对象拉姆达的主体中使用的所有的自动变量如果而使用存在

[此]将捕获只有this指针。

当你在范围有自动变量这会有所不同，e.g：

struct Test { 
    void run() { 
    int y = 2; 

    // all automatic variables are accessible, both local and members 
    auto l1 = [&](){ cout << x << " " << y << endl; }; 
    l1(); 

    // y is not accessible, x is only because it's a member 
    auto l2 = [this]() { cout << this->x << endl; }; 
    l2(); 
    } 

    int x = 1; 
}; 

int main() { 
    Test t; 
    t.run(); 
} 

那么，我们为什么需要它？

允许捕获[this]与允许捕获任何其他指针相同。

为什么不总是捕获所有的自动变量？有几个原因，其中包括：

• 封装：有时候，你不希望拉姆达熟悉其他值
• 灵活性：有时候，我们需要复制一些价值观和通过它们其中的一些参考

注：使用&不会引入额外的性能开销捕获所有的自动变量，因为编译器只传递ŧ他在lambda中使用的变量。

Answer 2

&捕获范围内引用的所有变量。试想一下：

void test_lambda(void) {             
    int dummy = 42;     // capture dummy ?!? 
    auto lambda = [&]() {    // yes         
     std::cout << "x: " << x << " y: " << y << " z: " << z << std::endl; 
     this->test1(); 
     std::cout << dummy;   // ok here              
    };                 
    lambda();                
} 

[this]不会捕捉局部变量意志[&]。

Answer 3

捕捉到成员的唯一方法是通过捕获this：

• 明确[this](){ member = 42; }
• 含蓄地捕获由价值[=](){ member = 42;}
• 含蓄地捕获参考[&](){ member = 42; }

以下是非法

• [&member](){ member = 42; } // illegal
• [member](){ std::cout << member; } // illegal。

然后根据您的打算表示捕获的限制，你可能会被明确或不进行选择，避免reference捕获（以避免可能悬空参考）...

Answer 4

使用[this]只将捕获this，而[&]捕捉this和所有局部变量从封闭的范围。

struct example { 
    int foo; 

    example() { 
    int bar; 

    [this]() { 
     foo = {}; 
     bar = {}; // error: 'bar' is not captured 
    }(); 

    [&]() { 
     foo = {}; 
     bar = {}; 
    }(); 
    } 
}; 

您可以使用[this]如果您关闭将封闭范围内的外部调用，就像一个成员函数，因为所有的局部变量将被销毁。

struct example { 
    int value = 42; 

    example() { 
    frobnicate = [this]() { 
     std::cout << value << std::endl; 
    }; 
    } 

    std::function<void()> frobnicate; 
}; 

example x; 
x.frobnicate(); 

您可以使用[&]如果您关闭将封闭的范围内被调用，像一块本地代码，如局部变量仍然活着。

struct example { 
    int value = 42; 

    example() { 
    int values[] = {1, 2, 3}; 

    std::for_each(std::begin(values), std::end(values), [&](int& v) { 
     std::cout << v * value << std::endl; 
    }); 
    } 
};