C++11：lambda表达式
目录
一.lambda表达式
1.格式
2. lambda表达式各部分说明
3.举例
（1）例子1：相加函数
（2）[ ]捕捉列表 例子2：交换函数
仿函数比较，lambda更易懂
4.lambda注意点
5.底层原理
二.包装器
1.可调用类型对象
2.function包装器
解决useF问题
3.包装器改装逆波兰表达式
4.bind 绑定
（1）调整可调用对象参数的个数
（2）调整可调用对象参数的顺序（用处不大）
bind总代码：
一.lambda表达式
lambda表达式就是定义了一个可调用的匿名函数，一般在局部。
[]{}是最简单的lambda表达式，但是该lambda表达式没有任何意义
1.格式
lambda表达式书写格式： [capture-list] (parameters) mutable -> return-type { statement
}
[capture-list] (parameters) mutable -> return-type { statement }
捕捉列表 参数 去const（单词意思易变的） 返回值 函数体
auto Add1 = [ ](int x, int y)->int {return (x + y); };
2. lambda表达式各部分说明
（1）[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置， 编译器根据[]来
判断接下来的代码是否为lambda函数， 捕捉列表能够捕捉上下文中的变量供lambda 函数使用。
捕捉的参数都是自带const的，想要去掉const属性可以用mutable，但是捕捉的对象(变量)仍是一份拷贝，外部的a，b无法被修改，所以mutable 很少用，意义不大，不如用 [&]引用捕捉 ( )引用传参
（2）(parameters)：参数列表。与 普通函数的参数列表一致，如果不需要参数传递，则可以
连同()一起省略。所传参数和捕捉参数不一样，不自带const，可以修改
（3）mutable： 默认情况下，lambda函数总是一个const函数，mutable可以取消其常量
性。 使用该修饰符时，参数列表不可省略(即使参数为空时，也要带上小括号)。mutable 只是让传值捕捉变量const属性去掉了，但是捕捉的a，b仍是拷贝，外部的a，b无法被修改，所以mutable 很少用，意义不大
（4） ->returntype：返回值类型。用 追踪返回类型形式声明函数的返回值类型，没有返回
值时此部分可省略。 返回值类型明确情况下，也可省略，由编译器对返回类型进行推 导。
（5） {statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获
到的变量。
注意：
在lambda函数定义中， 参数列表和返回值类型都是可省略部分，而捕捉列表和函数体可以为
空，但不可省略，因此C++11中 最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。
3.举例
（1）例子1：相加函数
int a = 0, b = 200;
// [capture-list] (parameters) mutable -> return-type { statement }
// 捕捉列表 参数 返回值 函数体
// 一般是局部匿名函数 也可以写到全局
auto Add1 = [](int x, int y)->double {return (x + y) / 3.0; };
auto Add2 = [](int x, int y)->int {return (x + y) / 3.0; };//传参写法
auto Add3 = [a, b] {return (a + b) / 3.0; };//捕捉变量写法
cout << Add1(a, b) << endl;
cout << Add2(a, b) << endl;
cout << Add3() << endl;（2）[ ]捕捉列表 例子2：交换函数
3,4,5,6是几种捕捉方式
1. auto Swap1 = [](int& x, int& y){
int tmp = x;
x = y;
y = tmp;
};
Swap1(a, b);
cout << a << " " << b << endl;
2. mutable 只是让传值捕捉变量const属性去掉了，但是捕捉的a，b仍是拷贝，外部的a，b无法被修改
/*auto Swap2 = [a, b]()mutable{
int tmp = a;
a = b;
b = tmp;
};*/
用引用的方式捕捉:
auto Swap2 = [&a, &b]{
int tmp = a;
a = b;
b = tmp;
};
Swap2();
cout << a << " " << b << endl;
3. int c =2, d=3, e=4, f=5, g=6, ret;
传值捕捉全部对象
auto Func1 = [=]{
return c + d*e / f + g;
};
cout << Func1() << endl;
4. 传引用捕捉全部对象
auto Func2 = [&]{
ret = c + d*e / f + g;
};
Func2();
cout << ret << endl;
5. 混着捕捉
auto Func3 = [c, d, &ret]{
ret = c + d;
};
Func3();
cout << ret << endl;
6. ret传引用捕捉 其他全部传值捕捉
auto Func4 = [=, &ret]{
ret = c + d*e / f + g;
//c = 1;
};
Func4();
cout << ret << endl;仿函数比较，lambda更易懂
（greater是排降序，less是排升序）
比如：仿函数 sort(v.begin(), v.end(), ComparePriceLess()); 可以写成sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._price < g2._price; });
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(evaluate)
{}
};
struct Compare1
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._evaluate < gr._evaluate;
}
};
struct ComparePriceLess
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
struct ComparePriceGreater
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price > gr._price;
}
};
int main()
{
vector v = { Goods( "苹果", 2.1, 5 ), { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
//sort(v.begin(), v.end()); 自定义类型没重载<不能用less或者greater
1.正常用仿函数写sort：
sort(v.begin(), v.end(), Compare1());
sort(v.begin(), v.end(), ComparePriceLess());
sort(v.begin(), v.end(), ComparePriceGreater());
2.用lambda代替仿函数：
（1）常规写法
auto com1 = [](const Goods& g1, const Goods& g2){return g1._price < g2._price; };
sort(v.begin(), v.end(), com1);
（2）匿名对象写法
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._price < g2._price; });
cout << endl;
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._price > g2._price; });
cout << endl;
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._evaluate < g2._evaluate; });
cout << endl;
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){
return g1._evaluate > g2._evaluate; });
cout << endl;
return 0;
} 4.lambda注意点
（1） 父作用域指包含lambda函数的语句块
（2） 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量
[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量
（3） 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复
（4） 在块作用域以外的lambda函数捕捉列表必须为空。
（5） 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者
非局部变量（捕捉 全局变量会报错）都会导致编译报错。
（6） lambda对象之间不能相互赋值，即使看起来类型相同 ，因为每个lambda都会被转换成一个仿函数类型，仿函数类名称lambda+ uuid。（ lambda表达式底层被转换成仿函数）
但是允许使用lambda表达式拷贝构造
也可以将lambda表达式赋值给相同类型的函数指针，了解一下，一般不建议这么用，意义不大
void (*PF)();
int main()
{
auto f1 = [] {cout << "hello world" << endl; };
auto f2 = [] {cout << "hello world" << endl; };
f1 = f2; //错误，lambda对象之间不能相互赋值，编译失败--->提示找不到operator=()
auto f3(f2); //正确，允许使用一个lambda表达式拷贝构造一个新的副本
f3();
// 可以将lambda表达式赋值给相同类型的函数指针，了解一下，一般不建议这么用
PF = f2; //上面有void (*PF)(); PF和f2都是无类型无返回值
PF();
return 0;
}5.底层原理
lambda表达式底层是一个仿函数。每个lambda都会被转换成一个仿函数类型，仿函数类名称lambda+ uuid。uuid是生成的随机不同的字符串，防止冲突
class Rate
{
public:
Rate(double rate) : _rate(rate)
{}
double operator()(double money, int year)
{
return money * _rate * year;
}
private:
double _rate;
};
int main()
{
// 函数对象
double rate = 0.49;
Rate r1(rate);
r1(10000, 2);
// lamber
auto r2 = [=](double monty, int year)->double {return monty * rate * year;};
r2(10000, 2);
return 0;
}仿函数：函数对象，又称为仿函数，即可以像函数一样使用的对象，就是在类中重载了operator()运算符的类对象。
r1就是仿函数，这里调用的是重载的了operator()运算符。lambda底层则是被转换成了一个 类名称叫lambda+ uuid 的仿函数，r2(10000, 2);就是调用了此仿函数的operator()运算符
二.包装器
1.可调用类型对象
1、函数指针
2、仿函数对象
3、lambda
ret = func(x);
// 上面func可能是什么呢？那么func可能是函数名？函数指针？函数对象(仿函数对象)？也有可能
是lamber表达式对象？所以这些都是可调用的类型！如此丰富的类型，可能会导致模板的效率低下！
为什么呢？我们继续往下看。
template
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数名
cout << useF(f, 11.11) << endl;
// 函数对象
cout << useF(Functor(), 11.11) << endl;
// lamber表达式
cout << useF([](double d)->double{ return d / 4; }, 11.11) << endl;
return 0;
} 
通过上面的程序验证，我们会发现useF函数模板实例化了三份。
包装器可以很好的解决上面的问题，下面有“解决 useF问题”
2.function包装器
把对应的可调函数 函数指针/仿函数/lambda 包装起来使用，比如包装lambda：
std::function func5 = [](int a, int b) {return a + b; }; ——包装
cout << func5(100, 200) << endl; ——包装以后直接使用 包装器用途：统一类型，
std::function
第一个int是被调用函数的返回类型，小括号俩int是被调用函数的形参类型，f是要包的那个函数。
template
class function;
模板参数说明：
Ret: 被调用函数的返回类型
Args…：被调用函数的形参
1、函数指针 （传函数名）
2、仿函数对象（传对象）
3、lambda
2、仿函数对象（传对象）
3、lambda
int f(int a, int b)
{
return a + b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
class Plus
{
public:
static int plusi(int a, int b)
{
return a + b;
}
double plusd(double a, double b)
{
return a + b;
}
};
int main()
{
std::function func1 = f;
cout << func1(1, 2) << endl;
std::function func2 = Functor();
cout << func2(10, 20) << endl;
静态成员函数包装可以加&也可以不加（建议都加&）
std::function func3 = &Plus::plusi;
cout << func3(100, 200) << endl;
规定：非静态成员函数包装必须加&，因为有this指针，所以参数多传一个域
std::function func4 = &Plus::plusd;
cout << func4(Plus(), 100.11, 200.11) << endl;//Plus()是匿名对象，有对象才能调函数
std::function func5 = [](int a, int b) {return a + b; };
cout << func5(100, 200) << endl;
return 0;
} 
解决useF问题
解决：包装器，把函数/仿函数/lambda表达式 包装成一个类型，只实例化一份
#include
template
T useF(F f, T x)
{
static int count = 0;
cout << "count:" << ++count << endl;
cout << "count:" << &count << endl;
return f(x);
}
double f(double i)
{
return i / 2;
}
struct Functor
{
double operator()(double d)
{
return d / 3;
}
};
int main()
{
// 函数名
std::function func1 = f;
cout << useF(func1, 11.11) << endl;
// 函数对象
std::function func2 = Functor();
cout << useF(func2, 11.11) << endl;
// lamber表达式
std::function func3 = [](double d)->double{ return d / 4; };
cout << useF(func3, 11.11) << endl;
return 0;
} 
3.包装器改装逆波兰表达式
150. 逆波兰表达式求值
例如：
["4","13","5","/","+"] ，把4,13,5入栈，取到“/”后，13/5=2,2入栈，栈里有：4,2；取到 “+” 后，4+2=6，结果为6
class Solution {
public:
int evalRPN(vector& tokens) {
stack st;
map> opFuncMap={
{"+",[](long long a,long long b){return a+b;}},
{"-",[](long long a,long long b){return a-b;}},
{"*",[](long long a,long long b){return a*b;}},
{"/",[](long long a,long long b){return a/b;}}
};
for(auto& e: tokens)
{
if(opFuncMap.count(e))
{
int right=st.top();
st.pop();
int left=st.top();
st.pop();
st.push(opFuncMap[e](left,right));
}
else
{
st.push(stoll(e));
}
}
return st.top();
}
};
4.bind 绑定
作用：调整可调用对象参数的个数和顺序
// 原型如下：
template
/* unspecified */ bind (Fn&& fn, Args&&... args);
// with return type (2)
template
/* unspecified */ bind (Fn&& fn, Args&&... args);
fn是可调用对象，Args&&... args是参数包
占位对象：_1是显示传的第一个参数，_2是显示传的第二个参数， _1 _2 _3... 表示你要自己传的那些参数，_1表示第一个参数传给_1（_1，_2都属于一个叫placeholders的域）
（可调用类型对象：1、函数指针 2、仿函数对象 3、lambda）
正常情况下面都是传两个参数：
int f(int a, int b)
{
return a - b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
class Plus
{
public:
Plus(int x = 2)
:_x(x)
{}
int plusi(int a, int b)
{
return (a + b)*_x;
}
private:
int _x;
};
int main()
std::function func1 = f;
cout << func1(1, 2) << endl;
std::function func2 = Functor();
cout << func2(10, 20) << endl;
但是非静态的成员函数因为有this，需要传3个参数
// 3个参数
std::function func3 = &Plus::plusi;
cout << func3(Plus(), 100, 200) << endl;
就导致定义map时,map的second类型是两个参数的包装器，则这3个参数的传不进去，只能通过bind解决：
map> opFuncMap =
{
{ "普通函数指针", f },
{ "函数对象", Functor() },
{ "成员函数指针", std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2) }
};
（1）调整可调用对象参数的个数
改成传2个参数的：
2个参数 这里相当于绑定了第一个参数10；1个参数 这里相当于绑定了第一个参数为10，第二个参数为30；
// 2个参数
std::function func4 = std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2);
cout << func4(10,20) << endl;
如果用bind改成传一个参数的：
// 1个参数
std::function func5 = std::bind(&Plus::plusi, Plus(10),
30, placeholders::_1);
cout << func5(200) << endl; （2）调整可调用对象参数的顺序（用处不大）
此时66传给_1，77传给_2，f函数中a接收_2的77，b接收_2的66
int f(int a, int b)
{
return a - b;
}
int main()
{
未调整：
std::function func1 = f;
cout << func1(66, 77) << endl;
调整顺序：
// 调整顺序 -- 用处不大
std::function func6 = std::bind(f, placeholders::_2,
placeholders::_1);
cout << func6(66, 77) << endl;
}
bind总代码：
占位对象：_1是显示传的第一个参数，_2是显示传的第二个参数， _1 _2 _3... 表示你要自己传的那些参数，_1表示第一个参数传给_1
int f(int a, int b)
{
return a - b;
}
struct Functor
{
public:
int operator() (int a, int b)
{
return a + b;
}
};
class Plus
{
public:
Plus(int x = 2)
:_x(x)
{}
int plusi(int a, int b)
{
return (a + b)*_x;
}
private:
int _x;
};
int main()
{
std::function func1 = f;
cout << func1(1, 2) << endl;
std::function func2 = Functor();
cout << func2(10, 20) << endl;
// 3个参数
std::function func3 = &Plus::plusi;
cout << func3(Plus(), 100, 200) << endl;
// 调整可调用对象的参数个数和顺序
// _1 _2 _3... 表示你要自己传的那些参数，_1表示第一个参数传给_1
// 调整个数
// 2个参数
std::function func4 = std::bind(&Plus::plusi, Plus(10),
placeholders::_1, placeholders::_2);
// 1个参数
std::function func5 = std::bind(&Plus::plusi, Plus(10),
10, placeholders::_1);
cout << func5(200) << endl;
// 调整顺序 -- 用处不大
std::function func6 = std::bind(f, placeholders::_2,
placeholders::_1);
cout << func1(66, 77) << endl;
cout << func6(66, 77) << endl;
map> opFuncMap =
{
{ "普通函数指针", f },
{ "函数对象", Functor() },
{ "成员函数指针", std::bind(&Plus::plusi, Plus(10), placeholders::_1, placeholders::_2) }
};
cout << opFuncMap["普通函数指针"](1, 2) << endl;
cout << opFuncMap["函数对象"](1, 2) << endl;
cout << opFuncMap["成员函数指针"](1, 2) << endl;
return 0;
}