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


什么是C ++ 11中的lambda表达式?我什么时候使用?他们解决了哪些问题在引入之前是不可能的?

一些示例和用例将是有用的。


1198
2017-10-02 14:58


起源


我已经看到了一个lambda非常有用的案例:我的一位同事正在编写具有数百万次迭代的代码来解决空间优化问题。使用lambda时算法要快得多,而不是正确的函数!编译器是Visual C ++ 2013。 - sergiol


答案:


问题

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,允许你编写一个内联,匿名函子来替换 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;
            }
        });
}

要解决此问题,您可以使用显式指定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;
            }
        });
}

“捕获”变量

到目前为止,我们还没有使用除了传递给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


1210
2017-10-02 15:21



@Yakk你被困了。没有捕获的lambdas有一个隐式转换为函数类型指针。转换功能是 const 总是... - Johannes Schaub - litb
@ JohannesSchaub-litb哦偷偷摸摸 - 当你调用它时会发生这种情况 ()  - 它作为零参数lambda传递,但因为 () const 与lambda不匹配,它查找允许它的类型转换,包括隐式转换为函数指针,然后调用它!偷偷摸摸的! - Yakk - Adam Nevraumont
有意思 - 我原本以为lambdas是匿名的 功能 而不是仿函数,并对捕获如何工作感到困惑。 - immibis
如果要在程序中使用lambdas作为变量,可以使用: std::function<double(int, bool)> f = [](int a, bool b) -> double { ... };  但通常,我们让编译器推断出类型: auto f = [](int a, bool b) -> double { ... };  (别忘了 #include <functional>) - evertheylen
我想不是每个人都明白为什么 return d < 0.00001 ? 0 : d; 保证返回double,当其中一个操作数是一个整数常量时(这是因为?:运算符的隐式提升规则,其中第二和第三操作数通过通常的算术转换相互平衡,无论哪一个被选中)。改为 0.0 : d 也许会让这个例子更容易理解。 - Lundin


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

通用Lambda

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

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

改进的返回类型扣除

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


719
2017-10-02 15:43



在上面初始化lambda捕获的示例中,为什么要使用();?结束lamba函数?这看起来像[](){}();代替 [](){};。也不应该x的值是5? - Ramakrishnan Kannan
@RamakrishnanKannan:1)()在定义它之后立即调用lambda并给它y返回值。变量y是整数,而不是lambda。 2)否,x = 5是lambda的局部值(按值进行捕获,恰好与外部作用域变量x具有相同的名称),然后返回x + 2 = 5 + 2。外部变量x的重新分配通过引用r发生: r = &x; r += 2;,但这发生在4的原始值。 - The Vee


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相比)往往更容易一些。 注意:关闭大括号后不要忘记分号。

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

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

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


152
2018-03-01 08:08



您是否意识到这个问题是在1。5年前被问到的,而且最近的活动是差不多1年前的?无论如何,你提供了一些我以前从未见过的有趣想法! - Piotr99
感谢您同时定义并执行提示!我认为值得注意的是,这可以作为一个条件 if 声明: if ([i]{ for (char j : i) if (!isspace(j)) return false ; return true ; }()) // i is all whitespace, 假设 i 是一个 std::string - Blacklight Shining
所以以下是一个法律表达: [](){}();。 - nobar
啊! Python的 (lambda: None)() 语法更清晰。 - dan04
@nobar - 你是对的,我输错了。这是合法的(我这次测试了) main() {{{{((([](){{}}())));}}}} - Mark Lakata


答案

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

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

问:我什么时候使用?

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

问:他们解决了哪些问题在引入之前是不可能的?

答:这是某种语法糖,比如运算符重载而不是自定义函数 添加,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不是函数指针,它不是匿名函数,但可以隐式转换为函数指针。

附: 

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

30
2018-06-03 16:40



我没有掩饰smth吗?为什么我重新减去? - bruziuz
在有人给我一个减号之后,我在C ++ 11中追加了关于捕获,返回类型推导的信息。它没有被提及,但我添加它来回答!也许这是我没有这个“额外部分......”的帖子的减号的原因。 - bruziuz
这个 [&,=Param2](int arg1){} 似乎不是有效的语法。正确的形式是 [&,Param2](int arg1){} - GetFree
谢谢。首先,我尝试编译此代码段。在捕获列表中允许的修改器中似乎奇怪的不对称// g ++ -std = c ++ 11 main.cpp -o test_bin; ./test_bin #include <stdio.h> int main(){#if 1 {int param = 0; auto f = [=,&param](int arg1)mutable {param = arg1;}; F(111); printf(“%i \ n”,param); } #endif #if 0 {int param = 0; auto f = [&,= param](int arg1)mutable {param = arg1;}; F(111); printf(“%i \ n”,param); } #endif返回0; } - bruziuz
看起来评论中不支持新行。然后我打开了5.1.2 Lambda表达式,第88页,“工作草案,编程语言C ++标准”,Dcoument编号:#337,2012-01-16。并研究语法语法。而你是对的。没有像“arg”这样捕获的东西 - bruziuz


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

12
2018-03-10 22:36



原因是,如果没有捕获,lambda只能转换为函数指针。如果 apply 是一个接受仿函数的模板,它会起作用 - sp2danny
但问题是如果apply是一个现有的接口,你可能没有能力以普通的旧函数来声明它。该标准可以设计为允许每次执行这样的lambda表达式时生成普通旧函数的新实例,并生成对捕获变量的硬编码引用。看起来lambda函数是在编译时生成的。还有其他后果。例如,如果声明一个静态变量,即使重新计算lambda表达式,也不会获得新的静态变量。 - Ted
函数指针通常意味着保存,lambdas捕获可能超出范围。只有捕获的lambdas转换为函数指针才是设计的 - sp2danny
你仍然需要注意由于同样的原因而被解除分配的堆栈变量。看到 blogs.msdn.com/b/nativeconcurrency/archive/2012/01/29/...  我用输出和应用编写的例子是这样写的,如果允许和使用函数指针,它们也可以工作。 col仍然分配,直到来自apply的所有函数调用完成。如何使用现有的apply接口重写此代码?您最终会使用全局变量还是静态变量,或者更加模糊的代码转换? - Ted
或者你只是意味着lambda表达式是rvalues,因此是临时的,但代码保持不变(单例/静态),以便将来可以调用它。在这种情况下,只要其堆栈分配的捕获保持分配,函数就可以保持分配状态。当然,如果例如在循环中分配函数的许多变体,它可能会弄乱它。 - Ted


其中一个最好的解释 lambda expression 是从C ++的作者 Bjarne Stroustrup 在他的书中 ***The C++ Programming Language*** 第11章(ISBN-13:978-0321563842):

What is a lambda expression? 

一个 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表达式的调用时采取。

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

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

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

请注意,以&开头的本地名称始终被捕获   引用和未被&表示的本地名称始终被捕获   值。仅通过引用捕获允许修改变量   呼叫环境。

Additional

Lambda expression 格式

enter image description here

其他参考:


6
2017-11-09 11:02





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

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


1
2018-06-27 00:38



这也可以通过简单的函数来完成,这甚至是您所链接的问题的接受答案。 - SirGuy


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

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


1
2017-11-23 09:16