C++ lambda笔记

基本语法

简单来说，Lambda函数也就是一个函数，它的语法定义如下：

[capture] (params) mutable/exception ->return-type {body}   (1)     
[capture] ( params ) -> return-type { body }    (2)       
[ capture ] ( params ) { body }     (3)       
[ capture ] { body }    (4) 

(1) 是完整的 lambda 表达式形式，
(2) const 类型的 lambda 表达式，该类型的表达式不能改捕获(“capture”)列表中的值。
(3)省略了返回值类型的 lambda 表达式，但是该 lambda 表达式的返回类型可以按照下列规则推演出来：

如果 lambda 代码块中包含了 return 语句，则该 lambda 表达式的返回类型由 return 语句的返回类型确定。
如果没有 return 语句，则类似 void 函数。

(4)省略了参数列表，类似于无参函数 f()。

1.[capture]：捕捉列表。捕捉列表总是出现在Lambda函数的开始处。实际上，[]是Lambda引出符。编译器根据该引出符判断接下来的代码是否是Lambda函数。捕捉列表能够捕捉上下文中的变量以供Lambda函数使用;

2.(parameters)：参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号“()”一起省略;

3.mutable：mutable修饰符。默认情况下，Lambda函数总是一个const函数，mutable可以取消其常量性。在使用该修饰符时，参数列表不可省略（即使参数为空）;

4.->return-type：返回类型。用追踪返回类型形式声明函数的返回类型。我们可以在不需要返回值的时候也可以连同符号”->”一起省略。此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导;

5.{body}：函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量。

与普通函数最大的区别是，除了可以使用参数以外，Lambda函数还可以通过捕获列表访问一些上下文中的数据。具体地，捕捉列表描述了上下文中哪些数据可以被Lambda使用，以及使用方式（以值传递的方式或引用传递的方式）。语法上，在“[]”包括起来的是捕捉列表，捕捉列表由多个捕捉项组成，并以逗号分隔。捕捉列表有以下几种形式：

1.[var]表示值传递方式捕捉变量var；
2.[=]表示值传递方式捕捉所有父作用域的变量（包括this）；
3.[&var]表示引用传递捕捉变量var；
4.[&]表示引用传递方式捕捉所有父作用域的变量（包括this）；
5.[this]表示值传递方式捕捉当前的this指针。

上面提到了一个父作用域，也就是包含Lambda函数的语句块，说通俗点就是包含Lambda的“{}”代码块。上面的捕捉列表还可以进行组合.
例如：
1.[=,&a,&b]表示以引用传递的方式捕捉变量a和b，以值传递方式捕捉其它所有变量;
2.[&,a,this]表示以值传递的方式捕捉变量a和this，引用传递方式捕捉其它所有变量。
不过值得注意的是，捕捉列表不允许变量重复传递。下面一些例子就是典型的重复，会导致编译时期的错误。例如：
3.[=,a]这里已经以值传递方式捕捉了所有变量，但是重复捕捉a了，会报错的;
4.[&,&this]这里&已经以引用传递方式捕捉了所有变量，再捕捉this也是一种重复。
5.[] 不捕获外部的任何变量。

测试mutable

#include<iostream>
using namespace std;

int main()
{
  int val = 0;
 // auto const_val_lambda = [=](){ val = 3; };// wrong!!! 不可更该val的值

  auto mutable_val_lambda = [=]() mutable{ val = 3; };//由于mutable的原因，可以更该val的值,但是只是内部有效
      mutable_val_lambda();
      cout<<val<<endl; // 0

      auto const_ref_lambda = [&]() { val = 4; };
      const_ref_lambda();
      cout<<val<<endl; // 4

      auto mutable_ref_lambda = [&]() mutable{ val = 5; };
      mutable_ref_lambda();
      cout<<val<<endl; // 5

      return 0;
    }

测试源码

#ifndef TEST_LAMBDA_HPP
#define TEST_LAMBDA_HPP
#include<iostream>
#include <vector>
#include <algorithm>
#include <functional>
using namespace std;
typedef enum{
  add = 0,
  sub,
  mul,
  divi
}type;
void test_lambda(){
  int a = 10;
  int b = 20;

  auto func = [&,a](type i)->int {
    switch (i){
      case add:{
//          a=100; //error: assignment of read-only variable 'a'
          return a + b;
        }
      case sub:
        return a - b;
      case mul:
        return a * b;
      case divi:
        return a / b;
      }
  };
    cout<<func(add)<<endl;
  cout<<a<<endl;
  [&]() {
    cout<<"123"<<endl;
  }();
  [] {
    cout<<"456"<<endl;
  }();

  std::vector<int> c { 0,1,2,3,4,5,6,7,99 };
      int x = 5;
      c.erase(std::remove_if(c.begin(), c.end(), [x](int n) { return n < x; } ), c.end());

      std::cout << "c: ";
      for (auto i: c) {
          std::cout << i << ' ';
      }
      std::cout << '\n';

      // the type of a closure cannot be named, but can be inferred with auto
      auto func1 = [](int i) { return i+4; };
      std::cout << "func1: " << func1(6) << '\n';

      // like all callable objects, closures can be captured in std::function
      // (this may incur unnecessary overhead)
      std::function<int(int)> func2 = [](int i) { return i+4; };
      std::cout << "func2: " << func2(6) << '\n';
}
#endif // TEST_LAMBDA_HPP

结果

c++11 sorting list using lambda

#include <iostream>
#include <algorithm>
#include <list>

using namespace std;
int main()
{
list<pair <string, int>> s = {{"two", 2}, {"one", 1}, {"three", 3}};
sort(s.begin(), s.end(), [](pair<string,int> a, pair<string,int> b) -> bool
                            {
                            return (a.second) > (b.second);
                            }
);

for_each(s.begin(),s.end(),[](pair<string,int> a)
{
    cout << a.first << " " << a.second << endl;
});
}

http://en.cppreference.com/w/cpp/language/lambda