C++11之lambda函数

最近一直在看mesos的源代码，mesos中用到了很多C++11的新特性，lambda函数就是其中的一个。对于lambda函数简单的来说就是java中的匿名函数。

语法定义
[capture] (paramenters) mutable->return-type {statement}

[capture] 捕捉列表：捕捉上下文中的变量供函数使用
(paramenters) 参数列表：跟普通参数列表相同，如果没有参数则可以连同（）一起省略
mutable mutable修饰符：默认情况下，lanbda函数是一个const函数，mutable关键字可以取消其常量性，此时，即使参数列表为空，也不可以省略参数列表
->return-type 返回类型：在没有返回值时可以连同->一起省略，同时，在返回类型明确的情况下也可以省略，由编译器进行推导
{statement} 函数体：除了参数之外还可以使用捕捉的变量
简单的lambda函数例子：

#include <iostream>
using namespace std;
int main( int argc, char* argv[]  )
{
    int boys = 3;
    int girls = 4;

    []{};//最简单的lambda函数

    [=]{ return boys + girls; };//省略参数列表和返回类型

    auto fun1 = [&]( int c ){ girls = boys + c; };

    auto fun2 = [=, &girls]( int c )->int { return girls += boys + c; };

    auto totalChild = [ girls, &boys ]()->int { return girls + boys; };
    cout << totalChild();
    return 0;
}

捕捉列表的语法规则
[var]表示值传递的方式捕捉变量
[=]b表示值传递的方式捕捉所有的父作域的变量（包括this）
[&var]表示引用传递捕捉变量
[&]表示引用传递捕捉所有父作用域变量（包括this）
[this]表示值传递的方式捕捉当前的this指针

举例：
[=,&a,&b] 表示以引用传递的方式捕捉变量a和b，以值传递的方式捕捉其他变量
[&,a,this]表示以值传递的方式捕捉变量a和this，以引用传递的方式捕捉其他变量

注意
不可以重复捕捉相同的变量
举例：
[&,&a]变量a被捕捉两次，这样不可以
在块作用域（在{}内的任何代码都是有块作用域的）以外的lambda函数捕捉列表必须为空

lambda与仿函数
仿函数：重定义了成员函数operator()函数的一种自定义的类型对象，在代码层面使用起来跟函数没有区别。

仿函数的例子：

#include <iostream>

using namespace std;

class Tax
{
private:
    float rate;
    int base;
public:
    Tax( float r, int b ):rate(r), base(b){  }
    float operator() ( float money  ){ return ( money - base ) * rate; }
};

int main( int argc, char* argv[]  )
{
    Tax high( 0.4, 3000 );
    Tax middle( 0.25, 2000 );

    cout << "tax over 3w: " << high( 37500 ) << endl;
    cout << "tax over 2w: " << middle( 27500 ) << endl;
    return 0;
}

在通过一个例子介绍仿函数与lambda函数的对比：

#include <iostream>
using namespace std;
class AirportPrice
{
private:
    float _dutyfreerate;

public:
    AirportPrice( float price ):_dutyfreerate( price ){  }
    float operator() ( float price ){ return price * ( 1 - _dutyfreerate / 100 ); }
};
int main( int argc, char *argv[]  )
{
    float tax_rate = 5.5f;
    AirportPrice Change1( tax_rate );

    auto Change2 = [ tax_rate ]( float price )->float { return price * ( 1 - tax_rate / 100 ); };

    float purchased1 = Change1( 3699 );
    float purchased2 = Change2( 2899 );

    cout << purchased1 << endl;
    cout << purchased2 << endl;
    return 0;
}

通过上面的例子可以发现仿函数与lambda函数在使用上一样，并且都可以捕捉一些变量作为初始状态，而事实上，编译器在编译阶段是将lambda函数转化成仿函数对象。

基础使用
1.在使用效果上，仿函数等价于一个局部函数。对于运算比较复杂的函数，通常函数中会有大量的局部状态和变量，这时函数需要实现一些“局部”功能，例如打印信息等，而这些局部功能不能与其他的函数共享，但是需要在此函数中重复使用，那么使用lambda的捕捉列表功能相比于较独立的全局静态函数或者私有成员函数方便很多。

