c++中的Lambda表达式

Lambda表达式
C++11的一大亮点就是引入了Lambda表达式。利用Lambda表达式，可以方便的定义和创建匿名函数。

相较于函数指针和函数符等函数对象，Lambda有以下优点：

距离：定义与使用在同一个地方，方便查看、修改和调试
简洁：可以给Lambda指定名称从而多次使用
效率：函数指针一般不会被内联，因为它的地址可能会被使用
功能：Lambda可访问作用域内任何动态变量

Lambda表达式的声明式如下：

// 一般形式
[capture] (params) mutable exception-> return type { function body }

// 常量形式，即不可更改捕获列表中的值
[capture list] (params list) -> return type {function body}

// 根据函数体推断返回类型
[capture list] (params list) {function body}

// 无参函数
[capture list] {function body}

说明如下：
capture：捕获作用域内变量，后面详述
params：参数
mutable：可变的，用来说明可以修改捕获的变量
exception：异常
return type：返回类型
function body：函数体

一个简单的Lambda类似下面：

// 返回值类型通过自动推导获得
auto foo = [](int x) { return x + 1; };

std::cout << foo(2) << std::endl; // 输出：3

Lambda需要明确声明需要使用哪些范围内可见变量，否则无法使用。规则如下：

[] 不捕获任何变量。
[&] 捕获外部作用域中所有变量，并作为引用在函数体中使用（按引用捕获）。
[=] 捕获外部作用域中所有变量，并作为副本在函数体中使用（按值捕获）。
[=，&foo] 按值捕获外部作用域中所有变量，并按引用捕获 foo 变量。
[&, x]：默认以引用捕获所有变量，但是x是例外，通过值捕获。
[bar] 按值捕获 bar 变量，同时不捕获其他变量。
[this] 捕获当前类中的 this 指针，让 lambda 表达式拥有和当前类成员函数同样的访问权限。如果已经使用了 & 或者 =，就默认添加此选项。捕获 this 的目的是可以在 lamda 中使用当前类的成员函数和成员变量。
[*this]：通过传值方式捕获当前对象。
举例如下：

class A
{
public:
    int i_ = 0;
    void func(int x, int y)
    {
        auto x1 = []{ return i_; };                    // error，没有捕获外部变量
        auto x2 = [=]{ return i_ + x + y; };           // OK，捕获所有外部变量
        auto x3 = [&]{ return i_ + x + y; };           // OK，捕获所有外部变量
        auto x4 = [this]{ return i_; };                // OK，捕获this指针
        auto x5 = [this]{ return i_ + x + y; };        // error，没有捕获x、y
        auto x6 = [this, x, y]{ return i_ + x + y; };  // OK，捕获this指针、x、y
        auto x7 = [this]{ return i_++; };              // OK，捕获this指针，并修改成员的值
    }
};

int a = 0, b = 1;
auto f1 = []{ return a; };               // error，没有捕获外部变量
auto f2 = [&]{ return a++; };            // OK，捕获所有外部变量，并对a执行自加运算
auto f3 = [=]{ return a; };              // OK，捕获所有外部变量，并返回a
auto f4 = [=]{ return a++; };            // error，a是以复制方式捕获的，无法修改
auto f5 = [a]{ return a + b; };          // error，没有捕获变量b
auto f6 = [a, &b]{ return a + (b++); };  // OK，捕获a和b的引用，并对b做自加运算
auto f7 = [=, &b]{ return a + (b++); };  // OK，捕获所有外部变量和b的引用，并对b做自加运算

根据实际需要决定以何种方式捕获哪些变量即可。需要注意的是，默认状态下 lambda 表达式无法修改通过复制方式捕获的外部变量。如果希望修改这些变量的话，我们需要使用引用方式进行捕获。

闭包类型
lambda 表达式的类型在 C++11 中被称为“闭包类型（Closure Type）”。因此，我们可以认为它是一个带有 operator() 的类，即仿函数。因此，我们可以使用 std::function 和 std::bind 来存储和操作 lambda 表达式：

std::function<int(int)>  f1 = [](int a){ return a; };
std::function<int(int)> f2 = std::bind([](int a){ return a; }, 123); // 调用时要传参数，要跟f2的函数类型一致，传参也没用，用占位符才用参数

这里也可以很自然地解释为何按值捕获无法修改捕获的外部变量。因为按照 C++ 标准，lambda 表达式的 operator() 默认是 const 的。一个 const 成员函数是无法修改成员变量的值的。而 mutable 的作用，就在于取消 operator() 的 const。

把Lambda作为就地定义使用的函数极其方便，如下代码统计std::vector中数据：

std::vector<int> v = { 1, 2, 3, 4, 5, 6 };
int even_count = 0;
for_each( v.begin(), v.end(), [&even_count](int val)
        {
            if (!(val & 1))  // val % 2 == 0
            {
                ++ even_count;
            }
        });
std::cout << "The number of even is " << even_count << std::endl;

而在c11之前，则需要专门定义一个函数用来做统计。

作为回调函数也很简单，如使用cpp_redis库连接redis时，选择数据库的代码：

// 不使用Lambda
void RedisSelectCb(cpp_redis::reply &reply)
{
    if (reply.is_error())
    {
        std::cout << "err: " << reply << std::endl;
    }
}

// ...

m_redis->select(2, boost::bind(&RedisSelectCb, _1));
m_redis->sync_commit();

// 使用Lambda
m_redis->select(2, [](cpp_redis::reply &reply) {
	      if (reply.is_error())
	      {
	          std::cout << "err: " << reply << std::endl;
	      }
	  });
m_redis->sync_commit();

lambda 表达式的价值在于，就地封装短小的功能闭包，可以极其方便地表达出我们希望执行的具体操作，并让上下文结合得更加紧密。

注意事项
1、一般情况下，编译器就会根据 return 语句自动推导出返回值类型，但初始化列表不能用于返回值的自动推导，如auto x2 = { return { 1, 2 }; }; // error: 无法推导出返回值类型
2、lambda 表达式是延迟调用的，如下代码：

int a = 0;
auto f = [=]{ return a; };      // 按值捕获外部变量
a += 1;                         // a被修改了
std::cout << f() << std::endl;  // 输出: 0

捕获的一瞬间，a 的值就已经被复制到f中了。之后 a 被修改，但此时 f 中存储的 a 仍然还是捕获时的值，如果希望 lambda 表达式在调用时能够即时访问外部变量，我们应当使用引用方式捕获。

默认状态下 lambda 表达式无法修改通过复制方式捕获的外部变量，如果需要修改，需要显式指明 lambda 表达式为 mutable，如下：

int a = 0;
auto f1 = [=]{ return a++; };             // error，修改按值捕获的外部变量
auto f2 = [=]() mutable { return a++; };  // OK，mutable

需要注意的一点是，被 mutable 修饰的 lambda 表达式就算没有参数也要写明参数列表。
当然，在Lambda使用中，也会有一些坑，查看深入理解c++中的Lambda表达式了解如何避开坑。