提问



什么是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引入了lambdas,允许你编写一个内联的匿名函子来代替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; }
                 );
}


但是当你开始编写更复杂的lambdas时,很快就会遇到编译器无法推断出返回类型的情况,例如:


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中使用其他变量。如果你想访问其他变量,你可以使用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 by reference



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



其它参考1


什么是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中,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;};


Generic Lambdas



Lambdas现在可以是通用的(auto在这里等于T
T是周围范围内某处的类型模板参数:


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


改进的退货类型扣除



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

其它参考2


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表达式还允许您创建命名的嵌套函数,这可以是避免重复逻辑的便捷方法。当将非平凡函数作为参数传递给另一个函数时,使用命名的lambdas在眼睛上(与匿名内联lambda相比)往往更容易一些。 注意:在结束大括号后不要忘记分号。 [84]


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

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


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

其它参考3


答案


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


答:在引擎盖下,它是一个自动生成的类的对象,具有重载 operator()const 。这样的对象称为 closure ,由编译器创建。
这个闭包概念与C ++ 11中的绑定概念相近。
但是lambdas通常会生成更好的代码。通过闭包调用允许完全内联。


问:我什么时候使用?


答:定义简单和小逻辑并要求编译器执行上一个问题的生成。你给编译器一些你想要在operator()中的表达式。所有其他东西编译器都会生成给你。


问:在他们推出之前,他们解决了哪些类型的问题?


答:这是某种语法糖,比如运算符重载而不是自定义 add,subrtact 操作的函数......但是它保存了更多不需要的代码行来将1-3行真实逻辑包装成一些课等等!一些工程师认为,如果线的数量较少,那么在其中产生错误的机会就会减少(我也是这么认为)


使用示例


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





关于lambdas的额外内容,未被提及。如果您不感兴趣,请忽略此部分


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。它存在通过值或通过引用捕获所有非静态变量并指定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。您只能捕获本地变量,而不能捕获对象的成员变量。


4。 Сonversions


4.1。 lambda不是函数指针,它不是匿名函数,但可以隐式转换为函数指针。


P.S。



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

  2. 在C ++ 14中添加了名为init capture的额外功能。它允许对闭包数据成员进行任意声明:


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


其它参考4


lambda函数是您在线创建的匿名函数。它可以像某些人所解释的那样捕获变量(例如http://www.stroustrup.com/C++11FAQ.html#lambda)但有一些限制。例如,如果有这样的回调接口,[85]


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

其它参考5


lambda expression的最佳解释之一来自C ++ Bjarne Stroustrup 的作者在他的书***The C++ Programming Language***第11章(ISBN-13:978-0321563842)中的作者:]]


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 sortedx - 1; x - 3; x - 4; x - 5; x - 6; x - 7; x - 33;



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


从书中引用:



  lambda表达式的第一个字符始终是 [[。一个lambda
  介绍人可以采取各种形式:

  
  • [[]] :空捕获列表。这个
  意味着不能使用周围环境中的本地名称
  在lambda体内。对于这样的lambda表达式,从中获取数据
  参数或非局部变量。

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

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

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

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

  
  • [[=,capture-list]] :通过值隐式捕获列表中未提及名称的所有局部变量。捕获列表不能包含此内容。列出的名称前面必须是& ;.捕获列表中命名的变量通过引用捕获。

  
  请注意,本地名称前面带有&总是被捕获
  参考文献和当地名称未被&总是被捕获
  值。仅通过引用捕获允许修改变量
  呼叫环境。



Additional


Lambda expression格式


[87]


其他参考:



  • 维基

  • open-std.org,第5.1.2章


其它参考6


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


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

其它参考7


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


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的性质满足了这个要求,我在那个案例中使用它。