c++11lambda表达式，匿名函数

时间：2021-11-13 20:02:57

from：http://blog.csdn.net/srzhz/article/details/7934652

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

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


基本的Lambda函数


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

[cpp] view plain copy print ?
  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 copy print ?
  1. [] () -> int {return 1; } 
[] () -> int { return 1; }

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

[cpp] view plain copy print ?
  1. [captures] (params) -> ret {Statments;}  
[captures] (params) -> ret {Statments;}

Lambda函数的用处


假设你设计了一个地址簿的类。现在你要提供函数查询这个地址簿，可能根据姓名查询，可能根据地址查询，还有可能两者结合。要是你为这些情况都写个函数，那么你一定就跪了。所以你应该提供一个接口，能方便地让用户自定义自己的查询方式。在这里可以使用lambda函数来实现这个功能。
[cpp] view plain copy print ?
  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 copy print ?
  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 copy print ?
  1. const string& addr  
const string& addr
返回值是bool类型。
如果用户要使用不同的方式查询的话，只要定义不同的lambda函数就可以了。

Lambda函数中的变量截取



在上述例子中，lambda函数使用的都是函数体的参数和它内部的信息，并没有使用外部信息。我们设想这样的一个场景，我们从键盘读入一个名字，然后用lambda函数定义一个匿名函数，在地址簿中查找有没有相同名字的人。那么这个lambda函数势必就要能使用外部block中的变量，所以我们就得使用变量截取功能（Variable Capture)。
[cpp] view plain copy print ?
  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 copy print ?
  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 copy print ?
  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. } ); 
标签：

相关文章