什么是C ++ 11中的lambdaexpression式？

什么是C ++ 11中的lambdaexpression式？我什么时候可以用一个？他们解决什么types的问题在引入之前是不可能的？

一些例子和用例会很有用。

问题

C ++包括有用的通用函数，如std::for_each和std::transform ，这可以非常方便。不幸的是，它们的使用也很麻烦，特别是如果你想要应用的函数对于特定函数是独一无二的。

 #include <algorithm> #include <vector> namespace { struct f { void operator()(int) { // do something } }; } void func(std::vector<int>& v) { ff; std::for_each(v.begin(), v.end(), 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中的模板函数。

新的解决scheme

C ++ 11引入lambda允许你编写一个内联的匿名仿函数来代替struct f 。对于简单的小例子来说，它可以更清晰地阅读（它将所有内容保存在一个地方），并且可能更简单，例如以最简单的forms：

 void func3(std::vector<int>& v) { std::for_each(v.begin(), v.end(), [](int) { /* do something here*/ }); }

Lambda函数只是匿名函数的语法糖。

返回types

在简单情况下，lambda的返回types是为你推导的，例如：

 void func4(std::vector<double>& v) { std::transform(v.begin(), v.end(), v.begin(), [](double d) { return d < 0.00001 ? 0 : d; } ); }

但是当你开始编写更复杂的lambda时，你会很快遇到编译器无法推导出返回types的情况，例如：

 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函数明确指定一个返回types：

 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; } }); }

“捕捉”variables

到目前为止，我们还没有使用除传递给它内部lambda以外的任何内容，但是我们也可以在lambda内使用其他variables。如果你想访问其他的variables，你可以使用capture子句（expression式的[] ），这个例子中迄今还没有被使用，例如：

 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; } }); }

您可以通过引用和值来捕获，您可以分别使用&和=指定值：

通过引用俘获
[&]通过引用捕获lambda中使用的所有variables
[=]通过值捕获lambda中使用的所有variables
[&, epsilon]用[＆ [&, epsilon]捕获variables，但是按值赋值为epsilon
[=, &epsilon]捕获像[=]的variables，但通过引用的epsilon

生成的operator()在默认情况下是const ，默认情况下，当你访问它们时，捕获的含义是const 。这样做的结果是每个具有相同input的调用都会产生相同的结果，但是您可以将lambda标记为mutable来请求生成的operator()不是const 。

什么是lambda函数？

lambda函数的C ++概念起源于lambda演算和函数式编程。 lambda是一个未命名的函数，在实际的编程中非常有用，但对于不可重复使用的短代码片段并不值得命名。

在C ++中，lambda函数是这样定义的

 []() { } // barebone lambda

或者所有的荣耀

 []() mutable -> T { } // T is the return type, still lacking throw()

[]是捕获列表， ()参数列表和{}函数体。

捕获列表

捕获列表定义了函数体内lambda的外部应该是什么，以及如何。它可以是：

值：[x]
一个参考[＆x]
目前在参考范围内的任何variables[＆]
与3相同，但值[=]

你可以用逗号分隔的列表[x, &y]混合上述任何一个。

参数列表

参数列表与其他C ++函数中的相同。

function体

实际调用lambda时将执行的代码。

返回types扣除

如果lambda只有一个return语句，则可以省略返回types，并且具有隐式types的decltype(return_statement) 。

易变的

如果一个lambda标记为mutable（例如[]() mutable { } ），则允许mutate通过value捕获的值。

用例

由ISO标准定义的库很大程度上受益于lambdaexpression式，并且提高了可用性的几个方面，因为现在用户不需要在一些可访问的范围内使用小的函数来混淆他们的代码。

C ++ 14

在C ++中，14个lambda已经被各种提议所扩展。

初始化的Lambda捕获

捕获列表的一个元素现在可以用=来初始化。这允许重命名variables并通过移动来捕获。以标准为例：

 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现在可以是generics的（如果T是周围范围中的某个types模板参数， auto在这里等于T ）：

 auto lambda = [](auto x, auto y) {return x + y;};

改进的退货types扣除

C ++ 14允许为每个函数推导返回types，并且不会将其限制为formsreturn expression;函数return expression; 。这也延伸到lambda。

Lambdaexpression式通常用于封装algorithm，以便将它们传递给另一个函数。但是， 定义时可以立即执行一个lambdaexpression式 ：

 [&](){ ...your code... }(); // immediately executed lambda expression

在function上等同于

 { ...your code... } // simple code block

这使得lambdaexpression式成为重构复杂函数的有力工具 。如上所示，首先将一个代码段封装在一个lambda函数中。显式参数化的过程可以在每个步骤之后通过中间testing逐渐执行。一旦完成了代码块的参数化（如删除& ），您可以将代码移到外部位置并使其成为正常function。

同样，你可以使用lambdaexpression式来初始化基于algorithm结果的variables 。

 int a = []( int b ){ int r=1; while (b>0) r*=b--; return r; }(5); // 5!

作为划分程序逻辑的一种方法 ，你甚至可能会发现将lambdaexpression式作为parameter passing给另一个lambdaexpression式是有用的。

 [&]( std::function<void()> algorithm ) // wrapper section { ...your wrapper code... algorithm(); ...your wrapper code... } ([&]() // algorithm section { ...your algorithm code... });

Lambdaexpression式还允许您创build命名的嵌套函数 ，这可以是避免重复逻辑的一种便捷方式。在将非平凡函数作为parameter passing给另一个函数时，使用命名lambdas也往往会更容易在眼睛上（与匿名内联lambda相比）。 注意：不要忘记在大括号之后的分号。