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

Question

提问by Nawaz

What is a lambda expression in C++11? When would I use one? What class of problem do they solve that wasn't possible prior to their introduction?

什么是 C++11 中的 lambda 表达式？我什么时候用一个？他们解决了哪些在引入之前无法解决的问题？

A few examples, and use cases would be useful.

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

Answer 1

回答by Flexo

The problem

问题

C++ includes useful generic functions like std::for_eachand std::transform, which can be very handy. Unfortunately they can also be quite cumbersome to use, particularly if the functoryou would like to apply is unique to the particular function.

C++ 包括有用的通用函数，如std::for_eachand 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);
}

If you only use fonce and in that specific place it seems overkill to be writing a whole class just to do something trivial and one off.

如果你只f在那个特定的地方使用一次，那么编写一整个类只是为了做一些微不足道的事情似乎有点过分。

In C++03 you might be tempted to write something like the following, to keep the functor local:

在 C++03 中，您可能会想写如下内容，以保持函子本地化：

void func2(std::vector<int>& v) {
  struct {
    void operator()(int) {
       // do something
    }
  } f;
  std::for_each(v.begin(), v.end(), f);
}

however this is not allowed, fcannot be passed to a templatefunction in C++03.

但是这是不允许的，f不能传递给C++03 中的模板函数。

The new solution

新的解决方案

C++11 introduces lambdas allow you to write an inline, anonymous functor to replace the struct f. For small simple examples this can be cleaner to read (it keeps everything in one place) and potentially simpler to maintain, for example in the simplest form:

C++11 引入了 lambdas 允许你编写一个内联的匿名函子来替换struct f. 对于小的简单示例，这可以更清晰地阅读（它将所有内容放在一个地方）并且可能更易于维护，例如以最简单的形式：

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

Lambda functions are just syntactic sugar for anonymous functors.

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

Return types

返回类型

In simple cases the return type of the lambda is deduced for you, e.g.:

在简单的情况下，为您推导出 lambda 的返回类型，例如：

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

however when you start to write more complex lambdas you will quickly encounter cases where the return type cannot be deduced by the compiler, e.g.:

但是，当您开始编写更复杂的 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;
            }
        });
}

To resolve this you are allowed to explicitly specify a return type for a lambda function, using -> T:

要解决此问题，您可以使用以下命令显式指定 lambda 函数的返回类型-> T：

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

"Capturing" variables

“捕获”变量

So far we've not used anything other than what was passed to the lambda within it, but we can also use other variables, within the lambda. If you want to access other variables you can use the capture clause (the []of the expression), which has so far been unused in these examples, e.g.:

到目前为止，除了传递给其中的 lambda 之外，我们还没有使用任何其他东西，但我们也可以在 lambda 中使用其他变量。如果您想访问其他变量，您可以使用 capture 子句（[]表达式的 the），到目前为止这些示例中尚未使用该子句，例如：

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

You can capture by both reference and value, which you can specify using &and =respectively:

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

[&epsilon]capture by reference
[&]captures all variables used in the lambda by reference
[=]captures all variables used in the lambda by value
[&, epsilon]captures variables like with [&], but epsilon by value
[=, &epsilon]captures variables like with [=], but epsilon by reference

[&epsilon]按引用捕获
[&]通过引用捕获 lambda 中使用的所有变量
[=]按值捕获 lambda 中使用的所有变量
[&, epsilon]使用 [&] 捕获变量，但按值捕获 epsilon
[=, &epsilon]像 [=] 一样捕获变量，但通过引用来捕获 epsilon

The generated operator()is constby default, with the implication that captures will be constwhen you access them by default. This has the effect that each call with the same input would produce the same result, however you can mark the lambda as mutableto request that the operator()that is produced is not const.

生成的operator()是const默认的，这意味着const默认情况下您访问它们时会进行捕获。这会导致具有相同输入的每次调用都会产生相同的结果，但是您可以将 lambda 标记为mutable请求operator()生成的不是const。

Answer 2

回答by pmr

What is a lambda function?

什么是 lambda 函数？

The C++ concept of a lambda function originates in the lambda calculus and functional programming. A lambda is an unnamed function that is useful (in actual programming, not theory) for short snippets of code that are impossible to reuse and are not worth naming.

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

In C++ a lambda function is defined like this

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

[]() { } // barebone lambda

or in all its glory

或在它所有的荣耀中

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

[]is the capture list, ()the argument list and {}the function body.

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

The capture list

捕获列表

The capture list defines what from the outside of the lambda should be available inside the function body and how. It can be either:

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

