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

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

一些示例和用例将很有用。

答案

问题

C ++ 包括有用的通用函数,例如std::for_eachstd::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 引入了 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 的东西外,我们没有使用其他任何东西,但是我们也可以在 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]通过引用捕获
  • [&]通过引用捕获 lambda 中使用的所有变量
  • [=]按值捕获 lambda 中使用的所有变量
  • [&, epsilon]捕获与 [&] 类似的变量,但是 epsilon 按值
  • [=, &epsilon]像 [=] 一样捕获变量,但是 epsilon 通过引用

默认情况下,生成的operator()const ,这意味着在您默认访问捕获时,捕获将是const 。这样的效果是,每个具有相同输入的调用将产生相同的结果,但是您可以将 lambda 标记为mutable以请求所生成的operator()不是const

什么是 lambda 函数?

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

在 C ++ 中,lambda 函数的定义如下:

[]() { } // barebone lambda

或全部荣耀

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

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

捕获清单

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

  1. 值:[x]
  2. 参考 [&x]
  3. 当前在参考范围内的任何变量 [&]
  4. 与 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.

还有一个摘自 Wikipedia 的视频,展示了如何使用std::move进行捕获:

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

通用 Lambdas

Lambda 现在可以是泛型的(如果T是周围范围内某个地方的类型模板参数,则auto在这里等效于T ):

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

改进的退货类型推导

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

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

如果后续分析显示出该函数对象的大量初始化开销,则可以选择将其重写为普通函数。

答案

问:C ++ 11 中的 lambda 表达式是什么?

答:在后台,它是带有重载operator()const的自动生成类的对象。这种对象称为闭包 ,由编译器创建。这个 “关闭” 概念与 C ++ 11 的 bind 概念差不多。但是 lambda 通常会生成更好的代码。通过闭包的调用允许完整的内联。

问:我什么时候会用一次?

答:要定义 “简单逻辑”,并要求编译器根据上一个问题进行生成。您为编译器提供了一些要包含在 operator()中的表达式。所有其他的东西编译器都会为您生成。

问:在介绍之前,他们无法解决哪种问题?

答:这是一种语法糖,例如运算符重载,而不是自定义添加,子操作的函数…… 但是它节省了更多的不需要的代码行,可以将 1-3 行的实际逻辑包装到某些类中,等等!一些工程师认为,如果行数较少,那么出错的机会就更少了(我也这么认为)

使用例

auto x = [=](int arg1){printf("%i", arg1); };
void(*f)(int) = x;
f(1);
x(1);

有关 lambda 的其他内容,不在问题范围之内。如果您不感兴趣,请忽略此部分

1. 捕获的值。您可以捕获什么

1.1。您可以使用 lambdas 引用具有静态存储持续时间的变量。他们全部被捕获。

1.2。您可以使用 lambda 来 “按值” 捕获值。在这种情况下,捕获的变量将被复制到函数对象(关闭)。

[captureVar1,captureVar2](int arg1){}

1.3。您可以参考。 &- 在本文中是指引用,而不是指针。

[&captureVar1,&captureVar2](int arg1){}

1.4。它具有表示法,可以按值或按引用捕获所有非静态变量

[=](int arg1){} // capture all not-static vars by value

  [&](int arg1){} // capture all not-static vars by reference

1.5。它存在一种表示法,可以按值或按引用捕获所有非静态 var 并指定 smth。更多。示例:通过值捕获所有非静态变量,但通过引用捕获 Param2

[=,&Param2](int arg1){}

通过引用捕获所有非静态变量,但通过值捕获 Param2

[&,Param2](int arg1){}

2. 返回类型扣除

2.1。如果 lambda 是一个表达式,则可以推断出 lambda 返回类型。或者您可以显式指定它。

[=](int arg1)->trailing_return_type{return trailing_return_type();}

如果 lambda 具有多个表达式,则必须通过尾随返回类型指定返回类型。同样,类似的语法可以应用于自动功能和成员功能

3. 捕获的值。您无法捕获的内容

3.1。您只能捕获本地 var,而不能捕获对象的成员变量。

