统一的列表初始化

｛｝初始化

C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自
定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

#include<iostream>
using namespace std;
int main()
{int arr1[] = { 1,2,3,4,5,6 };int arr2[]{ 1,2,3,4,5,6 };for (auto e : arr1){cout << e << " ";}cout << endl;for (auto e : arr2){cout << e << " ";}cout << endl;return 0;
}

#include<iostream>
using namespace std;
struct Point
{int _x;int _y;
};
int main()
{Point* p1 = new Point[2]{ {1,1},{2,2} };return 0;
}

#include<iostream>
using namespace std;
class Date
{
public:Date(int year, int month, int day):_year(year), _month(month), _day(day){cout << "Date(int year, int month, int day)" << endl;}
private:int _year;int _month;int _day;
};
int main()
{//这三个效果是相同的Date d1(2023, 5, 25);Date d2{ 2023, 5, 25 };Date d3 = { 2023, 5, 25 };return 0;
}

也就是说这里用花括号进行初始化调用的是类的构造。
也就是说，C++11几乎可以一切都可以用花括号初始化，包括变量（但是不建议这样）。

std::initializer_list

来看下面这段代码：

#include<iostream>
#include<vector>
#include<list>
using namespace std;
int main()
{vector<int> arr{1, 2, 3, 4, 5, 6};//这里的初始化为什么可以随意改变元素数量呢？auto a = { 10,20,30 };//来看看这个花括号初始化成了什么类型cout << typeid(a).name() << endl;//这里拿到的是类型的字符串return 0;
}

这是initializer_list类型的使用文档https://cplusplus.com/reference/initializer_list/initializer_list/

这个类似一个常量数组，有两个指针指向数组的开始和结束（其实也是迭代器）。
并且这个vector可以利用这个类型进行初始化的。

其实就相当于将initializer_list类型中的数据遍历然后push_back()到vector里面。
这种类型的实用处就是：

//这里就不用初始化一个pair类型的然后在插入map中了，因为里面是匿名对象的初始化
map<string, string> str = { {"字符串","string"},{"排序","sort"} };//里面的两个小花括号也可以理解为一个pair类型的initializer_list数组

声明

auto

这个经常用，自动推导左边对象类型。
在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局
部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将
其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初
始化值的类型。

decltype

关键字decltype将变量的类型声明为表达式指定的类型。

#include<iostream>using namespace std;int main()
{int x = 0;cout << typeid(x).name() << endl;decltype(x) y;cout << typeid(y).name() << endl;return 0;
}

那么decltype使用的地方在哪里呢？

#include<iostream>using namespace std;
template<class T1, class T2>
void F(T1 t1, T2 t2)
{decltype(t1 * t2) ret = t1 * t2;//这里万一涉及到整型提升，不知道提升到哪个类型就可以自动推导，不至于丢失精度cout << typeid(ret).name() << endl;cout << ret << endl;
}
int main()
{F(1, 2);F(1, 2.2);return 0;
}

nullptr

这个之前也经常用。
由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示
整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。

#ifndef NULL
#ifdef __cplusplus
#define NULL   0
#else
#define NULL   ((void *)0)
#endif
#endif

STL中一些变化

新容器

array
https://legacy.cplusplus.com/reference/array/array/

这个新容器和数组的功能没什么区别，不如vector好用，比普通数组多一个越界检查的报错。


forward_list
https://legacy.cplusplus.com/reference/forward_list/forward_list/
这是个单链表。

这里的区别就是，每个节点少一个指针的大小，并且没有头插头删（并不是那么好用）

已有容器的新接口

这里以vector举例：

这四个其实就是上面的正迭代器和反迭代器，c只是为了显示是const版本的而已，看起来更容易辨别。

这个接口是缩容的接口，如果空间浪费的实在是太大，可以用一下（用时间换空间）。

还有这两个接口，与右值引用和可变模板参数有关，下面会结合这个接口讲解。

右值引用和移动语义

左值引用和右值引用

什么是左值？

左值是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。
定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。

什么是右值？

右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。
右值引用就是对右值的引用，给右值取别名。

注意：

1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。
3. 右值引用只能右值，不能引用左值。
4. 但是右值引用可以move以后的左值。

