【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的拷贝，不影响外部 acout << a << endl;};f();            //  15std::cout << a << endl; //  5return 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; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

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

#include <functional>
int main()
{function<int(int, int)> func;func = [](int a, int b) { return a + b; };cout << func(3, 4) << endl; // 输出 7return 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));}elsest.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