C++11中的lambda表达式是什么？我什么时候用？他们解决了哪类在介绍之前不可能解决的问题？
一些示例和用例将是有用的。
当前回答
问题是
C++包括一些有用的通用函数，如std:：for_each和std:：transform，它们非常方便。不幸的是，它们使用起来也很麻烦，特别是如果要应用的函子对于特定函数是唯一的。
#include <algorithm>
#include <vector>
namespace {
struct f {
void operator()(int) {
// do something
}
};
}
void func(std::vector<int>& v) {
f f;
std::for_each(v.begin(), v.end(), f);
}
如果只在特定的地方使用f一次，那么编写一个完整的类来做一些琐碎的事情似乎是过度的。
在C++03中，您可能会尝试编写以下内容，以保持函子为本地函数：
void func2(std::vector<int>& v) {
struct {
void operator()(int) {
// do something
}
} f;
std::for_each(v.begin(), v.end(), f);
}
但是这是不允许的，f不能传递给C++03中的模板函数。
新的解决方案
C++11引入了lambdas，它允许您编写一个内联的匿名函子来替换结构f。对于小的简单示例，这样读起来更干净（它将所有内容都放在一个地方），维护起来也可能更简单，例如以最简单的形式：
void func3(std::vector<int>& v) {
std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}
Lambda函数只是匿名函子的语法糖。
返回类型
在简单的情况下，lambda的返回类型是为您推导的，例如：
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) { return d < 0.00001 ? 0 : d; }
);
}
然而，当您开始编写更复杂的lambda时，您将很快遇到编译器无法推断返回类型的情况，例如：
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
要解决此问题，您可以使用->T显式指定lambda函数的返回类型：
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) -> double {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
“捕获”变量
到目前为止，除了在lambda中传递给lambda之外，我们还没有使用其他变量，但我们也可以在lambda内使用其他变量。如果您想访问其他变量，可以使用capture子句（表达式的[]），该子句在这些示例中尚未使用，例如：
void func5(std::vector<double>& v, const double& epsilon) {
std::transform(v.begin(), v.end(), v.begin(),
[epsilon](double d) -> double {
if (d < epsilon) {
return 0;
} else {
return d;
}
});
}
您可以通过引用和值捕获，可以分别使用&和=指定：
[&epsilon，zeta]通过引用获取epsilon并通过值获取zeta[&]通过引用捕获lambda中使用的所有变量[=]按值捕获lambda中使用的所有变量[&，epsilon]通过引用捕获lambda中使用的所有变量，但通过值捕获epsilon[=，&epsilon]通过值捕获lambda中使用的所有变量，但通过引用捕获epsilon
默认情况下，生成的运算符（）是常量，这意味着当您默认访问捕获时，捕获将是常量。这样做的效果是，使用相同输入的每个调用都会产生相同的结果，但是您可以将lambda标记为可变，以请求生成的运算符（）不是常量。
其他回答
lambda函数是您在线创建的匿名函数。它可以捕获一些已经解释过的变量（例如。http://www.stroustrup.com/C++11FAQ.html#lambda），但存在一些限制。例如，如果有这样的回调接口，
void apply(void (*f)(int)) {
f(10);
f(20);
f(30);
}
您可以当场编写一个函数来使用它，就像下面传递给应用程序的函数一样：
int col=0;
void output() {
apply([](int data) {
cout << data << ((++col % 10) ? ' ' : '\n');
});
}
但你不能这样做：
void output(int n) {
int col=0;
apply([&col,n](int data) {
cout << data << ((++col % 10) ? ' ' : '\n');
});
}
由于C++11标准的限制。如果您想使用捕获，则必须依赖库和
#include <functional>
（或其他类似STL库的算法来间接获取），然后使用std:：function，而不是像这样传递普通函数作为参数：
#include <functional>
void apply(std::function<void(int)> f) {
f(10);
f(20);
f(30);
}
void output(int width) {
int col;
apply([width,&col](int data) {
cout << data << ((++col % width) ? ' ' : '\n');
});
}
问题是
C++包括一些有用的通用函数，如std:：for_each和std:：transform，它们非常方便。不幸的是，它们使用起来也很麻烦，特别是如果要应用的函子对于特定函数是唯一的。
#include <algorithm>
#include <vector>
namespace {
struct f {
void operator()(int) {
// do something
}
};
}
void func(std::vector<int>& v) {
f f;
std::for_each(v.begin(), v.end(), f);
}
如果只在特定的地方使用f一次，那么编写一个完整的类来做一些琐碎的事情似乎是过度的。
在C++03中，您可能会尝试编写以下内容，以保持函子为本地函数：
void func2(std::vector<int>& v) {
struct {
void operator()(int) {
// do something
}
} f;
std::for_each(v.begin(), v.end(), f);
}
但是这是不允许的，f不能传递给C++03中的模板函数。
新的解决方案
C++11引入了lambdas，它允许您编写一个内联的匿名函子来替换结构f。对于小的简单示例，这样读起来更干净（它将所有内容都放在一个地方），维护起来也可能更简单，例如以最简单的形式：
void func3(std::vector<int>& v) {
std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ });
}
Lambda函数只是匿名函子的语法糖。
返回类型
在简单的情况下，lambda的返回类型是为您推导的，例如：
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) { return d < 0.00001 ? 0 : d; }
);
}
然而，当您开始编写更复杂的lambda时，您将很快遇到编译器无法推断返回类型的情况，例如：
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
要解决此问题，您可以使用->T显式指定lambda函数的返回类型：
void func4(std::vector<double>& v) {
std::transform(v.begin(), v.end(), v.begin(),
[](double d) -> double {
if (d < 0.0001) {
return 0;
} else {
return d;
}
});
}
“捕获”变量
到目前为止，除了在lambda中传递给lambda之外，我们还没有使用其他变量，但我们也可以在lambda内使用其他变量。如果您想访问其他变量，可以使用capture子句（表达式的[]），该子句在这些示例中尚未使用，例如：
void func5(std::vector<double>& v, const double& epsilon) {
std::transform(v.begin(), v.end(), v.begin(),
[epsilon](double d) -> double {
if (d < epsilon) {
return 0;
} else {
return d;
}
});
}
您可以通过引用和值捕获，可以分别使用&和=指定：
[&epsilon，zeta]通过引用获取epsilon并通过值获取zeta[&]通过引用捕获lambda中使用的所有变量[=]按值捕获lambda中使用的所有变量[&，epsilon]通过引用捕获lambda中使用的所有变量，但通过值捕获epsilon[=，&epsilon]通过值捕获lambda中使用的所有变量，但通过引用捕获epsilon
默认情况下，生成的运算符（）是常量，这意味着当您默认访问捕获时，捕获将是常量。这样做的效果是，使用相同输入的每个调用都会产生相同的结果，但是您可以将lambda标记为可变，以请求生成的运算符（）不是常量。
什么是lambda函数？
lambda函数的C++概念起源于lambda演算和函数编程。lambda是一个未命名的函数，对于不可能重用且不值得命名的短代码片段非常有用（在实际编程中，而不是理论上）。
在C++中，lambda函数的定义如下
[]() { } // barebone lambda
或在它所有的荣耀
[]() mutable -> T { } // T is the return type, still lacking throw()
[]是捕获列表，（）是参数列表，{}是函数体。
捕获列表
捕获列表定义了lambda外部的哪些内容应该在函数体内部可用，以及如何使用。它可以是：
a值：[x]参考[&x]通过引用[&]当前作用域中的任何变量与3相同，但按值[=]
您可以在逗号分隔的列表[x，&y]中混合上述任何一项。
参数列表
参数列表与任何其他C++函数中的参数列表相同。
功能体
实际调用lambda时将执行的代码。
退货类型扣除
如果lambda只有一个return语句，则可以省略返回类型，并具有decltype（return_statement）的隐式类型。
可变的
如果lambda标记为可变（例如[]（）mutable｛｝），则允许对值捕获的值进行变异。
用例
ISO标准定义的库从lambdas中受益匪浅，并将可用性提高了几级，因为现在用户不必在某些可访问范围内使用小函子来扰乱代码。
C++14
在C++14中，各种提议扩展了lambdas。
已初始化Lambda捕获
捕获列表的元素现在可以用=初始化。这允许重命名变量并通过移动进行捕获。标准示例：
int x = 4;
auto y = [&r = x, x = x+1]()->int {
r += 2;
return x+2;
}(); // Updates ::x to 6, and initializes y to 7.
还有一张来自维基百科，展示了如何使用std:：move:
auto ptr = std::make_unique<int>(10); // See below for std::make_unique
auto lambda = [ptr = std::move(ptr)] {return *ptr;};
通用Lambdas
Lambdas现在可以是通用的（如果T是周围范围中的某个类型模板参数）：
auto lambda = [](auto x, auto y) {return x + y;};
改进的回报类型扣除
C++14允许为每个函数推导返回类型，并且不将其限制为返回表达式形式的函数；。这也扩展到lambdas。
答案
Q： C++11中的lambda表达式是什么？
A： 实际上，它是带有重载运算符（）常量的自动生成类的对象。这种对象称为闭包，由编译器创建。这个“闭包”概念与C++11中的绑定概念相近。但lambdas通常生成更好的代码。通过闭包的调用允许完全内联。
Q： 我什么时候用？
A： 要定义“简单而小的逻辑”，请编译器根据前面的问题进行生成。你给编译器一些表达式，你想在operator（）里面。编译器将为您生成所有其他内容。
Q： 他们解决了哪类在介绍之前不可能解决的问题？
A： 这是一种语法糖，类似于运算符重载，而不是用于自定义添加、子轻触操作的函数。。。但它节省了更多不需要的代码行，以便将1-3行实际逻辑包装到某些类中，等等。！一些工程师认为，如果行数较少，那么出错的机会就会减少（我也这么认为）
用法示例
auto x = [=](int arg1){printf("%i", arg1); };
void(*f)(int) = x;
f(1);
x(1);
关于lambdas的附加信息，问题不涉及。如果您不感兴趣，请忽略此部分
1.捕获的值。您可以捕获的内容
1.1.可以引用静态存储持续时间为lambda的变量。他们都被抓住了。
1.2.您可以使用lambda“按值”捕获值。在这种情况下，捕获的vars将被复制到函数对象（闭包）。
[captureVar1,captureVar2](int arg1){}
1.3.你可以捕捉参考在此上下文中，指的是引用，而不是指针。
[&captureVar1,&captureVar2](int arg1){}
1.4.存在通过值或引用捕获所有非静态变量的符号
[=](int arg1){} // capture all not-static vars by value
[&](int arg1){} // capture all not-static vars by reference
1.5.存在通过值或引用捕获所有非静态变量并指定smth的符号。更多示例：通过值捕获所有非静态变量，而是通过引用捕获Param2
[=,&Param2](int arg1){}
通过引用而不是通过值捕获Param2捕获所有静态变量
[&,Param2](int arg1){}
2.退货类型扣除
2.1.如果Lambda是一个表达式，则可以推断出Lambda返回类型。或者可以显式指定它。
[=](int arg1)->trailing_return_type{return trailing_return_type();}
如果lambda有多个表达式，则必须通过尾随返回类型指定返回类型。同样，类似的语法也可以应用于自动函数和成员函数
3.捕获的值。您无法捕获的内容
3.1.您只能捕获本地变量，而不能捕获对象的成员变量。
4.转换
4.1 !! Lambda不是函数指针，也不是匿名函数，但无捕获Lambda可以隐式转换为函数指针。
附笔
有关lambda语法信息的更多信息，请参阅编程语言C++#337的工作草案，2012-01-16，5.1.2。Lambda表达式，第88页在C++14中，添加了名为“init capture”的额外功能。它允许任意声明闭包数据成员：auto-toFloat=[]（int值）｛return float（value）；｝；自动插值=[min=toFloat（0），max=toFlat（255）]（int值）->float｛return（value-min）/（max-min）；｝；
嗯，我发现的一个实际用途是减少锅炉板代码。例如：
void process_z_vec(vector<int>& vec)
{
auto print_2d = [](const vector<int>& board, int bsize)
{
for(int i = 0; i<bsize; i++)
{
for(int j=0; j<bsize; j++)
{
cout << board[bsize*i+j] << " ";
}
cout << "\n";
}
};
// Do sth with the vec.
print_2d(vec,x_size);
// Do sth else with the vec.
print_2d(vec,y_size);
//...
}
如果没有lambda，您可能需要为不同的bsize情况做一些事情。当然，你可以创建一个函数，但如果你想将使用限制在soul用户函数的范围内呢？lambda的性质满足这一要求，我将其用于这种情况。
