什么是 C++11 中的 lambda 表达式？

Posted 2023-02-17

技术标签:

【中文标题】什么是 C++11 中的 lambda 表达式？【英文标题】：What is a lambda expression in C++11? 【发布时间】：2011-10-02 14:58:12 【问题描述】：

我什么时候用一个？他们解决了哪类问题在引入之前无法解决？

几个例子和用例会很有用。

【问题讨论】：

我见过一个 lambda 非常有用的案例：我的一位同事正在编写具有数百万次迭代的代码来解决空间优化问题。该算法在使用 lambda 时比使用适当的函数要快得多！编译器为 Visual C++ 2013。这是另一个非常好的参考资料，它很好地解释了 C++ 中的 lambda 表达式：Microsoft.com: Lambda expressions in C++。我特别喜欢它很好地解释了 lambda 表达式的部分，特别是：capture 子句、参数列表、尾随返回类型和 lambda 主体。跨度> 【参考方案1】：

问题

C++ 包含有用的泛型函数，例如 std::for_each 和 std::transform，它们非常方便。不幸的是，它们使用起来也很麻烦，特别是如果您要应用的 functor 是特定功能所独有的。

#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 中的 template 函数。

新的解决方案

C++11 引入了 lambda，允许您编写一个内联的匿名函子来替换 struct 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 中使用其他变量。如果你想访问其他变量，你可以使用捕获子句（表达式的[]），到目前为止在这些示例中没有使用，例如：

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

生成的operator()默认为const，默认访问时捕获为const。这具有相同输入的每次调用都会产生相同结果的效果，但是您可以mark the lambda as mutable 请求产生的operator() 不是const。

【讨论】：

@Yakk 你被困住了。没有捕获的 lambda 具有到函数类型指针的隐式转换。转换函数为const always... 有趣 - 我最初认为 lambda 是匿名的函数而不是仿函数，并且对捕获的工作原理感到困惑。如果你想在你的程序中使用 lambdas 作为变量，你可以使用：std::function<double(int, bool)> f = [](int a, bool b) -> double ... ; 但通常，我们让编译器推断类型：auto f = [](int a, bool b) -> double ... ;（别忘了@987654354 @) 我想不是每个人都明白为什么return d < 0.00001 ? 0 : d; 在其中一个操作数是整数常量时保证返回双精度（这是因为 ?: 运算符的隐式提升规则，其中第二个和第三个操作数通过通常的算术转换相互平衡，无论选择哪一个）。更改为 0.0 : d 可能会使示例更易于理解。 @MohammadMamunHossain 使用 std::array 数组而不是原始数组，然后它就变得微不足道了。（无论如何，在大多数情况下，这在 C++ 中是个好建议）【参考方案2】：

什么是 lambda 函数？

lambda 函数的 C++ 概念源自 lambda 演算和函数式编程。 lambda 是一个未命名的函数，对于无法重用且不值得命名的短 sn-ps 代码很有用（在实际编程中，而不是理论上）。

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

[]()   // barebone lambda

或者在它的所有荣耀中

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

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

捕获列表

捕获列表定义了 lambda 外部的哪些内容应该在函数体内可用以及如何可用。它可以是：

一个值：[x] 参考 [&x] 当前范围内的任何变量都通过引用 [&] 与 3 相同，但按值 [=]

您可以在逗号分隔的列表[x, &y] 中混合上述任何一种。

参数列表

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

函数体

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

返回类型扣除

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

可变

如果 lambda 被标记为可变（例如 []() mutable ），则允许对已按值捕获的值进行变异。

用例

由 ISO 标准定义的库极大地受益于 lambda，并提高了可用性，因为现在用户不必在某些可访问范围内使用小型仿函数来弄乱他们的代码。

C++14

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

初始化的 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 现在可以是通用的（auto 将等同于 T 在这里如果 T 是周围范围内某处的类型模板参数）：

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

改进的返回类型扣除

C++14 允许为每个函数推导出返回类型，并且不将其限制为 return expression; 形式的函数。这也扩展到 lambdas。

【讨论】：

在上面的初始化 lambda 捕获示例中，为什么用 (); 结束lamba 函数？这看起来像 []()();代替 []（）;。 x 的值也不应该是 5 吗？ @RamakrishnanKannan: 1) () 在定义它之后立即调用 lambda 并给 y 其返回值。变量 y 是一个整数，而不是 lambda。 2) 不，x=5 是 lambda 的局部变量（按值捕获，恰好与外部范围变量 x 同名），然后返回 x+2 = 5+2。外部变量 x 的重新分配通过引用 r:r = &x; r += 2; 发生，但这发生在原始值 4 上。嘿，说any variable currently in scope，是什么意思？这意味着全局捕获所有全局变量以及该函数中的任何局部变量？【参考方案3】：

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 表达式还允许您创建命名nested functions，这是避免重复逻辑的便捷方式。将非平凡函数作为参数传递给另一个函数时，使用命名 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);

如果后续分析显示函数对象的初始化开销很大，您可能会选择将其重写为普通函数。

【讨论】：

您是否意识到这个问题是在 1.5 年前提出的，而上一次活动几乎是 1 年前？不管怎样，你贡献了一些我以前从未见过的有趣想法！感谢同时定义和执行提示！我认为值得注意的是，这可以作为if 语句的条件：if ([i] for (char j : i) if (!isspace(j)) return false ; return true ; ()) // i is all whitespace，假设i 是std::string 所以下面是合法的表达方式：[]()();. 呃！ Python 的(lambda: None)() 语法更加清晰。 @nobar - 你是对的，我打错了。这是合法的（我这次测试了）main() ((([]()())));【参考方案4】：