#include<iostream>
using namespace std;
int main()
{// 左值引用只能引用左值，不能引用右值。int a = 10;int& ra1 = a;//ra为a的别名//int& ra2 = 10;//编译失败，因为10是右值//const左值引用既可引用左值，也可引用右值。const int& ra3 = 10;const int& ra4 = a;int a = 10;int&& r2 = a;// error C2440: “初始化”: 无法从“int”转换为“int &&”// message : 无法将左值绑定到右值引用// 右值引用可以引用move以后的左值int&& r3 = std::move(a);return 0;
}

需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可
以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地
址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用。

右值引用使用场景和意义

左值引用最大的意义就是函数传参，返回值，减少拷贝。
那么左值引用的缺点是什么？
看下面代码：

template<class T>
T func(const int x)
{T ret;return ret;//这里ret是局部变量，出作用域就会销毁，所以是一个传值返回
}

右值引用的价值之一就是补齐这最后一块短板。

右值引用引用左值及其一些更深入的使用场景分析

来看这样一段代码：

#include<iostream>
#include<cassert>
#include<algorithm>
using namespace std;
namespace baiye
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){//cout << "string(char* str)" << endl;_str = new char[_capacity + 1];strcpy(_str, str);}// s1.swap(s2)void swap(string& s){std::swap(_str, s._str);std::swap(_size, s._size);std::swap(_capacity, s._capacity);}// 拷贝构造string(const string& s):_str(nullptr){cout << "string(const string& s) -- 深拷贝" << endl;string tmp(s._str);swap(tmp);}// 赋值重载string& operator=(const string& s){cout << "string& operator=(string s) -- 深拷贝" << endl;string tmp(s);swap(tmp);return *this;}~string(){delete[] _str;_str = nullptr;}char& operator[](size_t pos){assert(pos < _size);return _str[pos];}void reserve(size_t n){if (n > _capacity){char* tmp = new char[n + 1];strcpy(tmp, _str);delete[] _str;_str = tmp;_capacity = n;}}void push_back(char ch){if (_size >= _capacity){size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;reserve(newcapacity);}_str[_size] = ch;++_size;_str[_size] = '\0';}//string operator+=(char ch)string& operator+=(char ch){push_back(ch);return *this;}const char* c_str() const{return _str;}private:char* _str;size_t _size;size_t _capacity; // 不包含最后做标识的\0};
}
namespace baiye
{baiye::string to_string(int value){bool flag = true;if (value < 0){flag = false;value = 0 - value;}baiye::string str;while (value > 0){int x = value % 10;value /= 10;str += ('0' + x);}if (flag == false){str += '-';}reverse(str.begin(), str.end());return str;}
}
int main()
{baiye::string str = baiye::to_string(-1234);return 0;
}

先看main函数中创建str然后调用to_string函数返回一个string类型赋值给str。
这里编译器优化就变成了拷贝构造。

这样就少了一次拷贝构造。
但如果是这种情况就无法进行优化。

那么这种情况下C++11是怎么解决问题的呢？

		// 移动构造string(string&& s):_str(nullptr), _size(0), _capacity(0){swap(s);}

如果传的参数是右值就会走这个函数。
注意：C++11给右值分为

纯右值（内置类型）
将亡值（自定义类型）

那么在to_string函数中返回了一个将亡值，如果在进行拷贝构造有些没必要：

那么这里在进行拷贝传值的时候就会传给移动构造函数，移动构造函数内部其实就是交换两个对象的值，反正将亡值也要销毁了，这样就不用进行深拷贝了。（深拷贝代价太大，如果深拷贝的对象是vector<vector< int>>效率就非常低了）

但是刚才这种情况还没有解决：

那么这里就可以再写一个移动赋值：

		// 移动赋值string& operator=(string&& s){swap(s);return *this;}

总结
右值引用是间接起作用，如果右值是将亡值，那么就转移资源。

这里用vector举例：如果传进去的是右值，就会走这个接口，会提升效率。

**注意：**右值引用被引用一次之后，引用的这个别名就变成了左值。


如果不变成左值怎么传给swap。

完美转发

万能引用

#include<iostream>using namespace std;
template<class T>
void func(T&& x)//这里也可以称为引用折叠，如果传的是左值，就折叠成一个引用符号
{}
int main()
{int x = 10;func(x);//左值也可以func(2);//右值也可以const int y = 20;func(y);//const左值func(move(y));//const右值return 0;
}

