【C++11（下）】—— 我与C++的不解之缘（三十二）

前言

随着 C++11 的引入，现代 C++ 语言在语法层面上变得更加灵活、简洁。其中最受欢迎的新特性之一就是 lambda 表达式（Lambda Expression），它让我们可以在函数内部直接定义匿名函数。配合 std::function 包装器 使用，可以大大提高代码的表达力与可维护性。

一、lambda 表达式基础语法

lambda表达式本质上就是一个匿名函数对象，与普通函数不同的是，它可以定义在函数内部；

一般情况下我们是使用auto或者模版参数定义的对象去接受lambda对象。

lambda表达式本质上是一个可调用对象（函数对象），其语法格式如下：

[capture](parameter_list)-> return_type { function_body };

各部分含义如下：

intmain(){auto add =[](int a,int b)->int{return a + b;}; std::cout <<add(2,3);// 输出：5}

也可以省略 -> int，由编译器自动推导：

intmain(){auto add =[](int a,int b){return a + b;}; std::cout <<add(2,3);// 输出：5}

这里呢，参数列表，如果不需要传参，可以省略，()也可以省略；返回值类型可以省略，让编译器自行推导。

而参数列表和函数体，就算为空，参数列表的[]和函数体的{}也不能省略。

捕获列表

捕获列表决定了 Lambda 表达式如何访问其所在作用域的变量。

intmain(){int x =10, y =20;auto f1 =[=](){return x + y;};// 值捕获auto f2 =[&](){ x += y;};// 引用捕获，修改外部变量auto f3 =[x,&y](){ y += x;};// 混合捕获return0;}

这里lambda表达式如果在函数局部域中，它可以捕捉lambda位置之前定义的变量，但是不能捕捉静态局部变量和全局变量（静态局部变量和全局变量也不需要捕捉，lambda表达式中也可以直接使用）。

如果lambda定义在全局，那捕捉列表必须为空

值捕获的变量在 Lambda 中是“只读”的，不能修改，除非加上 mutable。

mutable 关键字

默认情况下，lambda捕捉列表的值是被const修饰的，值捕获的变量不能在 Lambda 中被修改。要想修改值捕获的副本，可以使用 mutable：

intmain(){int a =5;auto f =[a]()mutable{ a +=10;// 修改的是a的拷贝，不影响外部 a cout << a << endl;};f();// 15 std::cout << a << endl;// 5return0;}

lambda 的实际应用场景

与 STL 算法结合

std::vector<int> vec ={1,2,3,4,5}; std::for_each(vec.begin(), vec.end(),[](int x){ std::cout << x <<" ";});

条件查找

auto it = std::find_if(vec.begin(), vec.end(),[](int x){return x >3;});if(it != vec.end()) std::cout <<*it;// 输出 4

排序自定义规则

std::sort(vec.begin(), vec.end(),[](int a,int b){return a > b;// 降序});

lambda的原理

lambda的原理和范围for非常相似，编译之后从汇编的角度来看，我们就要发现根本就没有lambda和范围for；

范围for的底层是迭代器，而lambda的底层是仿函数对象，简单来说我们写了一个lambda，编译器就会生成一对应的仿函数。

而仿函数的类名是编译器按照一定的规则生产的，保证不同的lambda生成的仿函数不同。lambda的参数/返回值/函数体就是仿函数operator()的参数/返回类型/函数体lambda捕捉列表的本质是生成的仿函数的成员变量。

简单来说就是捕捉列表的量都是lambda类构造函数的实参；

这样就很好解释值捕捉和引用捕捉了：

值捕捉：lambda生成的仿函数的成员就是对捕捉变量的值拷贝。引用捕捉：lambda生成的仿函数的成员就是对捕捉变量的引用。

而也支持隐式捕捉，这个就是编译器看需要用哪些对象，就传哪些对象（用多少捕捉多少）。

二、包装器

function

function是一个类模板，也是一个包装器。std::function的实例化对象可以包装存储其它可以调用的对象：包括函数指针、仿函数、lambda、bind表达式；

其中存储的对象被称为std::function的目标；如果std::function不含目标，那它为空（调用空目标导致抛出std::bad_function_call异常。

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

以上是 function 的原型，他被定义头⽂件中

#include<functional>intmain(){ function<int(int,int)> func; func =[](int a,int b){return a + b;}; cout <<func(3,4)<< endl;// 输出 7return0;}

function 的优势在于统一函数接口、做函数回调或作为参数传递。

函数指针、仿函数、lambda这些可以调用的对象的类型各不相同，std::function的优势就在于统一类型；

只要它们返回值，参数都相同，function就能对它们进行包装；这样在很多的地方就可以声明这些可调用对象的类型；

intfun(int a,int b){return a + b;}structFun{public:intoperator()(int a,int b){return a + b;}};classPlus{public:Plus(int n =10):_n(n){}staticintplusi(int a,int b){return a + b;}doubleplusd(double a,double b){return(a + b)* _n;}private:int _n;};intmain(){ function<int(int,int)> f1 = fun;//函数指针 function<int(int,int)> f2 =Fun();//仿函数 function<int(int,int)> f3 =[](int a,int b){return a + b;};//lambda 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包装后需要传对象或者对象的指针过去才能进行调用 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; 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;}

这里再来看一道可以使用function包装优化的题目

150. 逆波兰表达式求值 - 力扣（LeetCode）

classSolution{public:intevalRPN(vector<string>& tokens){ stack<int> st;for(auto& e:tokens){if(e =="+"||e =="-"|| e =="*"|| e =="/"){int right = st.top(); st.pop();int left = st.top(); st.pop();switch(e[0]){case'+': st.push(left + right);break;case'-': st.push(left - right);break;case'*': st.push(left * right);break;case'/': st.push(left / right);break;}}else{ st.push(stoi(e));}}return st.top();}};

这道题，向上述这样写，特别难受好吧，我们可以使用function进行优化：

我们知道+、-、*、/运算它返回值和参数类型都是相同的，那我们不妨将其包装起来；

然后使用map存储运算符和对应的函数/调用对象

这样直接使用map的[]就可以访问到要调用的函数/对象。

classSolution{public:intevalRPN(vector<string>& tokens){ stack<int> st; map<string,function<int(int,int)>> mp ={{"+",[](int x,int y){return x+y;}},{"-",[](int x,int y){return x-y;}},{"*",[](int x,int y){return x*y;}},{"/",[](int x,int y){return x/y;}}};for(auto& e:tokens){if(mp.count(e))//mp中存在就代表是操作符{int right = st.top(); st.pop();int left = st.top(); st.pop(); st.push(mp[e](left,right));}else st.push(stoi(e));}return st.top();}};

这样我们代码看起来简洁了好多，用起来也很方便；

如果再多几个运算符，我们只需要在mp再新增即可。

从这个角度来看：lambda算是统一了那些可调用对象的类型，这样对于可调用对象（函数指针、仿函数、lambda），只要参数和返回值相同，那我们就可以使用function包装起来，方便调用。

bind 与占位符

simple(1)template<classFn,class... Args>bind(Fn&& fn, Args&&... args); with returntype(2)template<classRet,classFn,class... Args>bind(Fn&& fn, Args&&... args);

bind是一个函数模版，它也是一个可调用对象的包装器；简单来说它就是一个函数适配器，可以对接受的Fn可调用对象进行处理后返回一个可调用对象。bind可以用来调整参数个数和参数的顺序。bind也在这个头文件中。

intFun(int a,int b){return(a - b)*10;}intFunc(int a,int b,int c){return(a - b - c)*10;}intmain(){//这里_1始终指接受第一个实参//_2指接受第二个实参auto fun1 =bind(Fun, _1, _2); cout <<fun1(10,5)<< endl;//fun1(10,5) -> Fun(10,5)auto Fun2 =bind(Fun, _2, _1); cout <<Fun2(10,5)<< endl;//fun2(10,5) -> Fun(5,10)auto fun3 =bind(Fun,100, _1); cout <<fun3(5)<< endl;//fun3(5) -> Fun(100,5)auto fun4 =bind(Fun, _1,100); cout <<fun4(5)<< endl;//fun4(5) -> Fun(5,100)auto fun5 =bind(Func,100, _1, _2); cout <<fun5(5,1)<< endl;//fun5(5,1) -> Func(100,5,1)auto fun6 =bind(Func, _1,100, _2); cout <<fun6(5,1)<< endl;//fun6(5,1) -> Func(5,100,1)auto fun7 =bind(Func, _1, _2,100); cout <<fun7(5,1)<< endl;//fun7(5,1) -> Func(5,1,100);return0;}

调用bind：auto newCallable = bind(callable, arg_list)（这里newCallable本身就是一个可调用对象，arg_list是参数列表，对应给定的callable的参数（也是可调用对象）

这样我们调用newCallable，newCallable就会调用callable，并传给它arg_list中的参数。

当我们使用function去包装类的非静态成员函数时，我们在调用时总是需要传该类型的对象或者该类型对象的指针，来完成调用；

这样的设计好难看，我每一次调用还要创建一个该类型的对象，那我还不如直接去调用呢

 function<double(Plus&&,double,double)> f1 =&Plus::plusd; Plus pd; cout <<f1(move(pd),1.1,1.1)<< endl; cout <<f1(Plus(),1.1,1.1)<< endl;

而bind这个绑定，我们可以同来绑定一些固定的参数；

就比如这里需要传递该类类型的对象或者该类型对象的指针，我们使用bind绑定，直接锁死这个参数，那这样在调用时就不用显示传递了。

 function<double(double,double)> f2 =bind(&Plus::plusd,Plus(), _1, _2); cout <<f2(1.1,1.1)<< endl;

到这里本篇文章内容就结束了
感谢各位的支持

我的博客即将同步至腾讯云开发者社区，邀请大家一同入驻：https://cloud.tencent.com/developer/support-plan?invite_code=2oul0hvapjsws