声明：本文参考了Alex Allain的文章​​http://www.cprogramming.com/c++11/c++11-lambda-closures.html​​

加入了自己的理解，不是简单的翻译

C++11终于知道要在语言中加入匿名函数了。匿名函数在很多时候可以为编码提供便利，这在下文会提到。很多语言中的匿名函数，如C++，都是用Lambda表达式实现的。Lambda表达式又称为lambda函数。我在下文中称之为Lambda函数。

为了明白Lambda函数的用处，请务必先搞明白C++中的自动类型推断

基本的Lambda函数



我们可以这样定义一个Lambda函数： 




 
    
 
  
1. #include <iostream>  
2.   
3. using namespace std;  
4.   
5. int main()  
6. {  
7. "Hello world"; };  
8. // now call the function  
9. }


其中func就是一个lambda函数。我们使用auto来自动获取func的类型，这个非常重要。定义好lambda函数之后，就可以当这场函数来使用了。


其中 [ ] 表示接下来开始定义lambda函数，中括号中间有可能还会填参数，这在后面介绍。之后的()填写的是lambda函数的参数列表{}中间就是函数体了。


[cpp]  ​​view plain​​ ​​copy​​



  1. [] () -> int { return 1; }  



所以总的来说lambda函数的形式就是： 




1. [captures] (params) -> ret {Statments;}




Lambda函数的用处



假设你设计了一个地址簿的类。现在你要提供函数查询这个地址簿，可能根据姓名查询，可能根据地址查询，还有可能两者结合。要是你为这些情况都写个函数，那么你一定就跪了。所以你应该提供一个接口，能方便地让用户自定义自己的查询方式。在这里可以使用lambda函数来实现这个功能。 



1. #include <string>  
2. #include <vector>  
3.   
4. class AddressBook  
5. {  
6. public:  
7. // using a template allows us to ignore the differences between functors, function pointers   
8. // and lambda  
9. template<typename Func>  
10.     std::vector<std::string> findMatchingAddresses (Func func)  
11.     {   
12.         std::vector<std::string> results;  
13. for ( auto itr = _addresses.begin(), end = _addresses.end(); itr != end; ++itr )  
14.         {  
15. // call the function passed into findMatchingAddresses and see if it matches  
16. if ( func( *itr ) )  
17.             {  
18.                 results.push_back( *itr );  
19.             }  
20.         }  
21. return results;  
22.     }  
23.   
24. private:  
25.     std::vector<std::string> _addresses;  
26. };


从上面代码可以看到，findMatchingAddressses函数提供的参数是Func类型，这是一个泛型类型。在使用过程中应该传入一个函数，然后分别对地址簿中每一个entry执行这个函数，如果返回值为真那么表明这个entry符合使用者的筛选要求，那么就应该放入结果当中。那么这个Func类型的参数如何传入呢？



1. AddressBook global_address_book;  
2.   
3. vector<string> findAddressesFromOrgs ()  
4. {  
5. return global_address_book.findMatchingAddresses(   
6. // we're declaring a lambda here; the [] signals the start  
7. const string& addr) { return addr.find( ".org" ) != string::npos; }   
8.     );  
9. }


可以看到，我们在调用函数的时候直接定义了一个lambda函数。参数类型是 



1. const string& addr


返回值是bool类型。


如果用户要使用不同的方式查询的话，只要定义不同的lambda函数就可以了。



Lambda函数中的变量截取




在上述例子中，lambda函数使用的都是函数体的参数和它内部的信息，并没有使用外部信息。我们设想这样的一个场景，我们从键盘读入一个名字，然后用lambda函数定义一个匿名函数，在地址簿中查找有没有相同名字的人。那么这个lambda函数势必就要能使用外部block中的变量，所以我们就得使用变量截取功能（Variable Capture)。 



1. // read in the name from a user, which we want to search  
2. string name;  
3. cin>> name;  
4. return global_address_book.findMatchingAddresses(   
5. // notice that the lambda function uses the the variable 'name'  
6. const string& addr) { return name.find( addr ) != string::npos; }   
7. );