那么这个时候如果func函数中要去调用这四个函数，结果是怎么样的呢？

#include<iostream>using namespace std;
void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }
template<class T>
void func(T&& x)
{Fun(x);
}
int main()
{int x = 10;func(x);//左值func(2);//右值const int y = 20;func(y);//const左值func(move(y));//const右值return 0;
}

这里只会调用前两个函数，因为func中的参数x都是左值属性，这里就需要一个叫完美转发的在传参的过程中保持了 x 的原生类型属性。

新的类功能

默认成员函数

C++11 新增了两个默认成员函数：移动构造函数和移动赋值运算符重载。
针对移动构造函数和移动赋值运算符重载有一些需要注意的点如下：

如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个。那么编译器会自动生成一个默认移动构造。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
如果你没有自己实现移动赋值重载函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)
如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值。

default与delete

强制生成默认函数的关键字default:
C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原
因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以
使用default关键字显示指定移动构造生成。

#include<iostream>
using namespace std;
class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}Person(const Person& p):_name(p._name), _age(p._age){}Person(Person && p) = default;//强制生成
private:string _name;int _age;
};
int main()
{Person s1;Person s2 = s1;Person s3 = std::move(s1);return 0;
}

禁止生成默认函数的关键字delete:
如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁
已，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即
可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

#include<iostream>
using namespace std;
class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}Person(const Person& p) = delete;
private:string _name;int _age;
};
int main()
{Person s1;Person s2 = s1;Person s3 = move(s1);return 0;
}

这样吴凯伦是内部和外部都无法使用这个拷贝构造函数了。

可变参数模板

参数包

这个也是为了对标C语言的可变性参数，比如printf和scanf。

#include<iostream>
using namespace std;
// Args是一个模板参数包，args是一个函数形参参数包
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
template <class ...Args>
void ShowList(Args... args)
{}
int main()
{return 0;
}

上面的参数args前面有省略号，所以它就是一个可变模版参数，我们把带省略号的参数称为“参数
包”，它里面包含了0到N（N>=0）个模版参数。我们无法直接获取参数包args中的每个参数的，
只能通过展开参数包的方式来获取参数包中的每个参数，这是使用可变模版参数的一个主要特
点，也是最大的难点，即如何展开可变模版参数。

如何查看参数包有几个参数呢？

#include<iostream>
using namespace std;
template <class ...Args>
void ShowList(Args... args)
{cout << sizeof...(args) << endl;//查看参数包有几个参数
}
int main()
{ShowList(1);ShowList(1, 2.2);ShowList(1, 2.2, string("xxx"));return 0;
}

遍历参数包中的参数

递归函数方式展开参数包

#include<iostream>
using namespace std;
// 递归终止函数
void ShowList()//当参数包中的参数变成0个的时候就会调用这个函数
{cout << endl;
}
// 展开函数
template <class T, class ...Args>
void ShowList(T value, Args... args)//第一个参数传给value，剩下的参数传给args参数包
{cout << value << " ";ShowList(args...);
}
int main()
{ShowList(1);//这里1传给value，然后参数包没有参数调用终止函数ShowList(1, 2.2);//这里第一次1传给value，2.2传给参数包，第二次2.2传给value，参数包没有值，调用终止函数ShowList(1, 2.2, string("xxx"));return 0;
}

非常的怪异。
逗号表达式展开参数包

#include<iostream>
using namespace std;
template <class T>
void PrintArg(T t)
{cout << t << " ";
}
//展开函数
template <class ...Args>
void ShowList(Args... args)
{int arr[] = { (PrintArg(args), 0)... };cout << endl;
}
int main()
{ShowList(1);ShowList(1, 'A');ShowList(1, 'A', std::string("sort"));return 0;
}

这里的arr数组是一个辅助的作用，里面调用的是PrintArg函数，编译器自行初始化arr数组，参数包中有多少个参数数组的空间就有多大。

这里的逗号表达式只是为了初始化arr数组，初始化为0。

STL容器中的empalce相关接口函数

http://www.cplusplus.com/reference/vector/vector/emplace_back/


emplace_back是可以不传参的，那么默认用户的就是匿名构造，传入的值就是0。
那么emplace_back的意义在哪里呢？

