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标记为可变，以请求生成的运算符（）不是常量。
其他回答
问题是
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标记为可变，以请求生成的运算符（）不是常量。
c++中的lambda被视为“随时可用的函数”。是的，你可以定义它；使用它；当父函数作用域结束时，lambda函数就消失了。
c++在c++11中引入了它，每个人都开始在每个可能的地方使用它。示例和lambda是什么可以在这里找到https://en.cppreference.com/w/cpp/language/lambda
我将描述每个c++程序员都必须知道的，但不存在哪些
Lambda并不意味着要在任何地方使用，每个函数都不能用Lambda替换。与正常功能相比，它也不是最快的。因为它有一些需要由lambda处理的开销。
在某些情况下，它肯定有助于减少线路数量。它基本上可以用于一段代码，这段代码在同一个函数中被调用一次或多次，在其他任何地方都不需要这段代码，因此您可以为它创建独立的函数。
下面是lambda的基本示例以及在后台发生的情况。
用户代码：
int main()
{
// Lambda & auto
int member=10;
auto endGame = [=](int a, int b){ return a+b+member;};
endGame(4,5);
return 0;
}
compile如何扩展它：
int main()
{
int member = 10;
class __lambda_6_18
{
int member;
public:
inline /*constexpr */ int operator()(int a, int b) const
{
return a + b + member;
}
public: __lambda_6_18(int _member)
: member{_member}
{}
};
__lambda_6_18 endGame = __lambda_6_18{member};
endGame.operator()(4, 5);
return 0;
}
正如您所看到的，当您使用它时，它会增加什么样的开销。所以在任何地方使用它们都不是好主意。它可以在适用的地方使用。
Lambda表达式通常用于封装算法，以便将它们传递给另一个函数。但是，可以在定义后立即执行lambda：
[&](){ ...your code... }(); // immediately executed lambda expression
在功能上等同于
{ ...your code... } // simple code block
这使得lambda表达式成为重构复杂函数的强大工具。首先在lambda函数中包装一个代码段，如上所示。然后，显式参数化过程可以在每个步骤之后通过中间测试逐步执行。一旦代码块完全参数化（如删除&所示），就可以将代码移动到外部位置并使其成为正常函数。
类似地，您可以使用lambda表达式根据算法的结果初始化变量。。。
int a = []( int b ){ int r=1; while (b>0) r*=b--; return r; }(5); // 5!
作为划分程序逻辑的一种方法，您甚至可能会发现将lambda表达式作为参数传递给另一个lambda表达式是有用的。。。
[&]( std::function<void()> algorithm ) // wrapper section
{
...your wrapper code...
algorithm();
...your wrapper code...
}
([&]() // algorithm section
{
...your algorithm code...
});
Lambda表达式还允许您创建命名的嵌套函数，这是避免重复逻辑的一种方便方法。当将一个非平凡函数作为参数传递给另一个函数时，使用命名的lambdas看起来也容易一些（与匿名内联lambdas相比）。注意：不要忘记右大括号后面的分号。
auto algorithm = [&]( double x, double m, double b ) -> double
{
return m*x+b;
};
int a=algorithm(1,2,3), b=algorithm(4,5,6);
如果后续的分析揭示了函数对象的大量初始化开销，您可以选择将其作为普通函数重写。
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');
});
}
嗯，我发现的一个实际用途是减少锅炉板代码。例如：
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的性质满足这一要求，我将其用于这种情况。
推荐文章
- decltype(auto)的一些用途是什么?
- Shared_ptr转换为数组:应该使用它吗?
- Printf与std::字符串?
- 禁用复制构造函数
- 只接受特定类型的c++模板
- 在c#中，什么是单子?
- c#和Java中的泛型有什么不同?和模板在c++ ?
- Java 8: Lambda-Streams，过滤方法与异常
- c++ 11中的递归lambda函数
- 在c++中指针使用NULL或0(零)吗?
- 在c++中，如何将int值附加到字符串中?
- 就性能而言，使用std::memcpy()还是std::copy()更好?
- 为什么布尔值是1字节而不是1位?
- 四舍五入到一个数字的最接近倍数
- 不能在lambda表达式中使用ref或out参数
