深入理解C++11（六）

深入理解C++11（六）

lambda表达式
lambda表达式是C++11最重要也最常用的一个特性之一。其实在C#3.5中就引入了lambda，Java则至今还没引入，要等到Java 8中才有lambda表达式。lambda来源于函数式编程的概念，也是现代编程语言的一个特点。C++11这次终于把lambda加进来了。
lambda表达式有如下优点：

·声明式编程风格：就地匿名定义目标函数或函数对象，不需要额外写
一个命名函数或者函数对象。以更直接的方式去写程序，好的可读性和可维
护性。
·简洁：不需要额外再写一个函数或者函数对象，避免了代码膨胀和功
能分散，让开发者更加集中精力在手边的问题，同时也获取了更高的生产
率。
·在需要的时间和地点实现功能闭包，使程序更灵活。

下面，先从lambda表达式的基本功能开始介绍。
lambda表达式定义了一个匿名函数，并且可以捕获一定范围内的变量。lambda表达式的语法形式可简单归纳如下：

[ capture ] ( params ) opt -> ret { body; };

其中：
capture是捕获列表；params是参数表；opt是函数选项；ret是返回值类型；body是函数体。因此，一个完整的lambda表达式看起来像这样：

auto f = [](int a) -> int { return a + 1; };
std::cout << f(1) << std::endl; // 输出: 2

可以看到，上面通过一行代码定义了一个小小的功能闭包，用来将输入
加1并返回。

在C++11中，lambda表达式的返回值是通过前面介绍的返回值后置语法来定义的。其实很多时候，lambda表达式的返回值是非常明显的，比如上例。因此，C++11中允许省略lambda表达式的返回值定义：

auto f = [](int a){ return a + 1; };

这样编译器就会根据return语句自动推导出返回值类型。需要注意的是，初始化列表不能用于返回值的自动推导：

auto x1 = [](int i){ return i; }; // OK: return type is int
auto x2 = [](){ return { 1, 2 }; }; // error: 无法推导出返回值类型

这时我们需要显式给出具体的返回值类型。另外，lambda表达式在没有参数列表时，参数列表是可以省略的。因此像下面的写法都是正确的：

auto f1 = [](){ return 1; };
auto f2 = []{ return 1; }; // 省略空参数表

lambda表达式可以通过捕获列表捕获一定范围内的变量：

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

下面看一下它的具体用法，如代码清单1-23所示。
代码清单1-23 lambda表达式的基本用法：

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表达式
能够访问的外部变量，以及如何访问这些变量。
需要注意的是，默认状态下lambda表达式无法修改通过复制方式捕获的外
部变量。如果希望修改这些变量的话，我们需要使用引用方式进行捕获。

一个容易出错的细节是关于lambda表达式的延迟调用的：

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

在这个例子中，lambda表达式按值捕获了所有外部变量。在捕获的一瞬
间，a的值就已经被复制到f中了。之后a被修改，但此时f中存储的a仍然还是
捕获时的值，因此，最终输出结果是0。

如果希望lambda表达式在调用时能够即时访问外部变量，我们应当使用引用方式捕获。从上面的例子中我们知道，按值捕获得到的外部变量值是在lambda表达式定义时的值。此时所有外部变量均被复制了一份存储在lambda表达式变量中。此时虽然修改lambda表达式中的这些外部变量并不会真正影响到外部，我们却仍然无法修改它们。

那么如果希望去修改按值捕获的外部变量应当怎么办呢？这时，需要显式指明lambda表达式为mutable：

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

需要注意的一点是，被mutable修饰的lambda表达式就算没有参数也要写明参数列表。最后，介绍一下lambda表达式的类型。lambda表达式的类型在C++11中被称为“闭包类型（Closure Type）”。它是一个特殊的，匿名的非nunion的类类型。
因此，我们可以认为它是一个带有operator（）的类，即仿函数。因此，我们可以使用std：：function和std：：bind来存储和操作lambda表达式：

std::function<int(int)> f1 = [](int a){ return a; };
std::function<int(void)> f2 = std::bind([](int a){ return a; },
123);

另外，对于没有捕获任何变量的lambda表达式，还可以被转换成一个普通的函数指针：

using func_t = int(*)(int);
func_t f = [](int a){ return a; };
f(123);

lambda表达式可以说是就地定义仿函数闭包的“语法糖”。它的捕获列表捕获住的任何外部变量，最终均会变为闭包类型的成员变量。而一个使用了成员变量的类的operator（），如果能直接被转换为普通的函数指针，那么lambda表达式本身的this指针就丢失掉了。而没有捕获任何外部变量的lambda表达式则不存在这个问题。
这里也可以很自然地解释为何按值捕获无法修改捕获的外部变量。因为按照C++标准，lambda表达式的operator（）默认是const的 [2] 。一个const成员函数是无法修改成员变量的值的。而mutable的作用，就在于取消operator（）的const。
需要注意的是，没有捕获变量的lambda表达式可以直接转换为函数指针，而捕获变量的lambda表达式则不能转换为函数指针。看看下面的代码：

typedef void(*Ptr)(int*);
// 正确，没有状态的
lambda（没有捕获）的
lambda表达式可以直接转换为函数指针
Ptr p = [](int* p){delete p;};
Ptr p1 = [&](int* p){delete p;};// 错误，有状态的
lambda不能直接转换为函数指针

上面第二行代码能编译通过，而第三行代码不能编译通过，因为第三行的代码捕获了变量，不能直接转换为函数指针
声明式的编程风格，简洁的代码
就地定义匿名函数，不再需要定义函数对象，大大简化了标准库算法的调用。比如，在C++11之前，我们要调用for_each函数将vector中的偶数打印出来，如代码清单1-24所示。
代码清单1-24 lambda表达式代替函数对象的示例

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

这样写既烦琐又容易出错。有了lambda表达式以后，我们可以使用真正的闭包概念来替换掉这里的仿函数，代码如下：

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;

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

在需要的时间和地点实现闭包，使程序更灵活
在1.5.3节中使用了std：：bind组合了多个函数，实现了计算集合中大于5小于10的元素个数的功能：

using std::placeholders::_1;
// 查找集合中大于5小于10的元素个数
auto f = std::bind(std::logical_and<bool>(),
std::bind(std::greater<int>(), _1, 5),
std::bind(std::less_equal<int>(), _1, 10));
int count = std::count_if(coll.begin(), coll.end(), f);

通过使用lambda表达式，可以轻松地实现类似的功能：

// 查找大于5小于10的元素的个数
int count = std::count_if(coll.begin(), coll.end(), [](int
x){return x > 5 && x < 10;});

可以看到，lambda表达式比std：：bind的灵活性更好，也更为简洁。当然，这都得益于lambda表达式的特征，它可以任意封装出功能闭包，使得短小的逻辑可以以最简洁清晰的方式表达出来。
比如说，我们这时候的需求变更了，只希望查找大于10，或小于10的个数：

// 查找大于10的元素的个数
int count = std::count_if(coll.begin(), coll.end(), [](int
x){return x > 10;});
// 查找小于10的元素的个数
int count = std::count_if(coll.begin(), coll.end(), [](int
x){return x < 10;});

不论如何去写，使用lambda表达式的修改量是非常小的，清晰度也很好。lambda和std：：function的效果是一样的，代码还更简洁了。一般情况下可以直接用lambda来代替function，但还不能完全替代，因为还有些老的库，比如boost的一些库就不支持lambda，还需要function。

C++11引入函数式编程的概念中的lambda，让代码更简洁，更灵活，也更强大，并提高了开发效率，提高了可维护性。