【1】lambda表达式语法
lambda表达式的语法定义如下：
[capture]（parameters）mutable ->return-type { statement };
（1）[capture]: 捕捉列表。捕捉列表总是出现在lambda函数的开始处。实质上，[]是lambda引出符（即独特的标志符）
编译器根据该引出符判断接下来的代码是否是lambda函数
捕捉列表能够捕捉上下文中的变量以供lambda函数使用
捕捉列表由一个或多个捕捉项组成，并以逗号分隔，捕捉列表一般有以下几种形式：
<1> [var] 表示值传递方式捕捉变量var
<2> [=] 表示值传递方式捕捉所有父作用域的变量（包括this指针）
<3> [&var] 表示引用传递捕捉变量var
<4> [&] 表示引用传递捕捉所有父作用域的变量（包括this指针）
<5> [this] 表示值传递方式捕捉当前的this指针
<6> [=，&a，&b] 表示以引用传递的方式捕捉变量 a 和 b，而以值传递方式捕捉其他所有的变量
<7> [&，a，this] 表示以值传递的方式捕捉 a 和 this，而以引用传递方式捕捉其他所有变量
备注：父作用域是指包含lambda函数的语句块
另外，需要注意的是，捕捉列表不允许变量重复传递。下面的例子就是典型的重复，会导致编译错误：
[=, a] 这里 = 已经以值传递方式捕捉了所有的变量，那么再捕捉 a 属于重复
[&，&this] 这里 & 已经以引用传递方式捕捉了所有变量，那么再捕捉 this 属于重复
（2）（parameters）: 参数列表。与普通函数的参数列表一致。如果不需要参数传递，则可以连同括号（）一起省略
（3）mutable : mutable修饰符。默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性（后面有详解）
在使用该修饰符时，参数列表不可省略（即使参数为空）
（4）->return-type : 返回类型。用追踪返回类型形式声明函数的返回类型。
出于方便，不需要返回值的时候也可以连同符号->一起省略
此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导
（5）{statement} : 函数体。内容与普通函数一样，不过除了可以使用参数之外，还可以使用所有捕获的变量
在lambda函数的定义中，参数列表和返回类型都是可选的部分，而捕捉列表和函数体都可能为空
那么，在极端情况下，C++11中最为简单的lambda函数只需要声明为：
[]{};
就可以了。不过显然，这样的lambda函数不能做任何事情（乍一看好漂亮，其实仅是好看）。
【2】lambda函数示例代码
示例代码1：
#include <iostream>
using namespace std; void main()
{
int a = , b = ; auto totalAB = [] (int x, int y)->int { return x + y; };
int aAddb = totalAB(a, b);
cout << "aAddb :" << aAddb << endl; auto totalAB2 = [a, &b]()->int { return a + b; };
int aAddb2 = totalAB2();
cout << "aAddb2 :" << aAddb2 << endl; auto totalAB3 = [=]()->int { return a + b; };
int aAddb3 = totalAB3();
cout << "aAddb3 :" << aAddb3 << endl; []{}; // 最简lambda函数
[=] { return a + b; }; // 省略了参数列表与返回类型，返回类型由编译器推断为int
auto fun1 = [&] (int c) { b = a + c; }; // 省略了返回类型，无返回值
auto fun2 = [=, &b](int c)->int { return b += a + c; }; // 各部分都很完整的lambda函数
cout << "fun2(100) :" << fun2() << endl;
}
// Result:
/*
aAddb :30
aAddb2 :30
aAddb3 :30
fun2(100) :130
*/
以上代码仅供学习参考
【3】lambda函数的作用
lambda函数的使用示例代码：
#include <iostream>
#include <vector>
#include <algorithm>
#include "time.h"
using namespace std; void main()
{
vector<int> nVec;
for (int i = ; i < ; ++i)
{
nVec.push_back(i);
} double time_Start = (double)clock();
for (vector<int>::const_iterator it = nVec.begin(); it != nVec.end(); ++it)
{
cout << *it << endl;
}
double time_Finish = (double)clock();
double time_Interval_1 = (double)(time_Finish - time_Start) / ; time_Start = (double)clock();
for_each( nVec.begin(), nVec.end(), [] (int val){ cout << val << endl; } );
time_Finish = (double)clock();
double time_Interval_2 = (double)(time_Finish - time_Start) / ; cout << "time_Interval_1 :" << time_Interval_1 << endl;
cout << "time_Interval_2 :" << time_Interval_2 << endl; }
// Result:
/*
time_Interval_1 :17.748
time_Interval_2 :17.513
*/
lambda函数的引入为STL的使用提供了极大的方便。同样是遍历容器，效率反而提高了很多。
【4】lambda函数 与 仿函数
何谓仿函数？个人理解，像函数一样工作的对象。
根据面向对象的编程思想，那么问题来了！既然主语是一个对象，创建这个对象的类长什么样子呢？
据听说，所有科学中数学学科最重要，语文重要性次之。为什么呢？
数学可以利用来解决问题，但当问题解决不了的时候，可以用语文涂画，涂画得让人听不懂。好像很高大上一样一样~
关于仿函数，请看下面示例：
#include <iostream>
using namespace std; class _functor_plus
{
private:
int m_nValue; public:
_functor_plus(int nValue = );
_functor_plus operator+ (const _functor_plus & funObj);
void printInfo();
}; _functor_plus::_functor_plus(int nValue) : m_nValue(nValue)
{
} _functor_plus _functor_plus::operator+ (const _functor_plus & funObj)
{
m_nValue += funObj.m_nValue;
return _functor_plus(m_nValue);
} void _functor_plus::printInfo()
{
cout << m_nValue << endl;
} class _functor_override
{
public:
int operator()(int x, int y);
}; int _functor_override::operator()(int x, int y)
{
return x + y;
} int main()
{
_functor_plus plusA, plusB, plusC;
plusC = plusA + plusB;
plusA.printInfo();
plusB.printInfo();
plusC.printInfo(); int boys = , girls = ;
_functor_override totalChildren;
cout << "totalChildren(int, int): " << totalChildren(boys, girls);
}
// Result:
/*
200
100
200
totalChildren(int, int): 7
*/
在这个例子中，_functor_override类的operator（）被重载。
因此，在调用该函数的时候，我们看到与函数调用一样的形式。
只不过这里的totalChildren不是函数名称，而是一个对象名称。
相比于函数，仿函数可以拥有初始化状态：
一般通过class定义私有成员，并在声明对象的时候对其进行初始化，
那般，私有成员的状态就成了仿函数的初始状态。
由于声明一个仿函数对象可以拥有多个不同的初始状态的实例，
因此，可以借由仿函数产生多个功能类似实质却各不同的仿函数实例。
请参见下例：
#include <iostream>
using namespace std; class Tax
{
private:
double m_dRate;
int m_nBase; public:
Tax(double dRate, int nBase) : m_dRate(dRate), m_nBase(nBase)
{
} double operator() (double dMoney)
{
return (dMoney - m_nBase) * m_dRate;
}
}; int main()
{
Tax high(0.40, );
Tax middle(0.25, );
cout << "tax over 3w: " << high() << endl;
cout << "tax over 2w: " << middle() << endl;
}
// Result:
/*
tax over 3w: 3000
tax over 2w: 1000
*/
到这里，是否发现仿函数和lambda之间存在一种“衍生”的关系？
难道还不明显？没看懂？咱再接着剖析，谁让程序员就这么理性呢？
请再看下例：
#include <iostream>
using namespace std; class AirportPrice
{
private:
double m_dDutyfreeRate; public:
AirportPrice(double dDutyfreeRate) : m_dDutyfreeRate(dDutyfreeRate)
{} double operator() (double dPrice)
{
return dPrice * ( - m_dDutyfreeRate/);
}
}; void main()
{
double dRate = 5.5;
AirportPrice fanFunObj(dRate); auto ChangLambda = [dRate](double dPrice)->double
{
return dPrice * ( - dRate/);
};
double purchased1 = fanFunObj();
double purchased2 = ChangLambda();
cout << "purchased1:" << purchased1 << endl;
cout << "purchased2:" << purchased2 << endl;
}
// Result:
/*
purchased1:3495.55
purchased2:3495.55
*/
分别使用了仿函数和lambda两种方式来完成扣税后的产品价格计算。
lamba函数捕捉了dRate变量，而仿函数则以dRate进行初始化类。
其他的，在参数传递上，两者保持一致，结果也一致。
可以看到，除去在语法层面的差异，lambda函数和仿函数有着相同的内涵：
即都可以捕捉一些变量作为初始化状态，并接受参数进行运算。
而事实上，仿函数正是编译器实现lambda的一种方式。
在现阶段，通常编译器都会把lambda函数转化为一个仿函数对象。
因此，C++11中，lambda可以视为仿函数的一种等价形式。
备注：有时，编译时发现lambda函数出现了错误，编译器会提示一些构造函数相关的信息，
显然是由于lambda的这种实现方式造成的。理解这种实现也能够正确理解错误信息的由来。
【5】lambda函数等同于一个局部函数
局部函数，在函数作用域中定义的函数，也称为内嵌函数。
局部函数通常仅属于其父作用域，能够访问父作用域的变量。
C/C++语言标准中不允许局部函数存在（FORTRAN语言支持）
C++11标准却用比较优雅的方式打破了这个规则。
因为事实上，lambda可以像局部函数一样使用。请参见下例：
#include <iostream>
using namespace std; extern int z = ;
extern float c = 100.00; void Calc(int& rnOne, int nTwo, float& rfThree, float fFour)
{
rnOne = nTwo;
rfThree = fFour;
} void TestCalc()
{
int x, y = ;
float a, b = 4.0;
int success = ; auto validate = [&]()->bool
{
if ((x == y + z) && (a == b + c))
return ;
else
return ;
}; Calc(x, y, a, b);
success += validate(); y = ;
b = 100.0;
Calc(x, y, a, b);
success += validate();
} void main()
{
}
在没有lambd函数之前，通常需要在TestCalc外声明同样一个函数，
并且把TestCalc中的变量当作参数进行传递。
出于函数作用域及运行效率的考虑，那样声明函数通常要加上关键字static 和 inline
相比于一个传统意义上的函数定义，lambda函数在这里直观，使用方便可读性很好。请参见下例：
#include <iostream>
using namespace std; int Prioritize(int nValue)
{
return nValue + ;
} int AllWorks(int nTimes)
{
int i = , x = ;
try
{
for (i = ; i < nTimes; ++i)
{
x += Prioritize(i);
}
}
catch (...)
{
x = ;
} const int y = [=]()->int
{
int i = , val = ;
try
{
for (; i < nTimes; ++i)
{
val += Prioritize(i);
}
}
catch (...)
{
val = ;
}
return val;
}();
// lambda表达式
{
[]{}();
[](){}();
[]{ cout << "emptyLambdaExec" << endl; }();
[=](){ cout << "const int y :" << y << endl; }();
[&](){ cout << "int x :" << x << endl; }();
} return ;
} void main()
{
AllWorks();
} // Result:
/*
emptyLambdaExec
const int y :145
int x :145
*/
备注：注意此例中的lambda表达式作用域中比较特殊的几个lambda函数。
【6】关于lambda的一些问题及其有趣的测试
（1）使用lambda函数时候，不同的捕捉方式会导致不同的结果：
请看下例：
#include <iostream>
using namespace std; void main()
{
int j = ;
auto by_val_lambda = [=] { return j + ; };
auto by_ref_lambda = [&] { return j + ; };
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;
} //Result:
/*
by_val_lambda: 11
by_ref_lambda: 11
by_val_lambda: 11
by_ref_lambda: 12
*/
充分说明了传值和引用方式的区别。
（2）使用lambda函数与函数指针
一般情况下，把匿名的lambda函数赋值给一个auto类型的变量，
这是一种声明和使用lambda函数的方法。
结合关于auto的知识，有人会猜测totalChild是一种函数指针类型的变量
结合lambda函数和仿函数之间关系，大多人会倾向于认为lambda是一种自定义类型。
实质上，lambda的类型并非简单函数指针类型或自定义类型。
从C++11标准定义发现，lambda类型被定义为“闭包”的类，而每一个lambda表达式则会产生一个闭包类型的临时对象。
也因此，严格地讲，lambda函数并非函数指针。
但是，C++11标准却允许lambda表达式向函数指针的转换，
前提是lambda函数没有捕捉任何变量，且函数指针所示的函数原型，必须跟lambda函数有着相同的调用方式。
#include <iostream>
using namespace std; void main()
{
int girs = , boys = ;
auto totalChild = [](int x, int y)->int{ return x + y; };
typedef int (*pFunAll)(int x, int y);
typedef int (*pFunOne)(int x); pFunAll funAll;
// funAll = totalChild; // 编译失败！ pFunOne funOne;
// funOne = totalChild; //编译失败！参数必须一致 decltype(totalChild) allPeople = totalChild; // 需通过decltype获得lambda的类型
// decltype(totalChild) totalPeople = funAll; // 编译失败，指针无法转换lambda
}
第 12 行，编译错误信息如下：
error C2440: “=”: 无法从“`anonymous-namespace'::<lambda0>”转换为“pFunAll”
没有可用于执行该转换的用户定义的转换运算符，或者无法调用该运算符
MSVC10环境下，第一步编译不通过。
关于此问题参见文章《在 MSVC10 下，將 lambda expression 轉換成 C 的 function pointer》
第 15 行 编译失败，参数不一致
第 18 行 编译失败，函数指针转换为lambda也是不成功的。
值得注意的是，可以通过decltype的方式获取lambda函数的类型。
（3）lambda函数的常量性以及mutable关键字
C++11中，默认情况下lambda函数是一个const函数。
神马意思呢？请参见下例：
#include <iostream>
using namespace std; class const_val_lambda
{
public:
const_val_lambda(int v) : m_nVal(v)
{}
public:
void operator() () const
{
// m_nVal = 3; /*注意：常量成员函数*/
} void ref_const_Fun(int& nValue) const
{
nValue = ;
} private:
int m_nVal;
}; void main()
{
int val = ;
// 编译失败！在const的lambda中修改常量
// auto const_val_lambda = [=]() { val = 3;}; // 不能在非可变 lambda 中修改按值捕获
// 非const的lambda,可以修改常量数据
auto mutable_val_lambda = [=]() mutable{ val = ; };
// 依然是const的lambda,不过没有改动引用本身
auto const_ref_lambda = [&] { val = ; };
// 依然是const的lambda,通过参数传递val
auto const_param_lambda = [&](int varA) { varA = ;};
const_param_lambda(val);
}
备注：使用引用方式传递的变量在常量成员函数中修改值并不会导致错误。
【7】lambda 与 STL
lambda对C++11最大的贡献，或者说改变，应该在STL库中
相关应用，具体请再参见下例：
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std; const int ubound = ; vector<int> nums;
vector<int> largeNums; void initNums()
{
for (int i = ; i < ; ++i)
{
nums.push_back(i);
}
} inline void largeNumsFunc(int i)
{
if (i > ubound)
{
largeNums.push_back(i);
}
} void filter()
{
for (auto it = nums.begin(); it != nums.end(); ++it)
{
if ((*it) > ubound)
{
largeNums.push_back(*it);
}
} for_each (nums.begin(), nums.end(), largeNumsFunc); for_each (nums.begin(), nums.end(), [=](int i)
{
if (i > ubound)
{
largeNums.push_back(i);
}
});
} void printInfo()
{
for_each (largeNums.begin(), largeNums.end(), [=](int i)
{
cout << i << " ";
});
cout << endl;
} void main()
{
initNums(); // 初始化值
filter(); // 过滤值
printInfo(); //打印信息
}
具体遇到其它的问题 ，再具体分析和学习。
【8】在返回类型明确的情况下，可以省略返回值类型，让编译器对返回类型进行推导
第一部分第4小节：“此外，在返回类型明确的情况下，也可以省略该部分，让编译器对返回类型进行推导”，示例如下：
#include <iostream>
#include <string> int main()
{
std::string str = "user_behavior_log";
auto key = [&]() {
if (str.empty())
{
return std::string{};
} return (str + ".json");
}; std::cout << key() << std::endl; return ;
} // result
/*
user_behavior_log.json
*/
希望能加深对返回类型的理解。
【9】lambda函数的总结
C++11中的Lambda表达式用于定义并创建匿名的函数对象，以简化编程工作。
Good Good Study, Day Day Up.
顺序 选择 循环 总结