嗯，我发现的一个实际用途是减少锅炉板代码。例如：

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的性质满足这一要求，我将其用于这种情况。

C++作者Bjarne Stroustrup在其著作《C++编程语言》第11章（ISBN-13:978-0321563842）中给出了lambda表达式的最佳解释之一：

什么是lambda表达式？

lambda表达式，有时也称为lambda函数或（严格地说不正确，但口语上）作为lambda是定义和使用匿名函数对象的简化符号。而不是用运算符（）定义一个命名类，然后创建该类的对象，最后调用它，我们可以使用速记。

我什么时候用？

当我们希望将操作作为算法的参数。在图形用户界面的上下文中（和其他地方），此类操作通常被称为回调。

他们解决了哪类在介绍之前不可能解决的问题？

在这里，我想用lambda表达式完成的每个操作都可以在没有它们的情况下解决，但需要更多的代码和更大的复杂性。Lambda表达式这是对代码进行优化的方法，也是使其更具吸引力的方法。正如Stroustup所言：

优化的有效途径

一些示例

通过lambda表达式

void print_modulo(const vector<int>& v, ostream& os, int m) // output v[i] to os if v[i]%m==0
{
    for_each(begin(v),end(v),
        [&os,m](int x) { 
           if (x%m==0) os << x << '\n';
         });
}

或通过功能

class Modulo_print {
         ostream& os; // members to hold the capture list int m;
     public:
         Modulo_print(ostream& s, int mm) :os(s), m(mm) {} 
         void operator()(int x) const
           { 
             if (x%m==0) os << x << '\n'; 
           }
};

甚至

void print_modulo(const vector<int>& v, ostream& os, int m) 
     // output v[i] to os if v[i]%m==0
{
    class Modulo_print {
        ostream& os; // members to hold the capture list
        int m; 
        public:
           Modulo_print (ostream& s, int mm) :os(s), m(mm) {}
           void operator()(int x) const
           { 
               if (x%m==0) os << x << '\n';
           }
     };
     for_each(begin(v),end(v),Modulo_print{os,m}); 
}

如果需要，可以将lambda表达式命名如下：

void print_modulo(const vector<int>& v, ostream& os, int m)
    // output v[i] to os if v[i]%m==0
{
      auto Modulo_print = [&os,m] (int x) { if (x%m==0) os << x << '\n'; };
      for_each(begin(v),end(v),Modulo_print);
 }

或者假设另一个简单的样本

void TestFunctions::simpleLambda() {
    bool sensitive = true;
    std::vector<int> v = std::vector<int>({1,33,3,4,5,6,7});

    sort(v.begin(),v.end(),
         [sensitive](int x, int y) {
             printf("\n%i\n",  x < y);
             return sensitive ? x < y : abs(x) < abs(y);
         });


    printf("sorted");
    for_each(v.begin(), v.end(),
             [](int x) {
                 printf("x - %i;", x);
             }
             );
}

将生成下一个

01.01.01.01.01.0排序x-1；x-3；x-4；x-5；x-6；x-7；x-33；

[]-这是捕获列表或lambda导入器：如果lambda不需要访问其本地环境，我们可以使用它。

书中引用：

lambda表达式的第一个字符始终是[.a lambda介绍人可以采取各种形式：•[]：空捕获列表。这暗示不能使用周围上下文中的本地名称在lambda车身中。对于此类lambda表达式，数据从参数或来自非局部变量。•[&]：隐式捕获参考可以使用所有本地名称。所有局部变量均为通过引用访问。•[=]：按值隐式捕获。所有本地可以使用名称。所有名称都引用本地变量的副本在lambda表达式的调用点获取。•[捕获列表]：显式捕获；捕获列表是要通过引用或值捕获（即存储在对象中）的本地变量的名称列表。名称前面带有&的变量由捕获参考其他变量由值捕获。捕获列表可以还包含this和后跟…的名称。。。作为元素。•[&，capture-list]：通过引用隐式捕获列表中未列出名称的所有局部变量。捕获列表可以包含此内容。列出的名称不能以&开头。中命名的变量捕获列表按值捕获。•[=，捕获列表]：通过值隐式捕获列表中未提及名称的所有局部变量。捕获列表不能包含此内容。列出的名称必须以&开头。捕获列表中命名的变量是通过引用捕获的。请注意，以&开头的本地名称总是由引用和本地名称不是由预先放弃的&总是由捕获价值仅通过引用捕获允许修改呼叫环境。

附加的

Lambda表达式格式

其他参考：

维基open-std.org，第5.1.2章

问题是

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。

嗯，我发现的一个实际用途是减少锅炉板代码。例如：

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的性质满足这一要求，我将其用于这种情况。

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

正如您所看到的，当您使用它时，它会增加什么样的开销。所以在任何地方使用它们都不是好主意。它可以在适用的地方使用。