2.在编写程序时，开发者通常会发现自己需要一些“常量”，但是这些常量的值却由自己初始化状态决定，例如：

#include <iostream>
using namespace std;
int Prioritize( int );
int allworks( int times  )
{
    int i;

    int x;
    try{
        for( i = 0; i < timesl i++  )
            x += Prioritize(i);//直接操作x函数
    }
    catch(...)
        x = 0;

    const int y = [=]{
        int i, val;
        try{
            for( i = 0; i < times; i++ )
                val += Prioritize(i);
        }
        catch(...)
            val = 0;
        return val;
    }();
}

其他
值传递捕捉列表与引用传递捕捉列表
对于按值方式传递的捕捉列表，其传递的值在lambda函数定义的时候就决定了；按引用传递的捕捉列表变量，其传递的值等于lambda函数调用时的值。
代码例子：

#include <iostream>
using namespace std;

int main( int argc, char* argv[] )
{
    int j = 12;

    auto by_val_lambda = [=] { return j + 1;  };
    auto by_ref_lambda = [&] { return j + 1;  };

    cout << " by_val_lambda: " << by_val_lambda() << endl;
    cout << " by_ref_lambda: " << by_ref_lambda() << endl;

    j++;

    cout << " by_val_lambda: " << by_val_lambda() << endl;
    cout << " by_ref_lambda: " << by_ref_lambda() << endl;
    return 0;
}

运行结果如下：

 by_val_lambda: 13
 by_ref_lambda: 13
 by_val_lambda: 13
 by_ref_lambda: 14

lambda函数与函数指针之间的转换
C++11允许lambda函数向函数指针转换，但是要求lambda函数没有捕捉到任何变量，且函数指针所示的函数原型，必须跟lambda函数有着相同的调用方式；同时，C++11不允许函数指针转化成lambda函数。
代码例子：

#include <iostream>

using namespace std;

int main( int argc, char* argv[] )
{
    int girls = 3;
    int boys = 4;

    typedef int (*allChild)( int x, int y );
    typedef int (*oneChild)( int x );

    auto totalChild = [](int x, int y)->int { return x + y ; };

    allChild p;
    p = totalChild;

    /*编译失败
    oneChild q;
    q = totalChild;
    */

    decltype( totalChild ) allPeople = totalChild;//通过decltype函数获得lambda函数的类型
    //编译失败
    //decltype( totalChild ) totalPeople = p;
    cout << (*p)( 5, 5 ) << endl;
    return 0;
}

mutable关键字
在C++11中。默认情况下lambda函数是一个const函数，按照规则const的成员函数不能在任何的函数体中改变非静态成员变量的值。

代码例子：

#include<iostream>
using namespace std;
int main( int argc,  char* argv[]  )
{
    int val = 10;

    /*
     * 编译失败
    auto const_val_lambda = [=]() { val = 3 };
    */
    //非const得lambda，可以修改常量数据
    auto mutable_val_lambda = [=]() mutable{ val = 3; cout << "lambda val = " << val << endl; };
    mutable_val_lambda();
    cout << "val = " << val << endl;

    //依然是const的lambda，不过没有改动引用本身
    auto const_ref_lambda = [&]() { val = 3;  cout << "lambda val = " << val << endl;};
    const_ref_lambda();
    cout << "val = " << val <<  endl;

    //依然是const的lambda，通过参数传递val
    auto const_param_lanbda = [&]( int v ){ v = 13; cout << "lambda val = " << v << endl; };
    const_param_lanbda( val  );
    cout << "val = " << val << endl;

    return 0;
}

运行结果：

lambda val = 3
val = 10
lambda val = 3
val = 3
lambda val = 13
val = 3

其实编译器将上述代码中的const_val_lambda转化成仿函数，代码如下：

class const_val_lambda{
    public:
        const_val_lambda(int v):val(v){}
    public:
        void operator() ()const{ val = 3; }/*常量成员函数*/
    private：
        int val;
};

从上述的代码来看，准确地说，lambda函数等价于const类型的operator()的仿函数。