Lambda（匿名函数）表达式是C++11最重要的特性之一，lambda来源于函数式编程的概念，也是现代编程语言的一个特点。
优点如下：
lambda表达式定义了一个匿名函数，并且可以捕获一定范围内的变量。语法形式如下：
[ capture ] ( params ) opt -> ret { body; };
一个完整的lambda表达式是这样：
auto f = [](int a) -> int {return a + 1;};
cout << f(3) << endl; //输出4
以上定义了一个完整的lambda，但是在实际的使用中，可以省略其返回值的定义，编译器会根据return语句进行自动推导返回值类型。
省略过后如下：
auto f = [](int a) {return a + 1;};
需要注意的是，初始化列表不能用于返回值的自动推导：
如：auto f = [](){return {1,2};}; //error:无法推导返回值类型
另外，如果表达式没有参数列表时，也可以省略，如：
auto f = []{return 1;};
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 = 0 ;
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表达式的延迟调用很容易出错,如下：
int a = 0;
auto f = [=]{return a;};
a += 1;
cout << f() << endl;
以上示例中，lambda按值捕获了所有外部变量，在捕获的时候 a的值就已经被复制到 f 中了，之后a被修改，但是f里面存储的a仍然是捕获时的值，所以最终输出的是 0.
如果希望lambda表达式在调用的时候能够访问外部变量，需要使用引用方式捕获。
所以简单来说，按值捕获，外部变量会被复制一份存储在lambda表达式变量中。
如果是按值捕获并且又想修改外部变量，可以显示指明lambda表达式为mutable：
int a = 0;
auto f1 = [=]{return a++;}; //error,修改按值捕获的外部变量
auto f2 = [=]() mutable {return a++;}; //ok
被mutable修饰的lambda表达式就算没有参数也要写明参数列表。
lambda表达式的类型在C++11中被称为“闭包类型”，它是一个特殊的，匿名的非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表达式则不存在这个问题。
需要注意的是，没有捕获变量的lambda表达式可以直接转换为函数指针，而捕获变量的lambda表达式则不能转换为函数指针。如下：
typedef void(*Ptr)(int*);
Ptr p = [](int *p){delete p;}; //ok
Ptr p1 = [&](int *p){delete p;}; //error
前面说到的按值捕获无法修改捕获的外部变量，因为按照C++标准，lambda表达式的operator()默认是const的，一个const成员函数是无法修改成员变量的值，而mutable的作用，就是取消operator()的const限制。
通过示例来看一下lambda的使用，在C++11之前，如果要用for_each函数将数组中的偶数数量打印出来，代码如下：
#include <vector>
#include <algorithm>
class Count
{
public:
Count(int &val):num(val){}
void operator()(int val){
if(!(val & 1)){
++num;
}
}
private:
int #
};
int main()
{
std::vector<int> v = {1,2,3,4,5,6,7};
int count = 0;
for_each(v.begin(),v.end(),Count(count));
std::cout << count << endl;
return 0;
}如果使用lambda表达式，就可以简化一下，真正使用闭包概念来替换这里的仿函数。
#include <vector>
#include <algorithm>
int main()
{
std::vector<int> v = {1,2,3,4,5,6,7};
int count = 0;
for_each(v.begin(),v.end(),[&count](int val){
if(!(val & 1)){
++count;
}
});
std::cout << count << endl;
return 0;
}lambda表达式的价值在于，就地封装短小的功能闭包，方便地表达出我们希望执行的具体操作，并让上下文结合的更加紧，代码更加简洁，更灵活，也提高了开发效率及可维护性。
参考：《深入应用C++11》
