前情回顾:
C++11出现与历史、花括号统一初始化、initializer_list初始化列表、 auto、decltype、nullptr、STL的一些新变化
右值引用和移动语义∶移动构造和移动赋值、move 函数、左值引用的短板、万能引用、完美转发、push_back 函数重载右值引用版本(借助list的push-back 使用举例)﹔新增两个默认类函数与delete关键字
可变参数模板:参数包的用法、参数包展开的几种方法;
emplace_back 函数:为什么该函数会比 push_back 高效
⭐⭐本文会使用到自己模拟实现的 string 和 list 类,为了更好的观察各种函数的构造过程,建议先将本文最后的 string 和 list 代码拷贝下来创建一个 string.h / list.h 文件
11 lambda表达式
11.1 C++98 中的一个例子
在 C++98 中,如果想要对一个数据集合中的元素进行排序,可以使用函数模板 std::sort方法。
#include <algorithm>
#include <functional>
int main()
{
int array[] = { 4,1,8,5,3,7,0,9,2,6 };
// 默认按照小于比较,排出来结果是升序
std::sort(array, array + sizeof(array) / sizeof(array[0]));
// 如果需要降序,需要改变元素的比较规则
std::sort(array, array + sizeof(array) / sizeof(array[0]), greater<int>());
return 0;
}
如果待排序元素为自定义类型,需要用户定义排序时的比较规则:
#include<algorithm>
struct Goods
{
string _name; // 名字
double _price; // 价格
int _evaluate; // 评价
Goods(const char* str, double price, int evaluate)
:_name(str)
, _price(price)
, _evaluate(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<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
sort(v.begin(), v.end(), ComparePriceLess()); // 按价格升序
sort(v.begin(), v.end(), ComparePriceGreater()); // 按价格降序
}
随着 C++ 语法的发展,人们开始觉得上面的写法太复杂了,每次为了实现一个algorithm算法,
都要重新去写一个类,如果每次比较的逻辑不一样,还要去实现多个类,特别是相同类的命名,
这些都给编程者带来了极大的不便。因此,在C++11语法中出现了Lambda表达式。
11.2 lambda表达式
使用 lambda 表达式后的 sort:想要按照什么排序,直接自定义,也无需多写一个结构体
int main()
{
vector<Goods> v = { { "苹果", 2.1, 5 }, { "香蕉", 3, 4 }, { "橙子", 2.2, 3 }, { "菠萝", 1.5, 4 } };
// 想要按照什么排序,直接自定义,也无需多写一个结构体
// 价格升序
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price < g2._price;
});
// 价格降序
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._price > g2._price;
});
// 评价分数升序
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate < g2._evaluate;
});
// 评价分数降序
sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2) {
return g1._evaluate > g2._evaluate;
});
}
上述代码就是使用C++11中的lambda表达式来解决,可以看出lambda表达式实际是一个匿名函
数。
11.3 lambda表达式使用语法
lambda表达式书写格式:[capture-list] (parameters) mutable -> return-type { statement }
1. lambda表达式各部分说明
⭐[capture-list] : 捕捉列表,该列表总是出现在 lambda 函数的开始位置,编译器根据[]
来判断接下来的代码是否为lambda函数,捕捉列表能够捕捉上下文中的变量供 lambda
函数使用。
⭐(parameters):参数列表。与普通函数的参数列表一致,如果不需要参数传递,则可以
连同()一起省略
⭐mutable:默认情况下,lambda函数总是一个const函数,mutable可以取消其常量性。
使用该修饰符时,参数列表不可省略(即使参数为空)。
⭐->return-type:返回值类型。用追踪返回类型形式声明函数的返回值类型,没有返回
值时此部分可省略。返回值类型明确情况下,也可省略,由编译器对返回类型进行推导。
⭐{statement}:函数体。在该函数体内,除了可以使用其参数外,还可以使用所有捕获
到的变量。
举个例子:
借助一个仿函数写出一个 lambda表达式
注意:
在 lambda 函数定义中,借助一个函数来理解和讲解:
因为一个函数可以没有 函数参数 和 返回值(即void),因此也可以省略不写
(注意:lambda 表达式的返回值它会自动识别,因此返回值可写可不写,为了可读性,建议写)
方括号的那个 捕捉列表必须写出方括号,至于这个怎么用,下面会讲解
因此C++11中最简单的lambda函数为下面这样,该lambda函数不能做任何事情。
[]() {
//....
};
各种结构的 lambda表达式
int main()
{
// 最简单的lambda表达式, 该lambda表达式没有任何意义
[] {};
// 省略参数列表和返回值类型,返回值类型由编译器推导为int
int a = 3, b = 4;
[=] {return a + 3; };
// 省略了返回值类型,无返回值类型
auto fun1 = [&](int c) {b = a + c; };
fun1(10)
cout << a << " " << b << endl;
// 各部分都很完善的lambda函数
auto fun2 = [=, &b](int c)->int {return b += a + c; };
cout << fun2(10) << endl;
// 复制捕捉x
int x = 10;
auto add_x = [x](int a) mutable { x *= 2; return a + x; };
cout << add_x(10) << endl;
return 0;
}
通过上述例子可以看出,lambda 表达式实际上可以理解为无名函数,或者理解成 匿名函数
(和匿名对象类似)该函数无法直接调用,如果想要直接调用,可借助 auto 将其赋值给一个
变量。
2. 捕捉列表说明
捕捉列表描述了上下文中哪些数据可以被 lambda 使用,以及使用的方式传值还是传引用
(通俗讲,lambda只能使用捕捉列表、lambda域 和 全局域的数据,若想要使用外部的局部域的变量,可以使用 捕捉列表 捕捉进来使用)
[var]:表示值传递方式捕捉变量 var
[=]:表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]:表示引用传递捕捉变量 var
[&]:表示引用传递捕捉所有父作用域中的变量(包括this)
[this]:表示值传递方式捕捉当前的this指针
注意:
a. 父作用域指 包含 lambda 函数的语句块
b. 语法上捕捉列表可由多个捕捉项组成,并以逗号分割。
比如:[=, &a, &b]:以引用传递的方式捕捉变量a和b,值传递方式捕捉其他所有变量
[&,a, this]:值传递方式捕捉变量a和this,引用方式捕捉其他变量
c. 捕捉列表不允许变量重复传递,否则就会导致编译错误。
比如:[=, a]:=已经以值传递方式捕捉了所有变量,捕捉a重复
演示:
(1)演示 lambda表达式的 哪些数据可以被使用 以及 传值和传引用
int main() {
// 1、lambda 表达式中只能使用 当前 lambda 局部域 和 捕捉的对象
int a = 0, b = 1;
auto swap1 = [](int& x, int& y) {
// x = a; // 报错:a 存在父作用域,即外面的main函数局部域中的变量,不属于 lambda 局部域 和 捕捉的对象,因此不能使用
int tmp = x;
x = y;
y = tmp;
};
swap1(a, b);
// 2、使用捕捉列表捕捉想要使用的变量:[a, b]
// 捕捉 a 和 b,这里没有传参,而是专门对 a 和 b 进行操作
// 其次,捕捉的变量,默认为 const 类型,要加上 mutable ,表示去除 const 常性
// 传值:lambda表达式中的 a 和 b,本质是外面的 a 和 b 临时拷贝,相当于函数传形参,对形参的 a 和 b 操作不会影响外面的 a 和 b,因此 这里交换操作实际上没有进行
auto swap2 = [a, b]()mutable {
int tmp = a;
a = b;
b = tmp;
};
swap2();
// 传引用:取别名,相当函数传实参
// 这里就不用写 mutable 了,mutable 是为了解除参数的常性,引用本就不是常性
auto swap3 = [&a, &b] {
int tmp = a;
a = b;
b = tmp;
};
swap3();
return 0;
}
(2)演示 [data]、[=]、[&data]、[&] 的使用 即 混合搭配使用
int x = 0; // 全局变量
int main()
{
// 只能用当前lambda局部域和捕捉的对象和全局对象
int a = 0, b = 1, c = 2, d = 3;
// 1、所有值传值捕捉
// 将外面区域中所有变量,以传值的方式 捕捉
auto func1 = [=]{
int ret = a + b + c + d + x; // x 是全局的
return ret;
};
// 2、所有值传引用捕捉
// 将外面区域中所有变量,以传引用的方式 捕捉
auto func2 = [&]{
a++;
b++;
c++;
d++;
int ret = a + b + c + d;
return ret;
};
// 3、混合捕捉:可以自己根据需求搭配
// 变量b 以传值捕捉,其他的所有变量 传引用捕捉
auto func3 = [&a, b]{
a++;
// b++;
int ret = a + b;
return ret;
};
// 所有值以传引用方式捕捉,d用传值捕捉
auto func4 = [&, d]{
a++;
b++;
c++;
//d++;
int ret = a + b + c + d;
};
// 所有值以传值方式捕捉,d用传引用捕捉
auto func5 = [=, &d]() mutable{
a++;
b++;
c++;
d++;
int ret = a + b + c + d;
};
return 0;
}
(3)【总结与本质】捕捉列表的运用
lambda 只能使用 当前 lambda 局部域 和 捕捉的对象 以及 全局域的
如下不能使用 外面的 main 函数局部变量
一般不会使用 mutable,容易使程序具有误导性
如果要修改外面的变量,直接传引用 [&]、[&a, &b]
如果不要修改,直接传值 [=]、[a, b]
如果针对某个变量,直接其他的传值,a 传引用 或 其他的传引用,a 传值 [=, &a] 或 [&, a]
本质:
只有 lambda 表达式里面用到的变量,会被传进来,不会因为使用 [=] 或 [&] 而把所有变量都传进来(编译器提高效率的技巧)
捕捉列表的对象是作为成员变量存在 lambda 类对象中
捕捉的本质是构造函数的初始化参数
11.4 lambda表达式的底层
(1)底层其实就是仿函数
汇编层面看,底部都调用了 类中的 operator() ,即仿函数
函数对象,又称为仿函数,即可以想函数一样使用的对象,就是在类中重载了operator()运算符的
类对象。
lambda表达式其实底层就是一个 函数对象
在底层编译器对于lambda表达式的处理方式,完全就是按照函数对象的方式处理的,即:如
果定义了一个lambda表达式,编译器会自动生成一个类,在该类中重载了operator()。
struct Goods
{
string _name; // 名字
double _price; // 价格
Goods(const char* str, double price)
:_name(str)
, _price(price)
{}
};
struct ComparePriceLess
{
bool operator()(const Goods& gl, const Goods& gr)
{
return gl._price < gr._price;
}
};
int main() {
Goods g[] = { {"apple", 11}, {"pear", 9} };
// 仿函数
ComparePriceLess cmp;
cmp(g[0], g[1]);
// Lambda 表达式
auto priceLess = [&](const Goods& gl, const Goods& gr) {
return gl._price < gr._price;
};
priceLess(g[0], g[1]);
return 0;
}
(2)每个lambda 表达式都是唯一的
每个 lambda 表达式都有自己唯一的名字(即带有一个很长的字符串 uuid 码)
即使内容完全相同,也是唯一的
因此:lambda表达式之间不能相互赋值,即使看起来类型相同
UUID 是 通用唯一识别码(Universally Unique Identifier)的缩写
相当于每一个 lambda 表达式有自己的身份证号
int main() {
// Lambda 表达式
int x = 1, y = 2;
auto L1 = [&](const int& a, const int& b) {
return a < b;
};
L1(x, y);
// Lambda 表达式
auto L2 = [&](const int& a, const int& b) {
return a < b;
};
L2(x, y);
}
12 包装器
12.1 function 包装器
(1)概念与具体实操使用(借助 游戏运行 与 LeetCode 题目 讲解用法)
function包装器 也叫作适配器。C++中的 function 本质是一个类模板,也是一个包装器。
那么我们来看看,我们为什么需要function呢?
可调用类型对象都可以使用 function 包装
可调用类型对象包括:函数名(函数指针)、函数对象(仿函数对象)、lamber表达式对象
function 包装可调用对象的 写法:
参数列表:括号外面的 int 对应可调用对象的返回值类型,括号里面的 int 则一一对应可调用对象参数的 类型(按顺序写)
#include <functional>
size_t Function(const size_t& a, const size_t& b) {
return a + b;
}
struct Functor
{
size_t operator()(const size_t& a, const size_t& b) {
return a + b;
}
};
int main() {
// 将可调用对象包装在一个 包装器中
function<int(int, int)> f1 = Function; // 函数指针:普通函数名就是函数指针,成员函数需要取地址&
function<int(int, int)> f2 = Functor(); // 函数对象:仿函数对象
function<int(int, int)> f3 = [](const size_t& a, const size_t& b)->int { // lambda 表达式
return a + b;
};
int x = 10, y = 20;
cout << f1(x, y) << '\n';
cout << f2(x, y) << '\n';
cout << f3(x, y) << '\n';
return 0;
}
包装器,将 一个可调用的功能接口 包装成一个 模块,直接需要时调用该模块即可,相当于工具包,你无需知道这个工具的具体实现逻辑(即无需像使用 lambda表达式,需要重新写一遍),直接可以拿来用,还是很方便的!
举个例子,像是王者荣耀操作英雄,每个英雄有几个技能,当你键盘或手指点击某个技能,则底层就会对应向系统发送某个指令,调用该技能 运行展示的函数,如 亚瑟一技能是强化普攻和加速追踪,若按键按下,响应了就会向系统发送某个 字符指令,系统就调用这个技能 的运行模块,使英雄具有这个效果展示
这其中展示出一种,命令与相关功能相互映射的关系,命令发出,则调用该命令映射的功能模块
我们以具体例题讲解:
像是 LeetCode 150. 逆波兰表达式求值 中每种运算符,对应一种计算逻辑,我们就可以将 运算符 和 计算逻辑 形成映射关系,需要该使用运算符,就调用对应的功能
题目:
写法思路是:遍历字符串数组,遇到数字放进栈,遇到运算符 取出栈顶的两个数字出来计算结果,结果再放回去,最后遍历完成后,栈中的最后一个数字即为 最终结果
下面是两种代码写法:
一般代码写法是:
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<long long>stk;
long long a, b;
long long result;
for (int i = 0; i < tokens.size(); ++i) {
if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/")
{
a = stk.top(); stk.pop();
b = stk.top(); stk.pop();
// 注意是先b后a:和数值放入栈的顺序有关
if (tokens[i] == "+") stk.push(b + a);
if (tokens[i] == "-") stk.push(b - a);
if (tokens[i] == "*") stk.push(b * a);
if (tokens[i] == "/") stk.push(b / a);
}
else {
stk.push(stoll(tokens[i]));
}
}
long long ans = stk.top();
return ans;
}
};
使用 function 包装器的写法:
将各个运算符 及其 对应功能 建立map映射关系,遍历到该运算符,直接调用对应功能,直接了断
class Solution {
public:
int evalRPN(vector<string>& tokens) {
stack<int>stk;
int a, b;
map<string, function<int(int, int)>> opFuncMp = {
{"+", [](const int& x, const int& y){return x + y;}},
{"-", [](const int& x, const int& y){return x - y;}},
{"*", [](const int& x, const int& y){return x * y;}},
{"/", [](const int& x, const int& y){return x / y;}}
};
for (int i = 0; i < tokens.size(); ++i) {
//if(tokens[i] == "+" || tokens[i] == "-" || tokens[i] == "*" || tokens[i] == "/")
if(opFuncMp.count(tokens[i])) // 使用 count 检查当前的map是否有这个键值
{
a = stk.top(); stk.pop();
b = stk.top(); stk.pop();
// 注意是先b后a:和数值放入栈的顺序有关
int ret = opFuncMp[tokens[i]](b, a); // operator[] 调用运算符对应的 function 操作
stk.push(ret);
}
else {
stk.push(stoi(tokens[i]));
}
}
int ans = stk.top();
return ans;
}
};
(2)function 包装成员函数(静态和非静态)
成员函数分为:静态成员函数 和 非静态成员函数(普通成员函数)
使用 function 包装 成员函数都要加上 类域指定(类内就不用)
包装 非静态成员函数, 取函数指针时 要加上 取地址&:可以理解成一种语法规定
包装 静态成员函数可以不用加,也可以加上,建议加上,和非静态的保持一致
class Cal
{
public:
size_t add(const size_t& a, const size_t& b) {
return a + b;
}
static size_t mul(const size_t& a, const size_t& b) {
return a * b;
}
};
int main() {
int x = 10, y = 20;
// 包装静态成员函数
function<int(int, int)> f1 = Cal::mul;
f1(x, y);
// 包装普通成员函数
// 直接写会报错:因为参数没有对齐,还有一个隐含的 this 指针
function<int(int, int)> f2 = &Cal::add; // 报错:按照常理这里参数应该都匹配上了,报错是因为忽略了非静态成员函数还有一个隐含的 this 指针,因此下面的使用都加上第一个
// 1、创建类对象,调用时传该类对象的&, 表示this指针
function<int(Cal*, int, int)> f2 = &Cal::add;
Cal c1;
f2(&c1, x, y);
// 2、直接传匿名对象地址
function<int(Cal*, int, int)> f3 = &Cal::add;
f3(&Cal(), x, y);
// 3、只传对象及其类型也行
function<int(Cal, int, int)> f4 = &Cal::add;
Cal c2;
f4(c2, x, y); // 传普通对象
f4(Cal(), x, y); // 传匿名对象
// 为什么传 this 指针 和 传对象都行?
// 注意,function 的底层是获取到 右边的函数指针或仿函数等其他的可调用对象,然后将其设置成 function的成员变量(function底层是仿函数)
// 当需要使用该函数指针时,再通过 第一个参数 对象或this指针 来调用该 函数指针
// 因此这里的 this指针 及其他参数并不是被function直接传给 右边的可调用对象的
// 总结:为什么传 this 指针 和 传对象都行,是因为不是直接传参,而是使用 this 指针 和 传对象 为了调用对应的函数指针
return 0;
}
12.2 bind 包装器(绑定)
std::bind 函数定义在头文件中,是一个函数模板,它就像一个函数包装器(适配器),接受一个可
调用对象(callable object),生成一个新的可调用对象来“适应”原对象的参数列表。
一般而言,我们用它可以把一个原本接收 N 个参数的函数 fn,通过绑定一些参数,返回一个接收M个(M可以大于N,但这么做没什么意义)参数的新函数(下面都会演示)。同时,使用std::bind函数还可以实现参数顺序调整等操作。
(1)用途与使用方法
可以将bind函数看作是一个通用的函数适配器,它接受一个可调用对象,生成一个新的可调用对
象来“适应”原对象的参数列表。
调用 bind 的一般形式:auto newCallable = bind(callable,arg_list);
其中,newCallable 本身是一个可调用对象,arg_list是一个逗号分隔的参数列表(在模板中就是可变参数模板),对应给定的 callable 的参数。当我们调用newCallable时,newCallable会调用callable,并传给它 arg_list 中的参数。
参数列表 arg_list 中的参数会用 _1、_2、_3、_4....、_n 这种参数表示,这些参数,表示 newCallable 的参数,它们占据了传递给 newCallable 的参数的“位置”。这种参数叫做 placeholders ,
placeholders 是一个命名空间,表示一种序号,主要是配合 bind 使用,例如 _1 就表示函数调用newCallable 的第一个实参, _2 就表示函数调用 newCallable 的第二个实参
bind 的用途一:调整参数顺序
下面代码,相同的函数调用,结果不同,就是因为 bind 修改了函数调用参数的顺序
// bind
struct Sub
{
int operator()(const int& x, const int& y) {
return (x - y) ;
}
};
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int main() {
// 因为bind返回可调用对象,直接用 auto 接收即可
// 1、调整参数顺序
auto sub1 = bind(Sub(), _1, _2); // 第一个参数 Sub() 就是可调用对象,其他参数为函数调用sub1的第一个第二个参数
cout << sub1(10, 20) << '\n';
auto sub2 = bind(Sub(), _2, _1);
cout << sub2(10, 20) << '\n';
return 0;
}
_1 代表第一个实参, _2 代表第二个实参,调用 仿函数 Sub 时传递参数的顺序就是 bind 中 _1 和 _2 的顺序,因此可以调整顺序
相当于 placeholder 的 _1 直接绑定 函数调用sub中第一个参数, _2 直接绑定 函数调用sub中第二个参数,因此 sub2 中将 _1 和 _2 交换位置就表示两个传值(10, 20)交换位置
bind 的用途二:调整参数个数
struct Sub
{
int operator()(const int& x, const int& y) {
return (x - y) ;
}
};
int SubX(int a, int b, int c)
{
return (a - b - c);
}
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int main() {
// 2、调整参数个数
// 固定一个参数 100,函数调用只需传一个参数 10
// 通过 _1(代表第一个函数调用参数)的顺序,来操作
auto sub3 = bind(Sub(), 100, _1); // 把Sub的第一个参数 x 绑死
cout << sub3(10) << '\n';
auto sub4 = bind(Sub(), _1, 100); // 把Sub的第二个参数 y 绑死
cout << sub4(10) << '\n';
// 分别绑死第123个参数(我们这里调用的是函数:可调用对象可以是函数指针、仿函数、lambda)
auto sub5 = bind(SubX, 100, _1, _2);
cout << sub5(5, 1) << endl;
auto sub6 = bind(SubX, _1, 100, _2);
cout << sub6(5, 1) << endl;
auto sub7 = bind(SubX, _1, _2, 100);
cout << sub7(5, 1) << endl;
cout << "\n\n\n\n\n";
return 0;
}
(2)bind 的应用(结合 function 讲解 “计算年利息”)
using placeholders::_1;
using placeholders::_2;
using placeholders::_3;
int main() {
bind一般用于,绑死一些固定参数
前面学习的 function 包装类成员函数,需要传this指针或该类对象作为参数,这个是固定的参数
因此,可以使用 bind ,将该参数绑定给 function
//function<double(double, double)> f7 = bind(&Cal::add, Cal(), _1, _2);
//cout << f7(1.1, 1.1) << endl;
// bind 的应用:专门用于绑定一些固定的参数,用户只需输入变量,不用理会定量,便利性和可读性大大提升
// 计算年利息:利息=本金×年数×年利率
auto f8 = [](const double& rate, const int& year, const int& amount)->double {
return amount * year * rate;
};
// f_3_1p5:表示 3 年 1.5%利率
function<double(double)> f_3_1p5 = bind(f8, 0.015, 3, _1);
function<double(double)> f_5_2p5 = bind(f8, 0.025, 5, _1);
function<double(double)> f_10_3p5 = bind(f8, 0.035, 10, _1);
cout << "3年期,1.5%的年利率的可得利息: " << f_3_1p5(10000) << '\n';
cout << "5年期,2.5%的年利率的可得利息: " << f_5_2p5(10000) << '\n';
cout << "10年期,3.5%的年利率的可得利息: " << f_10_3p5(10000) << '\n';
cout << "\n\n\n\n\n";
return 0;
}