下面是各种变量截取的选项：


  • [] 不截取任何变量
  • [&} 截取外部作用域中所有变量，并作为引用在函数体中使用
  • [=] 截取外部作用域中所有变量，并拷贝一份在函数体中使用
  • [=, &foo]   截取外部作用域中所有变量，并拷贝一份在函数体中使用，但是对foo变量使用引用
  • [bar]
  • [this]            截取当前类中的this指针。如果已经使用了&或者=就默认添加此选项。

Lambda函数和STL






lambda函数的引入为STL的使用提供了极大的方便。比如下面这个例子，当你想便利一个vector的时候，原来你得这么写：



1. vector<int> v;  
2. v.push_back( 1 );  
3. v.push_back( 2 );  
4. //...  
5. for ( auto itr = v.begin(), end = v.end(); itr != end; itr++ )  
6. {  
7.     cout << *itr;  
8. }  
 
 
 
 
     
    
 
    
 
  
1. vector<int> v;  
2. v.push_back( 1 );  
3. v.push_back( 2 );  
4. //...  
5. for_each( v.begin(), v.end(), [] (int val)  
6. {  
7.     cout << val;  
8. } );

而且这么写了之后执行效率反而提高了。因为编译器有可能使用”循环展开“来加速执行过程（计算机系统结构课程中学的）。


​​http://www.nwcpp.org/images/stories/lambda.pdf​​ 这个PPT详细介绍了如何使用lambda表达式和STL


给大家写一个例子:

C++11 的 lambda 表达式规范如下：

​​[​​​ capture ​​]​​​ ​​(​​​ params ​​)​​​ mutable exception attribute ​​->​​​ ret ​​{​​​ body ​​}​​

(1)

 

​​[​​​ capture ​​]​​​ ​​(​​​ params ​​)​​​ ​​->​​​ ret ​​{​​​ body ​​}​​

(2)

 

​​[​​​ capture ​​]​​​ ​​(​​​ params ​​)​​​ ​​{​​​ body ​​}​​

(3)

 

​​[​​​ capture ​​]​​​ ​​{​​​ body ​​}​​

(4)

 

其中

  • (1) 是完整的 lambda 表达式形式，
  • (2) const 类型的 lambda 表达式，该类型的表达式不能改捕获("capture")列表中的值。
  • (3)省略了返回值类型的 lambda 表达式，但是该 lambda 表达式的返回类型可以按照下列规则推演出来：
  • 如果 lambda 代码块中包含了 return 语句，则该 lambda 表达式的返回类型由 return 语句的返回类型确定。
  • 如果没有 return 语句，则类似 void f(...) 函数。
  • 省略了参数列表，类似于无参函数 f()。

mutable 修饰符说明 lambda 表达式体内的代码可以修改被捕获的变量，并且可以访问被捕获对象的 non-const 方法。

exception 说明 lambda 表达式是否抛出异常(​​noexcept​​)，以及抛出何种异常，类似于void f() throw(X, Y)。

attribute 用来声明属性。

另外，capture 指定了在可见域范围内 lambda 表达式的代码内可见得外部变量的列表，具体解释如下：

  • ​​[a,&b]​​ a变量以值的方式呗捕获，b以引用的方式被捕获。
  • ​​[this]​​ 以值的方式捕获 this 指针。
  • ​​[&]​​ 以引用的方式捕获所有的外部自动变量。
  • ​​[=]​​ 以值的方式捕获所有的外部自动变量。
  • ​​[]​​ 不捕获外部的任何变量。

此外，params 指定 lambda 表达式的参数。

一个具体的 C++11 lambda 表达式例子：




#include <vector>
#include <iostream>
#include <algorithm>
#include <functional>
 
int main()
{
    std::vector<int> c { 1,2,3,4,5,6,7 };
    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'; 
}