1lambda

1.1lambda表达式语法

• lambda 表达式本质是⼀个匿名函数对象，跟普通函数不同的是他可以定义在函数内部。
lambda 表达式语法使⽤层⽽⾔没有类型，所以我们⼀般是⽤auto或者模板参数定义的对象去接收 lambda 对象。
• lambda表达式的格式： [capture-list] (parameters)-> return type {
function boby }
• [capture-list] :捕捉列表，该列表总是出现在 lambda 函数的开始位置，编译器根据[]来
判断接下来的代码是否为 lambda 函数，捕捉列表能够捕捉上下⽂中的变量供 lambda 函数使⽤，捕捉列表可以传值和传引⽤捕捉，具体细节7.2中我们再细讲。捕捉列表为空也不能省略。
• (parameters) ：参数列表，与普通函数的参数列表功能类似，如果不需要参数传递，则可以连同()⼀起省略
• ->return type ：返回值类型，⽤追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。⼀般返回值类型明确情况下，也可省略，由编译器对返回类型进⾏推导。
• {function boby} ：函数体，函数体内的实现跟普通函数完全类似，在该函数体内，除了可以使⽤其参数外，还可以使⽤所有捕获到的变量，函数体为空也不能省略。

intmain(){// ⼀个简单的lambda表达式autoadd1=[](intx,inty)->int{returnx+y;};cout<<add1(1,2)<<endl;// 1、捕捉为空也不能省略// 2、参数为空可以省略// 3、返回值可以省略，可以通过返回对象⾃动推导// 4、函数题不能省略autofunc1=[]{cout<<"hello bit"<<endl;return0;};func1();inta=0,b=1;autoswap1=[](int&x,int&y){inttmp=x;x=y;y=tmp;};swap1(a,b);cout<<a<<":"<<b<<endl;return0;}

1.2捕捉列表

• lambda 表达式中默认只能⽤ lambda 函数体和参数中的变量，如果想⽤外层作⽤域中的变量就需要进⾏捕捉
• 第⼀种捕捉⽅式是在捕捉列表中显⽰的传值捕捉和传引⽤捕捉，捕捉的多个变量⽤逗号分割。[x，y，&z]表⽰x和y值捕捉，z引⽤捕捉。
• 第⼆种捕捉⽅式是在捕捉列表中隐式捕捉，我们在捕捉列表写⼀个=表⽰隐式值捕捉，在捕捉列表写⼀个&表⽰隐式引⽤捕捉，这样我们 lambda 表达式中⽤了那些变量，编译器就会⾃动捕捉那些变量。
• 第三种捕捉⽅式是在捕捉列表中混合使⽤隐式捕捉和显⽰捕捉。[=,&x]表⽰其他变量隐式值捕捉，x引⽤捕捉；[&,x,y]表⽰其他变量引⽤捕捉，x和y值捕捉。当使⽤混合捕捉时，第⼀个元素必须是&或=，并且&混合捕捉时，后⾯的捕捉变量必须是值捕捉，同理=混合捕捉时，后⾯的捕捉变量必须是引⽤捕捉。
• lambda 表达式如果在函数局部域中，他可以捕捉 lambda 位置之前定义的变量，不能捕捉静态局部变量和全局变量，静态局部变量和全局变量也不需要捕捉， lambda 表达式中可以直接使⽤。这也意味着 lambda 表达式如果定义在全局位置，捕捉列表必须为空。
• 默认情况下， lambda 捕捉列表是被const修饰的，也就是说传值捕捉的过来的对象不能修改，mutable加在参数列表的后⾯可以取消其常量性，也就说使⽤该修饰符后，传值捕捉的对象就可以修改了，但是修改还是形参对象，不会影响实参。使⽤该修饰符后，参数列表不可省略(即使参数为空)。

2包装器

2.1 function

intx=0;// 捕捉列表必须为空，因为全局变量不⽤捕捉就可以⽤，没有可被捕捉的变量autofunc1=[](){x++;};intmain(){// 只能⽤当前lambda局部域和捕捉的对象和全局对象inta=0,b=1,c=2,d=3;autofunc1=[a,&b]{// 值捕捉的变量不能修改，引⽤捕捉的变量可以修改//a++;b++;intret=a+b;returnret;};cout<<func1()<<endl;// 隐式值捕捉// ⽤了哪些变量就捕捉哪些变量autofunc2=[=]{intret=a+b+c;returnret;};cout<<func2()<<endl;// 隐式引⽤捕捉// ⽤了哪些变量就捕捉哪些变量autofunc3=[&]{a++;c++;d++;};func3();cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;// 混合捕捉1autofunc4=[&,a,b]{//a++;//b++;c++;d++;returna+b+c+d;};func4();cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;// 混合捕捉1autofunc5=[=,&a,&b]{a++;b++;/*c++; d++;*/returna+b+c+d;};func5();cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;// 局部的静态和全局变量不能捕捉，也不需要捕捉staticintm=0;autofunc6=[]{intret=x+m;returnret;};// 传值捕捉本质是⼀种拷⻉,并且被const修饰了// mutable相当于去掉const属性，可以修改了// 但是修改了不会影响外⾯被捕捉的值，因为是⼀种拷⻉autofunc7=[=]()mutable{a++;b++;c++;d++;returna+b+c+d;};cout<<func7()<<endl;cout<<a<<" "<<b<<" "<<c<<" "<<d<<endl;return0;}

1.3 lambda的应⽤

• 在学习 lambda 表达式之前，我们的使⽤的可调⽤对象只有函数指针和仿函数对象，函数指针的类型定义起来⽐较麻烦，仿函数要定义⼀个类，相对会⽐较麻烦。使⽤ lambda 去定义可调⽤对象，既简单⼜⽅便。
• lambda 在很多其他地⽅⽤起来也很好⽤。⽐如线程中定义线程的执⾏函数逻辑，智能指针中定制删除器等， lambda 的应⽤还是很⼴泛的，以后我们会不断接触到。

structGoods{string _name;// 名字double_price;// 价格int_evaluate;// 评价// ...Goods(constchar*str,doubleprice,intevaluate):_name(str),_price(price),_evaluate(evaluate){}};structComparePriceLess{booloperator()(constGoods&gl,constGoods&gr){returngl._price<gr._price;}};structComparePriceGreater{booloperator()(constGoods&gl,constGoods&gr){returngl._price>gr._price;}};intmain(){vector<Goods>v={{"苹果",2.1,5},{"⾹蕉",3,4},{"橙⼦",2.2,3},{"菠萝",1.5,4}};// 类似这样的场景，我们实现仿函数对象或者函数指针⽀持商品中// 不同项的⽐较，相对还是⽐较⿇烦的，那么这⾥lambda就很好⽤了sort(v.begin(),v.end(),ComparePriceLess());sort(v.begin(),v.end(),ComparePriceGreater());sort(v.begin(),v.end(),[](constGoods&g1,constGoods&g2){returng1._price<g2._price;});sort(v.begin(),v.end(),[](constGoods&g1,constGoods&g2){returng1._price>g2._price;});sort(v.begin(),v.end(),[](constGoods&g1,constGoods&g2){returng1._evaluate<g2._evaluate;});sort(v.begin(),v.end(),[](constGoods&g1,constGoods&g2){returng1._evaluate>g2._evaluate;});return0;}

1.4 lambda的原理

• lambda 的原理和范围for很像，编译后从汇编指令层的⻆度看，压根就没有 lambda 和范围for这样的东西。范围for底层是迭代器，⽽lambda底层是仿函数对象，也就说我们写了⼀个lambda 以后，编译器会⽣成⼀个对应的仿函数的类。
• 仿函数的类名是编译按⼀定规则⽣成的，保证不同的 lambda ⽣成的类名不同，lambda参数/返回类型/函数体就是仿函数operator()的参数/返回类型/函数体， lambda 的捕捉列表本质是⽣成的仿函数类的成员变量，也就是说捕捉列表的变量都是 lambda 类构造函数的实参，当然隐式捕捉，编译器要看使⽤哪些就传那些对象。

2. 包装器

2.1 function

template<classT>classfunction;// undefinedtemplate<classRet,class...Args>classfunction<Ret(Args...)>;

• std::function 是⼀个类模板，也是⼀个包装器。 std::function 的实例对象可以包装存
储其他的可以调⽤对象，包括函数指针、仿函数、 lambda 、 bind 表达式等，存储的可调⽤对象被称为 std::function 的⽬标 。若 std::function 不含⽬标，则称它为 空 。调⽤空
std::function 的 ⽬标 导致抛出std::bad_function_call异常。
• 以上是 function 的原型，他被定义头⽂件中。std::function-cppreference.com
是function的官⽅⽂件链接。
• 函数指针、仿函数、 lambda 等可调⽤对象的类型各不相同， std::function 的优势就是统
⼀类型，对他们都可以进⾏包装，这样在很多地⽅就⽅便声明可调⽤对象的类型，下⾯的第⼆个代码样例展⽰了 std::function 作为map的参数，实现字符串和可调⽤对象的映射表功能。

include<functional>intf(inta,intb){returna+b;}structFunctor{public:intoperator()(inta,intb){returna+b;}};classPlus{public:Plus(intn=10):_n(n){}staticintplusi(inta,intb){returna+b;}doubleplusd(doublea,doubleb){return(a+b)*_n;}private:int_n;};intmain(){// 包装各种可调⽤对象function<int(int,int)>f1=f;function<int(int,int)>f2=Functor();function<int(int,int)>f3=[](inta,intb){returna+b;};cout<<f1(1,1)<<endl;cout<<f2(1,1)<<endl;cout<<f3(1,1)<<endl;// 包装静态成员函数// 成员函数要指定类域并且前⾯加&才能获取地址function<int(int,int)>f4=&Plus::plusi;cout<<f4(1,1)<<endl;// 包装普通成员函数// 普通成员函数还有⼀个隐含的this指针参数，所以绑定时传对象或者对象的指针过去都可以function<double(Plus*,double,double)>f5=&Plus::plusd;Plus pd;cout<<f5(&pd,1.1,1.1)<<endl;function<double(Plus,double,double)>f6=&Plus::plusd;cout<<f6(pd,1.1,1.1)<<endl;cout<<f6(pd,1.1,1.1)<<endl;function<double(Plus&&,double,double)>f7=&Plus::plusd;cout<<f7(move(pd),1.1,1.1)<<endl;cout<<f7(Plus(),1.1,1.1)<<endl;return0;}

2.2 bind

simple(1)template<classFn,class...Args>/* unspecified */bind(Fn&&fn,Args&&...args);withreturntype(2)template<classRet,classFn,class...Args>/* unspecified */bind(Fn&&fn,Args&&...args);

• bind 是⼀个函数模板，它也是⼀个可调⽤对象的包装器，可以把他看做⼀个函数适配器，对接收的fn可调⽤对象进⾏处理后返回⼀个可调⽤对象。 bind 可以⽤来调整参数个数和参数顺序。
bind 也在这个头⽂件中。
• 调⽤bind的⼀般形式： auto newCallable = bind(callable,arg_list); 其中newCallable本⾝是⼀个可调⽤对象，arg_list是⼀个逗号分隔的参数列表，对应给定的callable的
参数。当我们调⽤newCallable时，newCallable会调⽤callable，并传给它arg_list中的参数。
• arg_list中的参数可能包含形如_n的名字，其中n是⼀个整数，这些参数是占位符，表⽰
newCallable的参数，它们占据了传递给newCallable的参数的位置。数值n表⽰⽣成的可调⽤对象中参数的位置：_1为newCallable的第⼀个参数，_2为第⼆个参数，以此类推。_1/_2/_3…这些占位符放到placeholders的⼀个命名空间中。

#include<functional>usingplaceholders::_1;usingplaceholders::_2;usingplaceholders::_3;intSub(inta,intb){return(a-b)*10;}intSubX(inta,intb,intc){return(a-b-c)*10;}classPlus{public:staticintplusi(inta,intb){returna+b;}doubleplusd(doublea,doubleb){returna+b;}};intmain(){autosub1=bind(Sub,_1,_2);cout<<sub1(10,5)<<endl;// bind 本质返回的⼀个仿函数对象// 调整参数顺序（不常⽤）// _1代表第⼀个实参// _2代表第⼆个实参// ...autosub2=bind(Sub,_2,_1);cout<<sub2(10,5)<<endl;// 调整参数个数 （常⽤）autosub3=bind(Sub,100,_1);cout<<sub3(5)<<endl;autosub4=bind(Sub,_1,100);cout<<sub4(5)<<endl;// 分别绑死第123个参数autosub5=bind(SubX,100,_1,_2);cout<<sub5(5,1)<<endl;autosub6=bind(SubX,_1,100,_2);cout<<sub6(5,1)<<endl;autosub7=bind(SubX,_1,_2,100);cout<<sub7(5,1)<<endl;// 成员函数对象进⾏绑死，就不需要每次都传递了function<double(Plus&&,double,double)>f6=&Plus::plusd;Plus pd;cout<<f6(move(pd),1.1,1.1)<<endl;cout<<f6(Plus(),1.1,1.1)<<endl;// bind⼀般⽤于，绑死⼀些固定参数function<double(double,double)>f7=bind(&Plus::plusd,Plus(),_1,_2);cout<<f7(1.1,1.1)<<endl;// 计算复利的lambdaautofunc1=[](doublerate,doublemoney,intyear)->double{doubleret=money;for(inti=0;i<year;i++){ret+=ret*rate;}returnret-money;};// 绑死⼀些参数，实现出⽀持不同年华利率，不同⾦额和不同年份计算出复利的结算利息function<double(double)>func3_1_5=bind(func1,0.015,_1,3);function<double(double)>func5_1_5=bind(func1,0.015,_1,5);function<double(double)>func10_2_5=bind(func1,0.025,_1,10);function<double(double)>func20_3_5=bind(func1,0.035,_1,30);cout<<func3_1_5(1000000)<<endl;cout<<func5_1_5(1000000)<<endl;cout<<func10_2_5(1000000)<<endl;cout<<func20_3_5(1000000)<<endl;return0;}