前情回顾：
【C++11 新增语法（1）：1~6 点】
C++11出现与历史、花括号统一初始化、initializer_list初始化列表、 auto、decltype、nullptr、STL的一些新变化
【C++11 新增语法（2）：7~8 点】
右值引用和移动语义∶移动构造和移动赋值、move 函数、左值引用的短板、万能引用、完美转发、push_back 函数重载右值引用版本（借助list的push-back 使用举例)﹔新增两个默认类函数与delete关键字
【C++11 新增语法（3）：9~10 点】
可变参数模板：参数包的用法、参数包展开的几种方法；
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. 逆波兰表达式求值 中每种运算符，对应一种计算逻辑，我们就可以将 运算符 和 计算逻辑 形成映射关系，需要该使用运算符，就调用对应的功能
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;
}
![[深度学习][LLM]：浮点数怎么表示，什么是混合精度训练？](https://img-blog.csdnimg.cn/img_convert/687d4d82dacedfedc0d41b8eaf0932b1.png)
