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

声明：本文参考了Alex Allain的文章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

 

基本的Lambda函数

 

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

 

#include

using namespace std;

int main()
{
    auto func = [] () { cout << "Hello world"; };
    func(); // now call the function
}

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

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

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

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

 

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

 

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

Lambda函数的用处

 

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

#include
#include

class AddressBook
{
    public:
    // using a template allows us to ignore the differences between functors, function pointers
    // and lambda
    template<typename Func>
    std::vector findMatchingAddresses (Func func)
    {
        std::vector 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 _addresses;
};

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

 

AddressBook global_address_book;

vector 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函数。参数类型是

const string& addr

返回值是bool类型。

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

 

Lambda函数中的变量截取

 

 

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

// 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的时候，原来你得这么写：

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函数你就可以这么写

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 这个PPT详细介绍了如何使用lambda表达式和STL

C++11 匿名函数(由[&]想到的)  

2013-05-28 13:15:49|  分类： learning |  标签：c++11   |举报 |字号大中小 订阅

最近在读别人写的C++代码时发现一些很古怪的东西：

有这样的：

         // Declare graph of factor types and build the factor structure
         std::vector<dtf::prior_t> priors;
         float tree_ms = ts::timing_ms([&]() {
            graph = InitFactorGraph(forest, priors, dags_train, sigma_unary, sigma_pw,
               levels_unary, levels_pw, feat_box_max, feat_radius);
         });
         std::cout << "Decision tree induction took " << (tree_ms/1000.0) << "s" << std::endl;

     
     
       
       
       
       


     
     
       
       
       
       

也有这样的，主函数写了一堆声明定义以后就return一个这样的东西：

  return processFrames([&](cv::Mat frame) {
    cv::Mat withoutBackground = bgHider.process(frame);
    cv::Mat eroded;
    cv::erode(withoutBackground, eroded, cv::Mat(), cv::Point(-1,-1), 3);
    cv::Mat dilated;
    cv::dilate(eroded, dilated, cv::Mat(), cv::Point(-1,-1), 5);
    //cv::Mat processed = redFilter.filter(withoutBackground);
    cv::Mat* showImage = 0;
    switch (showStage) {
      case 0: showImage = &frame; break;
      case 1: showImage = &withoutBackground; break;
      case 2: showImage = &eroded; break;
      case 3: showImage = &dilated; break;
      default: showImage = 0;
    }
    if (showImage) {
      std::ostringstream oss;
      auto millis = stopWatch.getMillisAndReset();
      oss << 1000/millis;
      cv::putText(*showImage, oss.str(),cv::Point(30,frame.rows-30), cv::FONT_HERSHEY_COMPLEX_SMALL, 0.8, cv::Scalar(200,200,250),1,CV_AA);
      cv::imshow(BGName, bgHider.backgroundEstimate());
      cv::imshow(TrackerName, *showImage);
    }
  });

我的感觉就是

可是还是要弄懂吧~

------------------ 割 割 割------------------

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

 不过首先可以看这里：http://blog.csdn.net/srzhz/article/details/7934483

介绍了一些自动类型推断和类型获取，有以下一些内容：

auto：当编译器能够在一个变量的声明时候就推断出它的类型，那么你就能够用auto关键字来作为他们的类型

例如这样

vector vec;
vector::iterator itr = vec.iterator();

变成这样

vector vec;
auto itr = vec.iterator();

然后是 新的返回语法，后置了…

由这样

Person::PersonType Person::getPersonType ()
{
    return _person_type;
}

变成这样

auto Person::getPersonType () -> PersonType
{
    return _person_type;
}

还有 类型获取（Decltype）

int x = 3;
decltype(x) y = x; // same thing as auto y = x;

看上去都是一些简单的卖弄技巧的东西啊，不过他们组合起来就变成酱紫：

template <typename Builder>
auto
makeAndProcessObject (const Builder& builder) -> decltype( builder.makeObject() )
{
    auto val = builder.makeObject();
    // do stuff with val
    return val;
}

这样就为代码带来很大的方便了，尤其是lambda中。

然后戳这里看lambda：http://blog.csdn.net/srzhz/article/details/7934652

以前看python的时候，对lambda的理解是：如果一个函数只在某一小块地方被调用，其它地方不用的话，用lambda表达式会增加可读性以及减少代码量吧。

lambda的形式是：

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

captures的选项有这些：

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

都是关于怎么使用外部变量的。

最简单的例子，就像这样：

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

----------我是回溯分割线--------

分析一下最上面的例子吧。

         // Declare graph of factor types and build the factor structure
         std::vector<dtf::prior_t> priors;
         float tree_ms = ts::timing_ms([&]() {
            graph = InitFactorGraph(forest, priors, dags_train, sigma_unary, sigma_pw,
               levels_unary, levels_pw, feat_box_max, feat_radius);
         });
         std::cout << "Decision tree induction took " << (tree_ms/1000.0) << "s" << std::endl;

首先ts::timing_ms是一个模板函数返回float：

// Execute 'func', and return the duration of the function call, in ms.
template <typename Func> inline float timing_ms(Func func)
{
   return timing_median_ms(1, func);
}

timing_ms 调用了  timing_median_ms，再调用func 得到float返回值。 这个func实际上就是lambda表达式了。表达式用到 [&]，说明它能够以引用形式使用其他的外部变量，因为里面的一些参数，如graph，是一个外部变量 。

这样兜兜转转，实际上对功能更好地划分了吧。把实际要做的事放在lambda里，时间计数放在timing_ms封装好的地方。

然后就这样吧，其实看懂了自己也不一定能很好的应用出来… #哭着跑掉#