Closure içinde kullanılan değişkenler referans şeklinde saklanır. Değişkenin ömrünün closure'dan fazla olmasına dikkat etmek gerekir. Açıklaması şöyle
a comma-separated list of zero or more captures, optionally beginning with a capture-default. Capture list can be passed as follows [...]:[a,&b] where a is captured by value and b is captured by reference.[this] captures the this pointer by value[&] captures all automatic variables odr-used in the body of the lambda by reference[=] captures all automatic variables odr-used in the body of the lambda by value[] captures nothing
Üretilen Kod
Elimize şöyle bir closure olsun.
[&] { x += 1; } // capture by referenceclass foo {
int &x;
public:
foo(int &x) : x(x) {}
void operator()() const { x += 1; }
};Kullanım
İsim vermeden capture ve isim vererek capture arasındaki fark şöyle
int main()
{
int num = 50;
[&] { std::cout << num << '\n'; }(); // num captured by reference
[=] { std::cout << num << '\n'; }(); // num captured by value
[&num] { std::cout << num << '\n'; }(); // by reference
[num] { std::cout << num << '\n'; }(); // by value
}Örnek - dangling reference
Elimizde şöyle bir kod olsun
#include <iostream>
#include <functional>
std::function<void ()> f()
{
int x = 666;
return [&] { std::cout << x << std::endl; };
}
int main()
{
f()();
return 0;
}Bu kod hatalı. Açıklaması şöyle.
You capture x by reference in the lambda and after leaving f() it becomes a dangling reference as x gets destroyed. You have a classic UB. To avoid it you can capture x by value by writing [x] or [=] instead of [&]
Örnek
Elimizde şöyle bir kod olsun. Burada [&] ile hem yerel değişkenler hem de this kullanılabiliyor.
İsim ile capture ve isim olmadan capture arasındaki fark şöyle.
Yakalama işleminde değişkenin const olup olmadığı önemlidir. const bir değişken değiştirilemez.
Rect rect;
Point point;
auto someLambda = [&](const SomeType& var)
{
if (rect.Contains(point))
{
var.Something();
}
this->MemberFunction();
};Açıklaması şöyle
This ends up grabbing rect and point by reference and also gives you access to this...
2. İsim İle Capture
Örnek
Şöyle yaparız. Sadece cap değişkenine erişileceği belirtilir.
int main() {
const int ci = 0;
auto &cap = ci;
auto lambda = [&cap]() { };
}İsim ile capture ve isim olmadan capture arasındaki fark şöyle.
vector<int> vec;
//a
auto foo = [&vec](){
//do something
};
//b
auto foo = [&v = vec](){
//do something
};Yakalama işleminde değişkenin const olup olmadığı önemlidir. const bir değişken değiştirilemez.
const int i = 5;
auto b = [&i]() { i++; }; //error on i++Şöyle yapılır. Lambda kendi içindeki state bilgisini değiştiremez.
int foo(int i)
{
const auto a = [&i](){...};
...
}2.2 İsim İle Capture ve Değişkene Farklı İsim Vermek
Örnekte ci değişkenine lamda içinde cap değişkeni olarak erişilir. Yani sadece değişkene farklı bir isim tanımlanır.int main() {
const int ci = 0;
auto lambda = [ &cap = ci ]() { };
}Saçma gelse bile capture ederken cast işlemi yapılabiliyor. Const olmayan bir değişken const yapılabiliyor.
#include <iostream>
#include <type_traits>
struct noncopyable
{
int a;
const noncopyable& operator=(noncopyable&&) = delete;
noncopyable(noncopyable&&) = delete;
const noncopyable& operator=(const noncopyable&) = delete;
noncopyable(const noncopyable&) = delete;
~noncopyable() = default;
};
void modify(noncopyable& a)
{
a.a = 0;
}
int main()
{
noncopyable a = { 25 }, b = { 42 };
[&, &a = static_cast<const noncopyable&>(a)]{
modify(b);
//modify(a); // uncommenting this should fail the build
}();
std::cout << a.a << " " << b.a << "\n";
// expected output 25 0
}