4. 转换

4.1 !! Lambda 不是函数指针,也不是匿名函数,但是可以将无捕获的 Lambda 隐式转换为函数指针。

ps

  1. 有关 lambda 语法信息的更多信息,请参见《 C ++ 编程语言》工作草案#337、2012-01-16、5.1.2。 Lambda 表达式,第 88 页

  2. 在 C ++ 14 中,添加了名为 “初始捕获” 的额外功能。它允许任意执行闭包数据成员的声明:

    auto toFloat = [](int value) { return float(value);};
    auto interpolate = [min = toFloat(0), max = toFloat(255)](int value)->float { return (value - min) / (max - min);};

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

C ++ 的作者Bjarne Stroustrup在其著作***The C++ Programming Language***第 11 章( ISBN-13:978-0321563842 )中给出了关于lambda expression的最佳解释之一:

What is a lambda expression?

Lambda 表达式有时也称为lambda函数,或者(严格来说讲不正确,但口语上称为lambda )是用于定义和使用匿名函数对象的简化表示法。我们可以使用简写形式,而不是使用 operator()定义命名的类,之后再创建该类的对象,最后调用它。

When would I use one?

当我们想将运算作为参数传递给算法时,这特别有用。在图形用户界面(和其他位置)的上下文中,此类操作通常称为回调

What class of problem do they solve that wasn't possible prior to their introduction?

在这里,我猜想用 lambda 表达式完成的每个动作都可以在没有它们的情况下解决,但是需要更多的代码和更大的复杂性。 Lambda 表达式是优化代码的一种方法,也是使其更具吸引力的一种方法。由 Stroustup 感到悲伤:

优化的有效方法

Some examples

通过 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 expression如下所示:

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

会产生下一个

0

1 个

0

1 个

0

1 个

0

1 个

0

1 个

0 已排序 x-1; x-3; x-4; x-5; x-6; x-7; x-33;

[] - 这是捕获列表或lambda introducer :如果lambdas不需要访问其本地环境,则可以使用它。

书中引用:

Lambda 表达式的第一个字符始终为[ 。 Lambda 引入程序可以采用多种形式:

[] :一个空的捕获列表。这意味着在 lambda 主体中不能使用来自周围上下文的本地名称。对于此类 lambda 表达式,数据是从参数或非局部变量获取的。

[&] :通过引用隐式捕获。可以使用所有本地名称。通过引用访问所有局部变量。

[=] :按值隐式捕获。可以使用所有本地名称。所有名称均引用在 lambda 表达式调用时获取的局部变量的副本。

[捕获列表]:显式捕获; capture-list 是通过引用或值要捕获(即,存储在对象中)的局部变量名称的列表。名称以&开头的变量被引用捕获。其他变量按值捕获。捕获列表也可以包含此名称和名称,后跟... 作为元素。

[&,capture-list] :通过引用隐式捕获名称未在列表中提及的所有局部变量。捕获列表可以包含此列表。列出的名称不能以&开头。捕获列表中命名的变量按值捕获。

[=,捕获列表] :按值隐式捕获列表中未提及名称的所有局部变量。捕获列表不能包含此内容。列出的名称必须以&开头。捕获列表中命名的变量通过引用捕获。

请注意,以&开头的本地名称始终由引用捕获,而不以&开头的本地名称始终由值捕获。只有通过引用捕获才能在调用环境中修改变量。

Additional

Lambda expression格式

在此处输入图片说明

其他参考:

好吧,我发现的一种实际用途是减少样板代码。例如:

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情况做一些事情。当然,您可以创建一个函数,但是如果您想在灵魂用户函数的范围内限制使用该怎么办? 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;

}

编译如何扩展它:

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

如您所见,使用时会增加什么样的开销。因此在任何地方使用它们并不是一个好主意。它可以在适用的地方使用。

它解决的一个问题是: 在构造函数中使用输出参数函数初始化 const 成员的调用的代码比 lambda 更简单

您可以通过调用返回其输出作为输出参数来设置其值的函数来初始化类的 const 成员。