a value: [x]
a reference [&x]
any variable currently in scope by reference [&]
same as 3, but by value [=]

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

You can mix any of the above in a comma separated list [x, &y].

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

The argument list

参数列表

The argument list is the same as in any other C++ function.

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

The function body

函数体

The code that will be executed when the lambda is actually called.

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

Return type deduction

退货类型扣除

If a lambda has only one return statement, the return type can be omitted and has the implicit type of decltype(return_statement).

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

Mutable

可变的

If a lambda is marked mutable (e.g. []() mutable { }) it is allowed to mutate the values that have been captured by value.

如果 lambda 被标记为可变的（例如[]() mutable { }），则允许改变已被值捕获的值。

Use cases

用例

The library defined by the ISO standard benefits heavily from lambdas and raises the usability several bars as now users don't have to clutter their code with small functors in some accessible scope.

ISO 标准定义的库从 lambda 中受益匪浅，并提高了几个方面的可用性，因为现在用户不必在某些可访问的范围内用小函子来混乱他们的代码。

C++14

In C++14 lambdas have been extended by various proposals.

在 C++14 中，各种提议都扩展了 lambda。

Initialized Lambda Captures

初始化的 Lambda 捕获

An element of the capture list can now be initialized with =. This allows renaming of variables and to capture by moving. An example taken from the standard:

捕获列表的元素现在可以使用=. 这允许重命名变量并通过移动进行捕获。取自标准的一个例子：

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.

and one taken from Wikipedia showing how to capture with std::move:

和来自维基百科的一个显示如何捕获std::move：

auto ptr = std::make_unique<int>(10); // See below for std::make_unique
auto lambda = [ptr = std::move(ptr)] {return *ptr;};

Generic Lambdas

通用 Lambda

Lambdas can now be generic (autowould be equivalent to There if Twere a type template argument somewhere in the surrounding scope):

Lambda 现在可以是泛型的（如果是周围范围内某处的类型模板参数，则auto相当于T此处 T）：

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

Improved Return Type Deduction

改进的返回类型推导

C++14 allows deduced return types for every function and does not restrict it to functions of the form return expression;. This is also extended to lambdas.

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

Answer 3

回答by nobar

Lambda expressions are typically used to encapsulate algorithms so that they can be passed to another function. However, it is possible to execute a lambda immediately upon definition:

Lambda 表达式通常用于封装算法，以便将它们传递给另一个函数。但是，可以在定义后立即执行 lambda：

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

is functionally equivalent to

在功能上等同于

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

This makes lambda expressions a powerful tool for refactoring complex functions. You start by wrapping a code section in a lambda function as shown above. The process of explicit parameterization can then be performed gradually with intermediate testing after each step. Once you have the code-block fully parameterized (as demonstrated by the removal of the &), you can move the code to an external location and make it a normal function.

这使得 lambda 表达式成为重构复杂函数的强大工具。您首先将代码部分包装在 lambda 函数中，如上所示。然后可以在每个步骤之后通过中间测试逐渐执行显式参数化过程。一旦您将代码块完全参数化（如删除所示&），您就可以将代码移动到外部位置并使其成为正常函数。

Similarly, you can use lambda expressions to initialize variables based on the result of an algorithm...

同样，您可以使用 lambda 表达式根据算法的结果初始化变量...

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

As a way of partitioning your program logic, you might even find it useful to pass a lambda expression as an argument to another lambda expression...

作为划分程序逻辑的一种方式，您甚至可能会发现将 lambda 表达式作为参数传递给另一个 lambda 表达式很有用...

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

Lambda expressions also let you create named nested functions, which can be a convenient way of avoiding duplicate logic. Using named lambdas also tends to be a little easier on the eyes (compared to anonymous inline lambdas) when passing a non-trivial function as a parameter to another function. Note: don't forget the semicolon after the closing curly brace.

Lambda 表达式还允许您创建命名嵌套函数，这是一种避免重复逻辑的便捷方式。在将非平凡函数作为参数传递给另一个函数时，使用命名 lambda 也往往更容易一些（与匿名内联 lambda 相比）。 注意：不要忘记右花括号后面的分号。

auto algorithm = [&]( double x, double m, double b ) -> double
   {
   return m*x+b;
   };

int a=algorithm(1,2,3), b=algorithm(4,5,6);

If subsequent profiling reveals significant initialization overhead for the function object, you might choose to rewrite this as a normal function.

如果随后的分析揭示了函数对象的大量初始化开销，您可以选择将其重写为普通函数。

Answer 4