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

前言

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

一、lambda 表达式基础语法

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

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

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

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

各部分含义如下：

部分 含义 [] 捕捉列表（capture list） () 参数列表（与函数类似） -> return_type 返回类型（可省略，自动推导） {} 函数体

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

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

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

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

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

捕获列表

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

捕获方式 语法 说明 值捕捉 [x] 捕获变量 x 的当前值（拷贝） 引用捕捉 [&x] 捕获变量 x 的引用 隐式值捕捉 [=] lambda使用了哪些变量，编译器就会对哪些变量进行值捕捉 隐式引用捕捉 [&] lambda使用了哪些变量，编译器就会对哪些变量进行引用捕捉 混合捕捉 [=, &y] 除 y 外的所有变量为值捕获，y 为引用捕获 混合捕捉 [&, x] 除x外的所有变量为引用捕捉，x为值捕捉

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

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

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

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

mutable 关键字

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

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

---

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 <class T>class function; // undefinedtemplate <class Ret, class... Args>class function<Ret(Args...)>;

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

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

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

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

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

int fun(int a, int b){return a + b;}struct Fun{public:int operator() (int a, int b){return a + b;}};class Plus{public:Plus(int n = 10):_n(n){}static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return (a + b) * _n;}private:int _n;};int main(){function<int(int, int)> f1 = fun;//函数指针function<int(int, int)> f2 = Fun();//仿函数function<int(int, int)> f3 = [](int a, int b) {return a + b; };//lambdacout << 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;return 0;}

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

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

class Solution {public: int evalRPN(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的[]就可以访问到要调用的函数/对象。

class Solution {public: int evalRPN(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 <class Fn, class... Args>bind (Fn&& fn, Args&&... args);with return type (2)template <class Ret, class Fn, class... Args>bind (Fn&& fn, Args&&... args);

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

int Fun(int a, int b){return (a - b) * 10;}int Func(int a, int b, int c){return (a - b - c) * 10;}int main(){//这里_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);return 0;}

调用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