C++11新特性：Lambda函数（匿名函数）

客官°小女子只卖身不卖艺 2022-08-11 08:59 167阅读 0赞

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

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

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

为了明白Lambda函数的用处，请务必先搞明白C++中的自动类型推断：[http://blog.csdn.net/srzhz/article/details/7934483][http_blog.csdn.net_srzhz_article_details_7934483]

# 基本的Lambda函数 #

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

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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

#include <iostream>
    
    using namespace std;
    
    int main()
    {
        auto func = [] () { cout << "Hello world"; };
        func(); // now call the function
    }

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

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

正常情况下，只要函数体中所有return都是同一个类型的话，编译器就会自行判断函数的返回类型。也可以显示地指定lambda函数的返回类型。这个需要用到函数返回值后置的功能,比如这个例子：

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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

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

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

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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

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

# Lambda函数的用处 #

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

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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

#include <string>
    #include <vector>
    
    class AddressBook
    {
        public:
        // using a template allows us to ignore the differences between functors, function pointers 
        // and lambda
        template<typename Func>
        std::vector<std::string> findMatchingAddresses (Func func)
        { 
            std::vector<std::string> results;
            for ( auto itr = _addresses.begin(), end = _addresses.end(); itr != end; ++itr )
            {
                // call the function passed into findMatchingAddresses and see if it matches
                if ( func( *itr ) )
                {
                    results.push_back( *itr );
                }
            }
            return results;
        }
    
        private:
        std::vector<std::string> _addresses;
    };

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

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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.  \}

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

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

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

1.  const string& addr

const string& addr

返回值是bool类型。

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

# Lambda函数中的变量截取 #

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

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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

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

从上述代码看出，我们的lambda函数已经能使用外部作用域中的变量name了。这个lambda函数一个最大的区别是\[\]中间加入了&符号。这就告诉了编译器，要进行变量截取。这样lambda函数体就可以使用外部变量。如果不加入任何符号，编译器就不会进行变量截取。

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

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

# Lambda函数和STL #

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

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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.  \}

vector<int> v;
    v.push_back( 1 );
    v.push_back( 2 );
    //...
    for ( auto itr = v.begin(), end = v.end(); itr != end; itr++ )
    {
        cout << *itr;
    }

现在有了lambda函数你就可以这么写

**\[cpp\]** [ view plain][view plain] [copy][view plain] [print][view plain] [?][view plain]

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

vector<int> v;
    v.push_back( 1 );
    v.push_back( 2 );
    //...
    for_each( v.begin(), v.end(), [] (int val)
    {
        cout << val;
    } );

而且这么写了之后执行效率反而提高了。因为编译器有可能使用”循环展开“来加速执行过程（计算机系统结构课程中学的）。  
[http://www.nwcpp.org/images/stories/lambda.pdf][http_www.nwcpp.org_images_stories_lambda.pdf] 这个PPT详细介绍了如何使用lambda表达式和STL

转自 [ http://blog.csdn.net/srzhz/article/details/7934652][http_blog.csdn.net_srzhz_article_details_7934652]

[http_www.cprogramming.com_c_11_c_11-lambda-closures.html]: http://www.cprogramming.com/c++11/c++11-lambda-closures.html
[http_blog.csdn.net_srzhz_article_details_7934483]: http://blog.csdn.net/srzhz/article/details/7934483
[view plain]: http://blog.csdn.net/srzhz/article/details/7934652#
[http_www.nwcpp.org_images_stories_lambda.pdf]: http://www.nwcpp.org/images/stories/lambda.pdf
[http_blog.csdn.net_srzhz_article_details_7934652]: http://blog.csdn.net/srzhz/article/details/7934652