#include<iostream>
#include<vector>
using namespace std;
int main()
{vector<pair<int, string>>arr;arr.emplace_back(1, "xxx");//这里可以这样初始化(直接构造),push_back只能构造一个对象去传，当然emplace_back也可以构造一个对象传return 0;
}

其实就是一种优化，如果传入的是右值编译器可以直接优化成直接构造（移动构造或者是移动赋值都省下了），不需要任何拷贝构造或者是移动构造（如果是左值还是构造+深拷贝）。

lambda表达式

为什么要有lambda表达式

这个和仿函数有些类似。
举个例子，如果定义水果类，创建多个水果对象，那么他们分别有名字，价格，评价等等属性，如果想通过sort函数来实现对于不同对象的排序就要写很多个仿函数，非常的麻烦。

#include<iostream>
#include<vector>
#include <algorithm>
#include <functional>
using namespace std; 
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());return 0;
}

那么这个时候lambda表达式就可以上场了。

#include<iostream>
#include<vector>
#include <algorithm>
#include <functional>
using namespace std; 
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(), [](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; });//按照评价排序return 0;
}

这是按照价格排序的结果：

这是按照评价排序：

lambda表达式的格式

lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type { statement }
1.lambda表达式各部分说明

[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。
(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略。
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)。
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。

注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为
空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。

#include<iostream>
using namespace std;
int main()
{//其实lambda就是要给可调用的对象auto compare = [](int x, int y) {return x > y; };//这个类型编译器认识，但是我们不认识cout << compare(1, 2) << endl;return 0;
}

那么，在外部定义的变量能在lambda表达式中使用吗？

#include<iostream>
using namespace std;
int main()
{int a = 10;int b = 20;auto add1 = []() { return a + b; };return 0;
}

这里是不可以的，因为是两个不同的作用域，这个时候需要捕捉这两个变量才可以使用。

auto add1 = [a, b]() { return a + b; };

这个时候编译就通过了。
那么如果想交换两个变量呢？

#include<iostream>
using namespace std;
int main()
{int a = 10;int b = 20;auto swap1 = [a, b](){int c = a;a = b;b = c;};return 0;
}

这里是不允许的，如果想修改要加mutable。

	auto swap1 = [a, b]()mutable{int c = a;a = b;b = c;};

但是外部的a和b并没有发生改变，也就是说捕捉的对象是传值拷贝，加了一个const的变量，mutable只是让他们变成非const属性的值。
如果想改变就要这样：

#include<iostream>
using namespace std;
int main()
{int a = 10;int b = 20;auto swap1 = [&a, &b]()//这里虽然是外部a和b的别名，但是不能修改a和b的名字，不然就不能捕捉了{int c = a;a = b;b = c;};return 0;
}

这里也无法在捕捉列表取地址。
在捕捉列表里面可以用=就是捕捉父作用域向上的变量，&是捕捉父作用域向上的变量别名。（向上就是在捕捉列表语句前面的所有变量）

#include<iostream>
using namespace std;
int main()
{int a = 10;int b = 20;auto add1 = [=]() { return a + b; };auto swap1 = [&](){int c = a;a = b;b = c;};return 0;
}

注意：这些可以进行混合捕捉，比如对父作用域向上的变量进行传值捕捉，对于某一个或者是某些进行引用捕捉。

lambda的底层

#include<iostream>
using namespace std;
class Rate
{
public:Rate(double rate) : _rate(rate){}double operator()(double money, int year){return money * _rate * year;}
private:double _rate;
};
int main()
{// 函数对象double rate = 0.49;Rate r1(rate);r1(10000, 2);// lamberauto r2 = [=](double monty, int year)->double {return monty * rate * year;};r2(10000, 2);return 0;
}

第一个是仿函数的反汇编，第二个是lambda表达式的反汇编，也就是说本质都是一样的调用仿函数。
并且lambda表达式的类型名字也很繁琐。

包装器

function包装器

function包装器 也叫作适配器。C++中的function本质是一个类模板，也是一个包装器。

#include<iostream>
using namespace std;
template<class F, class T>
T useF(F f, T x)
{static int count = 0;cout << "count:" << ++count << endl;cout << "count:" << &count << endl;return f(x);
}
double f(double i)
{return i / 2;
}
struct Functor
{double operator()(double d){return d / 3;}
};
int main()
{// 函数名cout << useF(f, 11.11) << endl;// 函数对象cout << useF(Functor(), 11.11) << endl;// lamber表达式cout << useF([](double d)->double { return d / 4; }, 11.11) << endl;return 0;
}

这里实例化的三分不同的函数，有没有什么办法让他不生成这么多的函数。

#include<iostream>
#include<functional>
using namespace std;
int f(int a, int b)
{return a + b;
}
struct Functor
{
public:int operator() (int a, int b){return a + b;}
};
int main()
{function<int(int, int)> f1;//第一个int是返回值，括号里面的是参数f1 = f;//封装到f1中cout << f1(1, 2) << endl;function<int(int, int)> f2(f);//这种方法也可以将f封装到f2中cout << f2(1, 2) << endl;function<int(int, int)> f3 = Functor();cout << f3(1, 2) << endl;/*function<int(int, int)> f4(Functor());//这里不可以，因为编译器会识别成为函数指针cout << f4(1, 2) << endl;*/function<int(int, int)> f5 = [](const int a, const int b){return a + b; };cout << f5(1, 2) << endl;
}

类中的成员函数也是可以包装的，但是要注意：

#include<iostream>
#include<functional>
using namespace std;
class Plus
{
public:static int plusi(int a, int b){return a + b;}int plusd(int a, int b){return a + b;}
};
int main()
{//这里存入的是函数指针function<int(int, int)> f1 = &Plus::plusi;//静态成员函数可以不加&cout << f1(1, 2) << endl;function<int(Plus, int, int)> f2 = &Plus::plusd;//非静态成员函数必须加&，这里还要加一个参数，因为传参还有一个this指针cout << f2(Plus(), 1, 2) << endl;//这里是传进去一个Plus类型的对象，其实就是利用这个对象调用该成员函数而已
}

其实包装器就是对于可调用对象类型的大统一。
那么使用的场景呢？
力扣：逆波兰表达式

class Solution {
public:int evalRPN(vector<string>& tokens) {stack<int> st;map<string, function<int(int, int)>> opMap={{"+",[](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)//在map中查找符号{if(opMap.count(e)){int a = st.top();st.pop();int b = st.top();st.pop();st.push(opMap[e](b, a));//找到之后就将栈中的两个值通过map中储存的包装器中的lamber表达式进行运算，这里要注意数的顺序，先去取出来的在左边，后取出来的在右边}else{st.push(stoi(e));}}return st.top();}
};

bind

std::bind函数定义在头文件中，是一个函数模板，它就像一个函数包装器(适配器)，接受一个可调用对象（callable object），生成一个新的可调用对象来“适应”原对象的参数列表。一般而言，我们用它可以把一个原本接收N个参数的函数fn，通过绑定一些参数，返回一个接收M个（M可以大于N，但这么做没什么意义）参数的新函数。同时，使用std::bind函数还可以实现参数顺序调整等操作。

// 原型如下：
template <class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);
// with return type (2) 
template <class Ret, class Fn, class... Args>
/* unspecified */ bind(Fn&& fn, Args&&... args);

举例：

#include<iostream>
#include <functional>
using namespace std;
int Plus(int a, int b)
{return a - b;
}
int main()
{//表示绑定函数plus 参数分别由调用 func1 的第一，二个参数指定function<int(int, int)> func1 = bind(Plus, placeholders::_1,placeholders::_2);//placeholders是占位对象cout << func1(1, 2) << endl;//_1代表本来的第一个参数，_2代表本来的第二个参数//这里调参数function<int(int, int)> func3 = bind(Plus, placeholders::_2, placeholders::_1);cout << func3(1, 2) << endl;return 0;
}

那么实际的作用在哪里呢？
比如包装器包装的是类的成员函数，传参的时候第一个总是类的匿名对象，写起来很麻烦。

#include<iostream>
#include <functional>
using namespace std;
class Sub
{
public:int sub(int a, int b){return a - b;}
};
int main()
{function<int(int, int)> func1 = bind(&Sub::sub, Sub(), placeholders::_1, placeholders::_2);cout << func1(1, 2) << endl;//这里本来是三个参数，但是第一个参数已经被绑定了，包装器的参数也不用写三个了，这里也不用传三个参数了return 0;
}