C++【C++11】

文章目录

• 一、统一的列表初始化
• • 1.用{}来初始化元素
  • 2.initializer_list
• 二、自动类型推断
• • 3.auto
  • 4.decltype
• 三、指针
• • 5.nullptr
  • 6.范围for
• 四、STL中的一些新变化
• • 1.新增加的容器
  • 2.容器内部的变化
• 五、左值引用和右值引用
• • 1.什么是左值，什么是右值
  • 左值
  • 右值
  • • 那么左值引用能不能给右值取别名？
    • 那么右值引用能不能给左值取别名
    • 右值引用的应用
    • 移动构造和移动赋值
    • • 移动构造
      • 移动赋值
    • 右值引用版本的插入
• 六、万能引用和完美转发
• • 1.万能引用
  • 2.完美转发
• 七、新的类功能
• • 1.移动构造的自动生成条件
  • default和delete
  • • 要求delete关键字实现，一个类，只能在堆上创建对象
  • 继承中的final和override关键字
• 八、可变参数模板
• • 1.通过递归调用的方式取出参数包中的内容
  • 2.列表初始化读取参数包中的内容
  • 3.emplace的实现
  • • emplace_back和我们的push_back有什么区别？
• 九、lambda表达式
• • greater< int >与greater< int >()
  • lambda表达式的语法
  • 捕捉列表的说明
  • lambda是怎么实现的
• 十、包装器
• • function包装器
  • 包装器的一些应用场景
  • 绑定bind
  • 1.绑定参数调整顺序
  • 2.绑定参数的个数

一、统一的列表初始化

1.用{}来初始化元素

在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：

struct Point
{int _x;int _y;
};
int main()
{int array1[] = { 1, 2, 3, 4, 5 };int array2[5] = { 0 };Point p = { 1, 2 };return 0;
}

但是在C++11中，我们都可以使用{}来对我们的元素进行初始化
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <array>
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()
{int x1 = 1;// 要能看懂，但是不建议使用int x2 = { 2 };int x3 { 2 };// 都是在调用构造函数Date d1(2022, 11, 22);// C++11 要能看懂，但是不建议使用Date d2 = {2022, 11, 11}; // ->调用构造函数Date d3{ 2022, 11, 11 };return 0;
}

2.initializer_list

C++11中有了一种新的类型，initializer_list，语法上原生支持通过大括号的方式初始化给它。它就像一个顺序表一样，支持迭代器，但是不支持插入数据。

int main()
{// 调用支持list (initializer_list<value_type> il）类似这样的构造函数vector<int> v1 = { 1, 2, 3, 4, 5, 6 };vector<int> v2 { 1, 2, 3, 4, 5, 6 };list<int> lt1 = { 1, 2, 3, 4, 5, 6 };list<int> lt2{ 1, 2, 3, 4, 5, 6 };//c++11这里新增了一个类型initializer_list类型来实现，是这里默认需要的一个容器auto x = { 1, 2, 3, 4, 5, 6 };cout << typeid(x).name() << endl;return 0;
}

那我们的vector等容器又是如何支持大括号的初始化的呢？
因为我们的C++11同时也对我们的库函数进行了更新，让我们的库函数都支持通过initializer_list来进行构造。
这里我们查看一下vector的构造函数中多了一个构造方法，也就是我们的initializer


那如何让我们自己之前写过的vector支持通过initializer来初始化

vector(initializer_list<T> il):_start(nullptr),_finish(nullptr),_end_of_storage(nullptr){reserve(il.size());iterator it=begin();for(auto&e:il){push_back(e);}}

测试代码

void myvector_test18(){vector<int> v1={1,2,3,4,5,6,7,8,9,10};vector<int> v2{1,2,3,4,5,6,7,8,9,10};for(auto e:v2){cout<<e<<" ";}cout<<endl;}

当然，我们的map,set,pair等容器也可以通过这种方式进行构造

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <array>
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(2022, 11, 22);Date d2 = {2022, 11, 11}; Date d3{ 2022, 11, 11 };vector<Date> v3 = {d1, d2, d3};vector<Date> v4 = { { 2022, 1, 1 }, {2022, 11, 11} };string s1 = "11111";// 构造//这相当于就是隐式类型转换//构造一个pair我们也可以通过{}的方式构造map<string, string> dict = { { "sort", "排序" }, { "insert", "插入" } };return 0;
}

当然在我们的C++11的库中，还将许多赋值也进行了重载，让其能够支持initializer进行赋值

下面是我们的测试代码

#include <iostream>
#include <map>
using namespace std;int main()
{// 构造//这相当于就是隐式类型转换//构造一个pair我们也可以通过{}的方式构造map<string, string> dict = { { "sort", "排序" }, { "insert", "插入" } };// 赋值重载//这里不写auto让编译器自动去推断，我们的编译器是没有办法匹配出来的。initializer_list<pair<const string, string>> kvil = { { "left", "左边" }, { "left", "左边" } };dict = kvil;return 0;
}

总结：
C++11之后，一切对象都可以用列表初始化。但是我们建议普通对象还是用以前的方式初始化，容器可以采用花括号进行初始化。

二、自动类型推断

3.auto

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

int main()
{int i = 10;auto p = &i;auto pf = strcpy;cout << typeid(p).name() << endl;cout << typeid(pf).name() << endl;map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };//如果我们这里要自己写的话，需要写一长串，但是使用auto的话就非常方便//map<string, string>::iterator it = dict.begin();auto it = dict.begin();return 0;
}

如果我们这里使用auto的话，我们上面代码中的迭代器的类型等等，我们都不用自己手写，就非常方便，但是我们如果使用了auto进行自动类型推断，我们代码的可读性就会变差，但是有些编译器会给你标识出来（比方说clion）。

4.decltype

typename可以推导对象的类型，但是我们不能通过这个推导出来的类型来定义我们的对象，只是单纯地拿到这个类型的字符串。
但是如果我们想要用推导出来的类型重新定义一个新的对象呢？

int main()
{int x = 10;// typeid拿到只是类型的字符串，不能用这个再去定义对象什么的// 下面这样写会报错的,没有下面这样的用法//	typeid(x).name() y = 20;decltype(x) y1 = 20.22;//auto和decltype是不一样的，我们的auto这里推导出来的是double，也就是我们右边的赋值的元素的类型是什么，我们auto推导出来也就是什么//但是我们的deltype推导出来的类型是x的类型，也就是intauto y2 = 20.22;cout << y1 << endl;cout << y2 << endl;return 0;
}

三、指针

5.nullptr

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

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

6.范围for

这里的范围for和我们java中的增强for有些相似，底层是一个迭代器。
可以查看我们之前的博客中的迭代器和范围for相关的部分

int main()
{vector<int> tmp{1,2,3,4,5,6,7,8,9};for(auto i:tmp){cout<<i<<" ";}cout<<endl;
}

四、STL中的一些新变化

1.新增加的容器

< array >和< forward_list >显得有些鸡肋
因为< array >是固定大小的数组容器，不支持尾插和尾删，支持[]迭代器。
C++11增加这个的初衷是为了替代c语言中的数组

int main()
{const size_t N = 100;int a1[N];// C语言数组越界检查，越界读基本检查不出来，越界写是抽查a1[N];//a1[N] = 1;a1[N+5] = 1;// 越界读写都可以被检查出来// 实际情况：array用得很少，一方面大家用c数组用惯了// 用array不如用vector + resize去替代c数组array<int, N> a2;a2[N];a2[N] = 1;a2[N + 5] = 1;return 0;
}

< forward_list >是一个单链表，我们的< list >是双向链表，在使用的时候其实< forward_list >插入的是在我们当前指定位置的后一个位置插入，然后erase并不是擦除当前的位置，而是擦除当前位置的下一个位置。

2.容器内部的变化

1.都支持了initializer_list构造，用来支持列表初始化
2.比较鸡肋的接口，比如cbegin,cend系列
3.移动构造和移动赋值，用来对标拷贝构造和拷贝赋值，在某些场景下可以提高效率
（set&&x）;
（set& operator=(set&&x）
4.右值引用的参数的插入

五、左值引用和右值引用

1.什么是左值，什么是右值

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

左值

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

int main()
{//左值：可以取它的地址int a = 10;const int b = 20;//这里的*p是左值int* p = &a;*p = 100;//左值一般都可以对其进行赋值，但是除了上面的b因为我们的b是一个const无法被修改
}

int main()
{// 以下的p、b、c、*p都是左值int* p = new int(0);int b = 1;const int c = 2;// 以下几个是对上面左值的左值引用int*& rp = p;int& rb = b;const int& rc = c;int& pvalue = *p;return 0;
}

右值

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

int main()
{double x = 1.1, y = 2.2;// 以下几个都是常见的右值//字面量10;//表达式，传值返回，会产生一个临时对象x + y;//传值返回的函数，因为会产生一个临时对象fmin(x, y);//右值不能放到赋值符号的左边// 这里编译会报错：error C2106: “=”: 左操作数必须为左值10 = 1;x + y = 1;fmin(x, y) = 1;return 0;
}

右值的特点就是不能取地址。
所以我们下面这样写的话是会报错的

int main()
{double x = 1.1, y = 2.2;// 右值:不能取地址10;x + y;fmin(x, y);cout << &10 << endl;cout << &(x + y) << endl;}

右值引用就是给我们的右值取别名。

int main()
{double x = 1.1, y = 2.2;// 以下几个都是对右值的右值引用int&& rr1 = 10;double&& rr2 = x + y;double&& rr3 = fmin(x, y);
}

那么左值引用能不能给右值取别名？

（左值引用可以引用右值嘛？）

int main()
{// 有条件的支持// 左值引用可以引用右值吗？ const的左值引用可以//这里的r1是不可以的，这里的r2是可以的double& r1 = x + y;const double& r2 = x + y;
}

右值引用是没办法被改变的，所以我们如果想要通过左值引用去引用一个右值，我们就需要加上const。
所以我们最好给我们的函数传参的时候加上const，这样的话，我们的函数既能够接收左值也能够接收右值

// x既能接收左值，也能接收右值
template<class T>
void Func(const T& x)
{}

那么右值引用能不能给左值取别名

（右值引用可以引用左值嘛？不可以，需要有语法支持）
右值引用可以引用move以后的左值

int main()
{int b = 1;// 右值引用可以引用左值吗？可以引用move以后的左值//这里的rr5编译器是会报错的，但是rr6不会，可以正常编译通过。int&& rr5 = b;int&& rr6 = move(b);}

左值引用可以引用右值吗？ const的左值引用可以
右值引用可以引用左值吗？可以引用move以后的左值

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

也就是可以理解成我们的右值在被右值引用之后，就变成了一个左值

int main()
{double x = 1.1, y = 2.2;int&& rr1 = 10;const double&& rr2 = x + y;rr1 = 20;rr2 = 5.5; // 报错return 0;
}

右值引用的应用

引用的价值：减少拷贝，尤其是深拷贝
左值引用：还可以用作输出型参数

左值引用解决了哪些问题？
①做参数：1.减少拷贝，提高效率 2.做输出型参数
②做返回值：1.减少拷贝，提高效率 2.引用返回可以修改返回对象（比方说operator[]就是这样使用的）

左值引用在什么情况下有盲区？

如果我们有一个对象需要返回，那么如果我们采用的是左值引用的话，我们在将这个这个对象返回的时候，我么得这个对象已经被析构了，那么我们就没有办法成功返回对象。
比方说下面的情况

//case1
string to_string (int val)
//case2
vector<vector<int>> generate(int numRows)

我们需要将上面的两行代码修改为下面的代码。

//case1
to_string(int val,string&str)
//case2
void generate(int numRows,vector<vector<int>& w)

也就是说我们需要将我们的对象用左值引用的方式传入我们的函数，这样才能够避免在我们的函数中开辟了一个对象，然后因为我们的函数执行完，这个对象被析构，没有办法被返回的问题。
但是这样不符合使用习惯。
C++11出右值引用的一个重要功能就是解决上面的问题。

如何解决？
比方说我们这里写了一个string类

namespace zhuyuan
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){_str = new char[_capacity + 1];strcpy(_str, str);}void swap(string& s){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷贝构造string(const string& s):_str(nullptr){cout << "string(const string& s) -- 拷贝构造(深拷贝)" << endl;//现代写法//string tmp(s._str);//swap(s);//传统写法_str = new char[s._capacity+1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}// 拷贝赋值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){push_back(ch);return *this;}const char* c_str() const{return _str;}private:char* _str;size_t _size;size_t _capacity;};string to_string(int value){bool flag = true;if (value < 0){flag = false;value = 0 - value;}zhuyuan::string str;while (value > 0){int x = value % 10;value /= 10;str += ('0' + x);}if (flag == false){str += '-';}std::reverse(str.begin(), str.end());return str;}
}

移动构造和移动赋值

想要优化上面代码中的拷贝，我们就需要实现移动构造和移动赋值。

移动构造

 // 移动构造string(string&& s):_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 资源转移" << endl;swap(s);}

移动赋值

// 移动赋值string& operator=(string&& s){cout << "string& operator=(string s) -- 移动赋值(资源移动)" << endl;swap(s);return *this;}

相比于拷贝构造和拷贝赋值，其参数都是左值引用，如果我们这里没有移动构造和移动赋值，因为我们上面的拷贝构造和拷贝赋值的参数为const类型的，所以我们调用左值的时候，都会走拷贝构造和拷贝赋值函数。
但是我们这里写了移动构造和移动赋值的话，左值引用就会调用我们这里的移动构造和移动赋值。
（编译器在匹配类型的之后，会去寻找最匹配的）

C++11又对右值进行了进一步的划分
1、内置类型的右值：纯右值
2、自定义类型的右值：将亡值
右值一般是一些字面量，函数表达式的返回值，表达式的值，这些临时的对象的声明周青往往就只有在它所在的那一行，所以将其称为将亡值（资源即将被销毁）。
（这里我们需要将这里的右值的资源给swap另外一个对象，用另外一个对象的存在，实现资源转移。）

int main()
{zhuyuan::string str1("hello");zhuyuan::string str2(str1); //  拷贝构造//如果我们的右边是一个右值，move之后的就是右值zhuyuan::string str3(move(str1)); // 移动构造return 0;
}

我们观察到我们对象str1中的内容被拷贝到了我们的str3中

拷贝构造的代价相比移动构造更加大，拷贝构造了一个对象，我们还需要将这个旧的对象给释放，也就是一次深拷贝，再加上一次资源的释放。但是我们的移动构造是将我们的资源转移过来，不需要拷贝。

本来我们下面的代码应该是有一次拷贝构造和一次移动构造的，但是由于我们编译器的优化，因为我们这里的str出了我们的作用域就会销毁掉，所以我们的编译器会将其优化，也就是直接将其识别为右值（将亡值），然后就进行资源的转移，然后调用移动构造，然后再调用移动赋值，将str中的资源转移到我们的ret，从而实现拷贝的减少。

zhuyuan::string to_string(int value)
{zhuyuan::string str;//...//拷贝构造，返回结果作为左值return str;
}
int main()
{//移动构造zhuyuan::string ret= to_string(-3456);return 0;
}

我们这里的右值引用并不是直接起作用的，而是通过移动构造和移动赋值间接起作用的。
所以我们只要实现了移动构造和移动拷贝，我们就不用像前面那样传入一个对象，函数操作完成，再将其返回了，更加符合我们的使用习惯（可以直接将我们的对象返回了）。

我们再来看一下库中的实现

int main()
{std::string s1("hello world");std::string s2(s1); // 拷贝构造
//	 std::string s3(s1+s2);//表达式的返回对象是一个将亡值，也就是一个右值，这里我们使用的就是右值拷贝std::string s3 = s1 + s2; // 移动构造std::string s4 = move(s1);return 0;
}

我们通过调试来观察一下，这是初始状态

运行到s2(s1)之后，这里是深拷贝构造

执行到s3=s1+s2，这里的s1+s2的结果是一个将亡值，这个将亡值直接被移动构造给了s3

然后运行到s4=move(s1)，这里就是一个右值引用，我们s1中的内容直接移动给了s4，我们从下面的调试中观察到其实我们的s1中已经没有内容了

我们观察到在c++11之后，在我们的STL库中的容器都提供了这个移动构造的方法

和移动赋值

右值引用版本的插入

我们观察c++11的STL库中还增加了右值引用版本的插入

移动构造和移动赋值解决了传值返回这些类型对象的问题。

int main()
{vector<zhuyuan::string> v;//这里的hello是一个左值zhuyuan::string s1("hello");v.push_back(s1);cout << "----------------------------------" << endl;//这里的world是一个右值v.push_back(zhuyuan::string("world"));v.push_back("world");cout << "===================================" << endl;list<zhuyuan::string> lt;zhuyuan::string s2("hello");lt.push_back(s2);cout << "----------------------------------" << endl;lt.push_back(zhuyuan::string("world"));lt.push_back("world");return 0;
}

插入的过程中，如果传递对象是右值对象，那么进行资源转移，减少拷贝，STL中的插入的接口在C++11后都会提供。

六、万能引用和完美转发

1.万能引用

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; }// 万能引用：t既能引用左值，也能引用右值
// 引用折叠
template<typename T>
void PerfectForward(T&& t)
{Fun(t);
}

#include "list.h"int main()
{PerfectForward(10);int a;PerfectForward(a);   PerfectForward(std::move(a));const int b = 8;PerfectForward(b);		    PerfectForward(std::move(b)); return 0;
}

那这里的t的属性是什么呢？
我们发现无论我们传入的是左值还是右值，它调用的都是左值

2.完美转发

像上面的万能引用，我们的编译器全部都会被处理成左值，那么我们怎么才能保持我们的传入的参数原本的属性呢？这里我们就需要用到我们的完美转发

首先我们给我们自己写的list.h加上右值引用的插入函数

void push_back(T&& x)
{insert(end(), (x));
}iterator insert(iterator pos, T&& x)
{Node* cur = pos._node;Node* prev = cur->_prev;Node* newnode = new Node(x);// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);
}

template<typename T>
void PerfectForward(T&& t)
{// 完美转发：保持t引用对象属性Fun(std::forward<T>(t));
}#include "list.h"测试代码int main()
{PerfectForward(10);           // 右值int a;PerfectForward(a);            // 左值PerfectForward(std::move(a)); // 右值const int b = 8;PerfectForward(b);		      // const 左值PerfectForward(std::move(b)); // const 右值zhuyuan::list<zhuyuan::string> lt;zhuyuan::string s1("hello");lt.push_back(s1);cout << "----------------------------------" << endl;lt.push_back("world");return 0;
}

这里我们注意到，我们的拷贝构造全部都是深拷贝，没有匹配上我们的右值构造的版本，这是为什么？
因为我们上面的push_back中是我们上述的万能引用，所以传入的参数全部都被当成了左值引用，如果我们还想要使用右值引用的话，我们需要将其变成完美转发！

void push_back(T&& x)
{insert(end(), std::forward<T>(x));
}//然后给我们的list_node也写一个右值引用的版本
//只要往下一层传递，我们就需要完美转发一下
list_node(T&& x):_data(std::forward<T>(x)), _next(nullptr), _prev(nullptr){}iterator insert(iterator pos, T&& x)
{Node* cur = pos._node;Node* prev = cur->_prev;Node* newnode = new Node(std::forward<T>(x));// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);
}

OK，我们下面的终于调用了资源转移（右值引用）。

七、新的类功能

原来的C++中，有6个默认的成员函数：

1.构造函数
2.析构函数
3.拷贝构造函数
4.拷贝赋值函数
5.取地址重载
6.const取地址重载

在C++11之后默认成员函数有8个，增加了移动构造和移动赋值运算符重载
（拷贝构造和拷贝赋值是针对于左值的拷贝（const左值引用既可以针对左值也可以针对右值））
（移动构造和移动赋值是针对右值的拷贝）

1.移动构造的自动生成条件

如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个（不过说实话，这里面只要有一个需要我们自己手写，其他的一般也都是需要我们手写的）。那么编译器会自动生成一个默认移动构造。

默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

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

1.拷贝对象需要深拷贝时，自己写移动构造和移动赋值，比如：string，vector，list

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& operator=(const Person& p){if(this != &p){_name = p._name;_age = p._age;}return *this;}~Person(){}private:zhuyuan::string _name;int _age;
};int main()
{Person s1("张三", 7);Person s2 = s1; // 拷贝构造Person s3 = std::move(s1); // 移动构造 （没有移动构造，再调用拷贝构造）return 0;
}

我们注意到我们这里的调用的都是拷贝构造，如果我们想要使用移动构造的话，我们就需要将我们上面自己写的析构，拷贝，负值重载给去掉

class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}// 会默认生成拷贝构造+移动构造
private:zhuyuan::string _name;int _age;
};int main()
{Person s1("张三", 7);Person s2 = s1; // 拷贝构造Person s3 = std::move(s1); // 移动构造 （没有移动构造，再调用拷贝构造）return 0;
}

移动赋值和移动构造类似

class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}// 会默认生成拷贝构造+移动构造
private:zhuyuan::string _name;int _age;
};int main()
{Person s1("张三", 7);Person s2 = s1; // 拷贝构造Person s3 = std::move(s1); // 移动构造 （没有移动构造，再调用拷贝构造）Person s4;s4 = std::move(s2);return 0;
}

也就是说深拷贝的类，一般都是需要我们自己手动写的。
如果是像上面这样的person类，让编译器自动生成就可以了。（自定义类型会自动调用析构）

default和delete

default

	//强制编译器生成默认的移动构造Person(Person&& p)=default;

比防说我们自己写了一个拷贝构造，那么编译器就不会自动生成拷贝构造了，那么，想要让我们的编译器生成默认的移动构造的话，我们可以像上面这样，加上一个default

delete
如果我们不想让编译器生成默认的构造方法，我们可以给我们的参数加上delete，这样我们的Person对象就不能被拷贝了。

	// 不想让Person对象拷贝Person(const Person& p) = delete;

要求delete关键字实现，一个类，只能在堆上创建对象

// 要求delete关键字实现，一个类，只能在堆上创建对象
class HeapOnly
{
public:HeapOnly(){_str = new char[10];}//将析构变成delete，没有一个对象能够创建对象//因为变量出了作用域，一定要调用析构函数~HeapOnly() = delete;void Destroy(){//将空间释放delete[] _str;//this的值就是我们的对象的地址，我们不能直接写delete (this)，因为delete被禁用了//operator delete(this);}private:char* _str;//...
};int main()
{//栈//HeapOnly hp1;//静态区//static HeapOnly hp2;//为什么new可以创建出来？//因为new出来的对象返回的是一个指针，这个指针会在堆上开辟一块空间，并不会去调用析构函数，所以可以成功创建出来HeapOnly* ptr = new HeapOnly;//析构函数被禁用了，没办法用delete//delete ptr;//调用我们自己写的Destory来释放空间//下面两个都是可以的ptr->Destroy();//operator delete(ptr);return 0;
}

继承中的final和override关键字

final：可以修饰我们的类，不能被继承，虚函数不能被重写
override：检查子类中的虚函数是否完成了重写，没有完成从写就会报错

八、可变参数模板

可变参数也就是说可以有0个或者多个参数。
它的底层就是用一个数组去接收的，实际函数执行的时候，再去数组里面去取。
函数参数传的是对象，变量，模板参数传的是类型！！
函数参数可以有多个，用逗号分隔，模板参数也可以有多个。
（非类型模板参数必须是整型，其余的都得是类型）

// Args是一个模板参数包，args是一个函数形参参数包，这两个参数包是配对的。
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
// 这里可以是class，也可以是typename，这里的Args可以自己取名，但是最好是这个
template <class ...Args>
void ShowList(Args... args)
{}

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

下面这样直接打印args[i]的方式打开参数包是不允许的

using namespace std;//可变参数的函数模板
template <class ...Args>
void ShowList(Args... args)
{//可以用这种方式获取到我们的参数包里面的参数的个数cout << sizeof...(args) << endl;// 不支持，不能这么玩for (size_t i = 0; i < sizeof...(args); ++i){cout << args[i] << " ";}cout << endl;
}int main()
{string str("hello");ShowList();ShowList(1);ShowList(1, 'A');ShowList(1, 'A', str);return 0;
}

那如果我们想要拿到参数里面的参数怎么办呢？
首先sizeof可以帮助我们知道参数个数的多少。

using namespace std;//可变参数的函数模板
template <class ...Args>
void ShowList(Args... args)
{cout << sizeof...(args) << endl;
}int main()
{string str("hello");ShowList();ShowList(1);ShowList(1, 'A');ShowList(1, 'A', str);return 0;
}

1.通过递归调用的方式取出参数包中的内容

//当参数包中没有任何参数的时候，会匹配这个函数，从而让我们跳出递归循环
void ShowList()
{cout << endl;
}// Args... args代表N个参数包（N >= 0）
//增加一个模板参数T
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{cout << "ShowList("<<val<<", " << sizeof...(args) << "参数包)" <<" ";//通过递归推断我们参数包里面的元素//也就是用我们的val每次都取出参数包中的第一个参数，从而实现对于我们参数包的内容的读取ShowList(args...);
}int main()
{string str("hello");//第一个参数传给上面的val，后面的参数传给参数包ShowList(1, 'A', str);ShowList(1, 'A', str, 2, 3, 5.555);return 0;
}

这样我们的可变参数包就可以实现我们任意多个参数的传入和接收。

2.列表初始化读取参数包中的内容

template<class T>
int PrintArg(const T& x)
{cout << x << " ";return 0;
}// Args... args代表N个参数包（N >= 0）
template <class ...Args>
void ShowList(Args... args)
{//{}中有多少个值，我们的a就会开辟多大的空间，然后就会依次展开这个参数包中的内容，并且知道需要展开多少次//(因为我们的a在开辟的过程中会调用参数包的元素次构造函数，然后每一次构造的时候，就将参数包的一个元素展开，传入我们上面的PrintArg中，然后将我们PrintArg的返回值作为我们a[]中的元素)//然后再参数包展开的过程中，我们调用PrintArg(args)，从而将已经展开的参数给打印出来int a[] = { PrintArg(args)... };cout << endl;
}int main()
{string str("hello");ShowList(1, 'A', str);ShowList(1, 'A', str, 2, 3, 5.555);return 0;
}

3.emplace的实现

这里使用万能引用，就能够灵活地引用各种左值和右值

emplace_back和我们的push_back有什么区别？

emplace_back可以接收多个参数，但是我们的push_back只能接收一个参数

int main()
{// 没有区别vector<int> v1;v1.push_back(1);v1.emplace_back(2);//这里我们的vector中存储的是pair类型的vector<pair<zhuyuan::string, int>> v2;//如果是我们的push_back的话，我们一定只能传pair结构的对象进去//因为push_back只有一个参数v2.push_back(make_pair("sort", 1));//但是如果是emplace_back的话，我们可以不make_pair，直接传一个参数包进去//因为我们的empalce_back可以有多个参数v2.emplace_back(make_pair("sort", 1));v2.emplace_back("sort", 1);return 0;
}

区别在于push_back的话，先需要make_pair，make_pair需要先构造一个pair对象，然后push_back这个pair对象，这个pair对象构造出来，有可能是左值，也可能是右值，然后push_back可能调用左值版本，或者是右值版本。
也就是说，push_back的话，是构造+拷贝构造或者移动构造（左值走拷贝构造，右值走移动构造）

如果是emplace_back的话，我拿到的是pair的参数包，我们可以直接将这个参数包一直一层层传递，传到最后的时候，直接用这个参数包去构造我们的pair。所以emplace_back在这种场景下会显得更加高效。

代码验证：

class Date
{
public://构造函数Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){cout << "Date(int year = 1, int month = 1, int day = 1)" << endl;}//拷贝构造Date(const Date& d):_year(d._year), _month(d._month), _day(d._day){cout << "Date(const Date& d)" << endl;}//拷贝赋值Date& operator=(const Date& d){cout << "Date& operator=(const Date& d))" << endl;return *this;}private:int _year;int _month;int _day;
};int main()
{vector<Date> v3;v3.push_back(Date(2022,11,16));cout <<"---------------------------------"<<endl;v3.emplace_back(2022, 11, 16);cout <<"---------------------------------"<<endl;list<Date> lt1;lt1.push_back(Date(2022, 11, 16));cout << "---------------------------------" << endl;lt1.emplace_back(2022,   11, 16);return 0;
}

从上面的运行结果来看，我们的再vector下并没有验证出来，但是在list的情况下，我们观察到emplace_back并没有拷贝构造，因为它是将我们的参数包一层层传到底层，然后再在底层用我们的可变参数包进行对象的构建。所以其中并没有拷贝构造的过程。

所以在一定程度上，使用emplace_back比push_back更加高效，建议使用。

九、lambda表达式

像函数使用的对象/类型
1.函数指针
2.仿函数/函数对象
3.lambda

greater< int >与greater< int >()

我们传类似于less或者是greater，什么时候我们要在其后面加上()？
如果是下面这种情况，我们传递的是对象的话，我们就需要加上()
也就是我们这里的compare comp，也就是写greater< int >()

那如果是这种模板参数传入类型的话，我们就不需要加上()
也就是直接写==greater< int >==就可以了

之前我们的排序，我们需要将我们具体的排序法则传入

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());
}

这样非常麻烦，还要单独定义一个比较的函数作为参数传入。
并且一个成员，我们就需要写两种比较方式，一种升序，一种降序，非常麻烦。
这时，我们就可以使用lambda表达式进行优化。

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函数不能做任何事情。

int main()
{// 两个数相加的lambda//捕捉列表，参数列表，返回值，函数体//这个对象没有明确的类型名称，这里我们先使用auto传给add1auto add1 = [](int a, int b)->int{return a + b; };//然后像普通函数一样去用就可以了。cout << add1(1, 2) << endl;
}

或者是省略返回值

int main()
{// 省略返回值auto add2 = [](int a, int b){return a + b; };cout << add2(1, 2) << endl;
}

交换变量的lambda

int main()
{// 交换变量的lambdaint x = 0, y = 1;//捕捉列表，参数列表，返回值类型，函数体auto swap1 = [](int& x1, int& x2)->void{int tmp = x1; x1 = x2; x2 = tmp; };swap1(x, y);cout << x << ":" << y << endl;
}

lambda可以定义在局部，作为一个简单的函数。
交换变量还可以像下面这样写

int main()
{// 交换变量的lambdaint x = 0, y = 1;auto swap2 = [](int& x1, int& x2){int tmp = x1;x1 = x2;x2 = tmp;};swap2(x, y);cout << x << ":" << y << endl;
}

不传参数交换x,y
我们可以不传参数，然后写一个捕捉列表

int main()
{// 交换变量的lambdaint x = 0, y = 1;//捕捉列表只能捕捉和lambda同一个作用域中的对象// 不传参数交换x y的lambda  -- 捕捉列表// 默认捕捉的对象不能修改，我们需要加上参数mutable，让其变成可变的// 虽然我们将x,y捕捉过来了，但是我们这里的捕捉是传值捕捉，并不会修改x,y本身。// 形参不影响实参！auto swap3 = [x, y]()mutable{int tmp = x;x = y;y = tmp;};swap3();cout << x << ":" << y << endl;
}

我们可以使用传引用捕捉的方式，让我们的x,y发生交换

int main()
{// 交换变量的lambdaint x = 0, y = 1;//传引用捕捉auto swap3 = [&x, &y]{int tmp = x;x = y;y = tmp;};swap3();cout << x << ":" << y << endl;return 0;
}

然后我们上面的代码就可以这样修改来改成我们的lambda表达式的版本，来对我们的商品进行排序

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._name < g2._name;});//按照名字进行降序排序sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._name > g2._name;});//按照价格的升序排序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;});
}

捕捉列表的说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针

注意：
a. 父作用域指包含lambda函数的语句块

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：
[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量。（所有变量都以传值捕捉，但是a和b用引用捕捉）
[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

d. 在块作用域以外的lambda函数捕捉列表必须为空。

e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。

f. lambda表达式之间不能相互赋值，即使看起来类型相同

举例：

int main()
{int a,b,c,d,e;a=b=c=d=e=1;//全部传值捕捉auto f1=[=](){cout<<a<<b<<c<<d<<e<<endl;};f1();//混合捕捉a=b=c=d=e=1;auto f2=[=,&a](){a++;cout<<a<<b<<c<<d<<e<<endl;};f2();//混合捕捉a=b=c=d=e=1;auto f3=[&,a](){b++;c++;d++;e++;cout<<a<<b<<c<<d<<e<<endl;};f3();return 0;
}

lambda可以捕捉父作用域的变量

int main()
{int a,b,c,d,e;a=b=c=d=e=1;//混合捕捉a=b=c=d=e=1;if(a){//混合捕捉auto f4=[&,a](){b++;c++;d++;e++;cout<<a<<b<<c<<d<<e<<endl;};f4();}return 0;
}

这里的父作用域值得是其lambda所在的函数，指的是当前函数所在的栈帧里面的变量。

int f=1;
int main()
{int a,b,c,d,e;a=b=c=d=e=1;//混合捕捉a=b=c=d=e=1;if(a){//混合捕捉auto f4=[&,a](){b++;c++;d++;e++;f++;cout<<a<<b<<c<<d<<e<<f<<endl;};f4();}return 0;
}

这里我们观察到这里的全局变量也是可以捕捉到的。全局变量在数据段，静态区，哪个位置都能够调用到全局变量。

下面这样写的话就捕捉不到了

void func()
{int a,b,c,d,e;a=b=c=d=e=1;
}
int main()
{func();auto f4=[&,a](){b++;c++;d++;e++;cout<<a<<b<<c<<d<<e<<endl;};f4();
}

1.对象的生命周期和存储区域有关系
2.对象的作用域会受全局，局部，类域，命名空间域的影响
作用域关联的是编译器编译的时候，用的地方能否找到的问题
现在自己所属的域里面去找，然后再去全局去找，找不到就报错。

捕捉列表本质上是在传参，然后看我们的捕捉列表中的写法，让有的参数传值，有的参数传引用

lambda是怎么实现的

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);
// lambdaauto r2 = [=](double monty, int year) -> double {return monty * rate * year;};r2(10000, 2);return 0;
}

所以lambda调用的时候是operate()
底层是将lambda转换成一个仿函数对象的类，然后这个类的名称是lambda_uuid。

//lambda_uuid
class lambda_xxx
{
};

这里（call）调用的函数是lambda::再加上UUID（唯一标识符（基本上是唯一的）），防止我们的lambda因为重名而出现不必要的错误。
然后你捕捉的参数都是通过传参传进去的。

所以说lambd的底层其实就是一个仿函数

所以这里的lambda对于我们来说是匿名的，但是对于编译器来说其实是有名字的。

lambda不能互相赋值的问题，由我们上面的原理中可以知道，我们两个不同的lambda的uuid是不同的，是两个不同的类型，所以不能相互赋值。

void (*PF)();
int main()
{auto f1 = []{cout << "hello world" << endl; };auto f2 = []{cout << "hello world" << endl; };
//f1 = f2; // 编译失败--->提示找不到operator=()
// 允许使用一个lambda表达式拷贝构造一个新的副本auto f3(f2);f3();
// 可以将lambda表达式赋值给相同类型的函数指针PF = f2;PF();return 0;
}

十、包装器

function包装器

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

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;
}

这里我们观察到我们的类模板被实例化成了三份

那有没有办法只实例化成一份呢？
我们就需要使用包装器将其包装一下
（比方说我们送礼，可以用红包包装一下，这样你红包给的多还是给得少就不会有影响了）

那为什么一定要包装呢？
比防说遇到事件响应问题，这里我们需要先知道什么是事件？
就是发生了某个行为（我们按了一个快捷键组合，对应的就需要有一个响应，比方说ctrl+c就会复制）
比方说map<string,函数>，也就是我们输入了一个string，也就是我们的快捷键，我们就需要从map中查找到对应的函数，并执行对应的函数，这样我们就能够做到事件响应。
（或者比方说网络中的增删查改，你传入一个命令，它就要执行对应的操作。）
我们这里对应的行为是一个函数调用，这里的函数调用可能是函数指针，也可能是函数对象，或者是lambda表达式对象，那么我们这里的map<string,函数>的函数这里的类型应该如何去定义呢？
这里我们就需要用到包装器进行包装。

std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

模板参数说明：
Ret: 被调用函数的返回类型（返回值的类型）
Args…：被调用函数的形参（可变参数的参数包，参数包作为函数的参数包）

那我们如何包装呢

// 使用方法如下：
#include <functional>
int f(int a, int b)
{return a + b;
}
struct Functor
{
public:int operator() (int a, int b){return a + b;}
};
class Plus
{
public:static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return a + b;}
};
int main()
{// 函数名(函数指针)std::function<int(int, int)> func1 = f;cout << func1(1, 2) << endl;// 函数对象std::function<int(int, int)> func2 = Functor();cout << func2(1, 2) << endl;// lamber表达式std::function<int(int, int)> func3 = [](const int a, const int b){return a + b; };cout << func3(1, 2) << endl;//绑定静态的// 类的成员函数std::function<int(int, int)> func4 = Plus::plusi;cout << func4(1, 2) << endl;//绑定非静态的，需要加&std::function<double(Plus, double, double)> func5 = &Plus::plusd;//成员函数的指针不能直接调用，需要用对象去调用，所以我们需要传一个对象进去cout << func5(Plus(), 1.1, 2.2) << endl;return 0;
}

然后我们使用包装器解决我们上面模板多次实例化的问题

#include <functional>
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()
{// 函数名std::function<double(double)> func1 = f;cout << useF(func1, 11.11) << endl;
// 函数对象std::function<double(double)> func2 = Functor();cout << useF(func2, 11.11) << endl;
// lamber表达式std::function<double(double)> func3 = [](double d)->double{ return d /4; };cout << useF(func3, 11.11) << endl;return 0;
}

包装器的一些应用场景

/

这是我们之前的解题思路

然后在我们学习了C++11之后，我们就可以这样写了
这里写的就是一个类似于事件响应的代码。

class Solution {
public:int evalRPN(vector<string>& tokens) {stack<long long> st;//生成一个包装器，参数是long long ，返回值也是long longmap<string,function<long long(long long,long long)>> opFuncMap={//四个pair，多个pair的初始化列表直接使用initializer_list构造初始化{"+",[](long long a,long long b){return a+b;}},{"-",[](long long a,long long b){return a-b;}},{"*",[](long long a,long long b){return a*b;}},{"/",[](long long a,long long b){return a/b;}}};for(auto& str:tokens){if(opFuncMap.count(str))//操作符{//返回对应的lambda//栈中先出来的是右操作数，后出来的是左操作数long long right=st.top();st.pop();long long left=st.top();st.pop();st.push(opFuncMap[str](left,right));}else//操作数{//将其转换成longlong 类型再入栈st.push(stoll(str));}}return st.top();}
};

函数指针和仿函数可以写出实实在在的类型，但是lambda写不出类型，因为lambda函数对我们的使用者而言是匿名的，但是因为lambda可以用包装器包装，所以可以用包装器去包装lambda之后，然后使用我们的lambda。

绑定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);

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
调用bind的一般形式：auto newCallable = bind(callable,arg_list);
其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。
arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推

（第一个参数为函数，第二个参数为参数包）

（用来确定你要绑定的参数和不绑定的参数）

1.绑定参数调整顺序

using namespace placeholders;
int main()
{
//    function<int(int,int)> funcPlus=Plus;
//    function<int(Sub,int,int)> funcSub=&Sub::sub;
//    map<string,function<int(int,int)>> opFuncMap=
//    {
//            {'+', Plus},
//            {'-',&Sub::sub}
//    };int x=10,y=2;Div(x,y);//假设我们想要调整div的参数的顺序//第一个参数是可调用对象//你要调整的是形参，调整的不是实参//我们这里用占位去代表形参_1代表第一个参数，_2代表第二个参数，以此类推//调整顺序//_1 _2……是定义在命名空间中的，代表绑定函数对象的形参，1代表第一个形参，_2代表第二个形参，以此类推
//    bind(Div,placeholders::_1,placeholders::_2);
//要么让编译器自动推断auto bindFunc1=bind(Div,_1,_2);//或者这样写function<int(int,int)> bindFunc2=bind(Div,_1,_2);//然后我们想要调整形参的话，需要这样写function<int(int,int)> bindFunc3=bind(Div,_2,_1);cout<<bindFunc1(x,y)<<endl;cout<<bindFunc2(x,y)<<endl;cout<<bindFunc3(x,y)<<endl;
}

所以及时你这里交换了顺序，_1依旧代表的是第一个参数，_2代表的是第二个参数。

2.绑定参数的个数

#include <iostream>
#include <map>
#include <string>
using namespace std;
#include <functional>int Div(int a,int b)
{return a/b;
}
//普通的全局函数
int Plus(int a, int b)
{return a + b;
}int Mul(int a, int b,int rate)
{return a * b* rate;
}//如果这里的Sub是一个成员函数
class Sub
{
public://成员函数int sub(int a, int b){return a - b;}
};using namespace placeholders;
int main()
{//调整这个数，绑定死固定参数function<int(int,int)> funcPlus=Plus;function<int(int,int)> funcDiv=Div;//将三个参数绑定成两个参数function<int(int,int)> funcSub=bind(&Sub::sub,Sub(),_1,_2);//这里我们直接将这个第三个参数给定为1function<int(int,int)> funcMul=bind(Mul,_1,_2,1);map<string,function<int(int,int)>> opFuncMap={{"+", funcPlus},{"-",funcSub},{"*",funcMul},{"/",funcDiv}};cout<<funcPlus(1,2)<<endl;cout<<funcSub(1,2)<<endl;cout<<funcMul(1,2)<<endl;cout<<funcDiv(5,2)<<endl;cout<<opFuncMap["+"](1,2)<<endl;cout<<opFuncMap["-"](1,2)<<endl;cout<<opFuncMap["*"](1,2)<<endl;cout<<opFuncMap["/"](5,2)<<endl;
}

C++【C++11】

文章目录

• 一、统一的列表初始化
• • 1.用{}来初始化元素
  • 2.initializer_list
• 二、自动类型推断
• • 3.auto
  • 4.decltype
• 三、指针
• • 5.nullptr
  • 6.范围for
• 四、STL中的一些新变化
• • 1.新增加的容器
  • 2.容器内部的变化
• 五、左值引用和右值引用
• • 1.什么是左值，什么是右值
  • 左值
  • 右值
  • • 那么左值引用能不能给右值取别名？
    • 那么右值引用能不能给左值取别名
    • 右值引用的应用
    • 移动构造和移动赋值
    • • 移动构造
      • 移动赋值
    • 右值引用版本的插入
• 六、万能引用和完美转发
• • 1.万能引用
  • 2.完美转发
• 七、新的类功能
• • 1.移动构造的自动生成条件
  • default和delete
  • • 要求delete关键字实现，一个类，只能在堆上创建对象
  • 继承中的final和override关键字
• 八、可变参数模板
• • 1.通过递归调用的方式取出参数包中的内容
  • 2.列表初始化读取参数包中的内容
  • 3.emplace的实现
  • • emplace_back和我们的push_back有什么区别？
• 九、lambda表达式
• • greater< int >与greater< int >()
  • lambda表达式的语法
  • 捕捉列表的说明
  • lambda是怎么实现的
• 十、包装器
• • function包装器
  • 包装器的一些应用场景
  • 绑定bind
  • 1.绑定参数调整顺序
  • 2.绑定参数的个数

一、统一的列表初始化

1.用{}来初始化元素

在C++98中，标准允许使用花括号{}对数组或者结构体元素进行统一的列表初始值设定。比如：

struct Point
{int _x;int _y;
};
int main()
{int array1[] = { 1, 2, 3, 4, 5 };int array2[5] = { 0 };Point p = { 1, 2 };return 0;
}

但是在C++11中，我们都可以使用{}来对我们的元素进行初始化
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <array>
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()
{int x1 = 1;// 要能看懂，但是不建议使用int x2 = { 2 };int x3 { 2 };// 都是在调用构造函数Date d1(2022, 11, 22);// C++11 要能看懂，但是不建议使用Date d2 = {2022, 11, 11}; // ->调用构造函数Date d3{ 2022, 11, 11 };return 0;
}

2.initializer_list

C++11中有了一种新的类型，initializer_list，语法上原生支持通过大括号的方式初始化给它。它就像一个顺序表一样，支持迭代器，但是不支持插入数据。

int main()
{// 调用支持list (initializer_list<value_type> il）类似这样的构造函数vector<int> v1 = { 1, 2, 3, 4, 5, 6 };vector<int> v2 { 1, 2, 3, 4, 5, 6 };list<int> lt1 = { 1, 2, 3, 4, 5, 6 };list<int> lt2{ 1, 2, 3, 4, 5, 6 };//c++11这里新增了一个类型initializer_list类型来实现，是这里默认需要的一个容器auto x = { 1, 2, 3, 4, 5, 6 };cout << typeid(x).name() << endl;return 0;
}

那我们的vector等容器又是如何支持大括号的初始化的呢？
因为我们的C++11同时也对我们的库函数进行了更新，让我们的库函数都支持通过initializer_list来进行构造。
这里我们查看一下vector的构造函数中多了一个构造方法，也就是我们的initializer


那如何让我们自己之前写过的vector支持通过initializer来初始化

vector(initializer_list<T> il):_start(nullptr),_finish(nullptr),_end_of_storage(nullptr){reserve(il.size());iterator it=begin();for(auto&e:il){push_back(e);}}

测试代码

void myvector_test18(){vector<int> v1={1,2,3,4,5,6,7,8,9,10};vector<int> v2{1,2,3,4,5,6,7,8,9,10};for(auto e:v2){cout<<e<<" ";}cout<<endl;}

当然，我们的map,set,pair等容器也可以通过这种方式进行构造

#include <iostream>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <array>
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(2022, 11, 22);Date d2 = {2022, 11, 11}; Date d3{ 2022, 11, 11 };vector<Date> v3 = {d1, d2, d3};vector<Date> v4 = { { 2022, 1, 1 }, {2022, 11, 11} };string s1 = "11111";// 构造//这相当于就是隐式类型转换//构造一个pair我们也可以通过{}的方式构造map<string, string> dict = { { "sort", "排序" }, { "insert", "插入" } };return 0;
}

当然在我们的C++11的库中，还将许多赋值也进行了重载，让其能够支持initializer进行赋值

下面是我们的测试代码

#include <iostream>
#include <map>
using namespace std;int main()
{// 构造//这相当于就是隐式类型转换//构造一个pair我们也可以通过{}的方式构造map<string, string> dict = { { "sort", "排序" }, { "insert", "插入" } };// 赋值重载//这里不写auto让编译器自动去推断，我们的编译器是没有办法匹配出来的。initializer_list<pair<const string, string>> kvil = { { "left", "左边" }, { "left", "左边" } };dict = kvil;return 0;
}

总结：
C++11之后，一切对象都可以用列表初始化。但是我们建议普通对象还是用以前的方式初始化，容器可以采用花括号进行初始化。

二、自动类型推断

3.auto

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

int main()
{int i = 10;auto p = &i;auto pf = strcpy;cout << typeid(p).name() << endl;cout << typeid(pf).name() << endl;map<string, string> dict = { {"sort", "排序"}, {"insert", "插入"} };//如果我们这里要自己写的话，需要写一长串，但是使用auto的话就非常方便//map<string, string>::iterator it = dict.begin();auto it = dict.begin();return 0;
}

如果我们这里使用auto的话，我们上面代码中的迭代器的类型等等，我们都不用自己手写，就非常方便，但是我们如果使用了auto进行自动类型推断，我们代码的可读性就会变差，但是有些编译器会给你标识出来（比方说clion）。

4.decltype

typename可以推导对象的类型，但是我们不能通过这个推导出来的类型来定义我们的对象，只是单纯地拿到这个类型的字符串。
但是如果我们想要用推导出来的类型重新定义一个新的对象呢？

int main()
{int x = 10;// typeid拿到只是类型的字符串，不能用这个再去定义对象什么的// 下面这样写会报错的,没有下面这样的用法//	typeid(x).name() y = 20;decltype(x) y1 = 20.22;//auto和decltype是不一样的，我们的auto这里推导出来的是double，也就是我们右边的赋值的元素的类型是什么，我们auto推导出来也就是什么//但是我们的deltype推导出来的类型是x的类型，也就是intauto y2 = 20.22;cout << y1 << endl;cout << y2 << endl;return 0;
}

三、指针

5.nullptr

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

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

6.范围for

这里的范围for和我们java中的增强for有些相似，底层是一个迭代器。
可以查看我们之前的博客中的迭代器和范围for相关的部分

int main()
{vector<int> tmp{1,2,3,4,5,6,7,8,9};for(auto i:tmp){cout<<i<<" ";}cout<<endl;
}

四、STL中的一些新变化

1.新增加的容器

< array >和< forward_list >显得有些鸡肋
因为< array >是固定大小的数组容器，不支持尾插和尾删，支持[]迭代器。
C++11增加这个的初衷是为了替代c语言中的数组

int main()
{const size_t N = 100;int a1[N];// C语言数组越界检查，越界读基本检查不出来，越界写是抽查a1[N];//a1[N] = 1;a1[N+5] = 1;// 越界读写都可以被检查出来// 实际情况：array用得很少，一方面大家用c数组用惯了// 用array不如用vector + resize去替代c数组array<int, N> a2;a2[N];a2[N] = 1;a2[N + 5] = 1;return 0;
}

< forward_list >是一个单链表，我们的< list >是双向链表，在使用的时候其实< forward_list >插入的是在我们当前指定位置的后一个位置插入，然后erase并不是擦除当前的位置，而是擦除当前位置的下一个位置。

2.容器内部的变化

1.都支持了initializer_list构造，用来支持列表初始化
2.比较鸡肋的接口，比如cbegin,cend系列
3.移动构造和移动赋值，用来对标拷贝构造和拷贝赋值，在某些场景下可以提高效率
（set&&x）;
（set& operator=(set&&x）
4.右值引用的参数的插入

五、左值引用和右值引用

1.什么是左值，什么是右值

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

左值

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

int main()
{//左值：可以取它的地址int a = 10;const int b = 20;//这里的*p是左值int* p = &a;*p = 100;//左值一般都可以对其进行赋值，但是除了上面的b因为我们的b是一个const无法被修改
}

int main()
{// 以下的p、b、c、*p都是左值int* p = new int(0);int b = 1;const int c = 2;// 以下几个是对上面左值的左值引用int*& rp = p;int& rb = b;const int& rc = c;int& pvalue = *p;return 0;
}

右值

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

int main()
{double x = 1.1, y = 2.2;// 以下几个都是常见的右值//字面量10;//表达式，传值返回，会产生一个临时对象x + y;//传值返回的函数，因为会产生一个临时对象fmin(x, y);//右值不能放到赋值符号的左边// 这里编译会报错：error C2106: “=”: 左操作数必须为左值10 = 1;x + y = 1;fmin(x, y) = 1;return 0;
}

右值的特点就是不能取地址。
所以我们下面这样写的话是会报错的

int main()
{double x = 1.1, y = 2.2;// 右值:不能取地址10;x + y;fmin(x, y);cout << &10 << endl;cout << &(x + y) << endl;}

右值引用就是给我们的右值取别名。

int main()
{double x = 1.1, y = 2.2;// 以下几个都是对右值的右值引用int&& rr1 = 10;double&& rr2 = x + y;double&& rr3 = fmin(x, y);
}

那么左值引用能不能给右值取别名？

（左值引用可以引用右值嘛？）

int main()
{// 有条件的支持// 左值引用可以引用右值吗？ const的左值引用可以//这里的r1是不可以的，这里的r2是可以的double& r1 = x + y;const double& r2 = x + y;
}

右值引用是没办法被改变的，所以我们如果想要通过左值引用去引用一个右值，我们就需要加上const。
所以我们最好给我们的函数传参的时候加上const，这样的话，我们的函数既能够接收左值也能够接收右值

// x既能接收左值，也能接收右值
template<class T>
void Func(const T& x)
{}

那么右值引用能不能给左值取别名

（右值引用可以引用左值嘛？不可以，需要有语法支持）
右值引用可以引用move以后的左值

int main()
{int b = 1;// 右值引用可以引用左值吗？可以引用move以后的左值//这里的rr5编译器是会报错的，但是rr6不会，可以正常编译通过。int&& rr5 = b;int&& rr6 = move(b);}

左值引用可以引用右值吗？ const的左值引用可以
右值引用可以引用左值吗？可以引用move以后的左值

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

也就是可以理解成我们的右值在被右值引用之后，就变成了一个左值

int main()
{double x = 1.1, y = 2.2;int&& rr1 = 10;const double&& rr2 = x + y;rr1 = 20;rr2 = 5.5; // 报错return 0;
}

右值引用的应用

引用的价值：减少拷贝，尤其是深拷贝
左值引用：还可以用作输出型参数

左值引用解决了哪些问题？
①做参数：1.减少拷贝，提高效率 2.做输出型参数
②做返回值：1.减少拷贝，提高效率 2.引用返回可以修改返回对象（比方说operator[]就是这样使用的）

左值引用在什么情况下有盲区？

如果我们有一个对象需要返回，那么如果我们采用的是左值引用的话，我们在将这个这个对象返回的时候，我么得这个对象已经被析构了，那么我们就没有办法成功返回对象。
比方说下面的情况

//case1
string to_string (int val)
//case2
vector<vector<int>> generate(int numRows)

我们需要将上面的两行代码修改为下面的代码。

//case1
to_string(int val,string&str)
//case2
void generate(int numRows,vector<vector<int>& w)

也就是说我们需要将我们的对象用左值引用的方式传入我们的函数，这样才能够避免在我们的函数中开辟了一个对象，然后因为我们的函数执行完，这个对象被析构，没有办法被返回的问题。
但是这样不符合使用习惯。
C++11出右值引用的一个重要功能就是解决上面的问题。

如何解决？
比方说我们这里写了一个string类

namespace zhuyuan
{class string{public:typedef char* iterator;iterator begin(){return _str;}iterator end(){return _str + _size;}string(const char* str = ""):_size(strlen(str)), _capacity(_size){_str = new char[_capacity + 1];strcpy(_str, str);}void swap(string& s){::swap(_str, s._str);::swap(_size, s._size);::swap(_capacity, s._capacity);}// 拷贝构造string(const string& s):_str(nullptr){cout << "string(const string& s) -- 拷贝构造(深拷贝)" << endl;//现代写法//string tmp(s._str);//swap(s);//传统写法_str = new char[s._capacity+1];strcpy(_str, s._str);_size = s._size;_capacity = s._capacity;}// 拷贝赋值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){push_back(ch);return *this;}const char* c_str() const{return _str;}private:char* _str;size_t _size;size_t _capacity;};string to_string(int value){bool flag = true;if (value < 0){flag = false;value = 0 - value;}zhuyuan::string str;while (value > 0){int x = value % 10;value /= 10;str += ('0' + x);}if (flag == false){str += '-';}std::reverse(str.begin(), str.end());return str;}
}

移动构造和移动赋值

想要优化上面代码中的拷贝，我们就需要实现移动构造和移动赋值。

移动构造

 // 移动构造string(string&& s):_str(nullptr), _size(0), _capacity(0){cout << "string(string&& s) -- 资源转移" << endl;swap(s);}

移动赋值

// 移动赋值string& operator=(string&& s){cout << "string& operator=(string s) -- 移动赋值(资源移动)" << endl;swap(s);return *this;}

相比于拷贝构造和拷贝赋值，其参数都是左值引用，如果我们这里没有移动构造和移动赋值，因为我们上面的拷贝构造和拷贝赋值的参数为const类型的，所以我们调用左值的时候，都会走拷贝构造和拷贝赋值函数。
但是我们这里写了移动构造和移动赋值的话，左值引用就会调用我们这里的移动构造和移动赋值。
（编译器在匹配类型的之后，会去寻找最匹配的）

C++11又对右值进行了进一步的划分
1、内置类型的右值：纯右值
2、自定义类型的右值：将亡值
右值一般是一些字面量，函数表达式的返回值，表达式的值，这些临时的对象的声明周青往往就只有在它所在的那一行，所以将其称为将亡值（资源即将被销毁）。
（这里我们需要将这里的右值的资源给swap另外一个对象，用另外一个对象的存在，实现资源转移。）

int main()
{zhuyuan::string str1("hello");zhuyuan::string str2(str1); //  拷贝构造//如果我们的右边是一个右值，move之后的就是右值zhuyuan::string str3(move(str1)); // 移动构造return 0;
}

我们观察到我们对象str1中的内容被拷贝到了我们的str3中

拷贝构造的代价相比移动构造更加大，拷贝构造了一个对象，我们还需要将这个旧的对象给释放，也就是一次深拷贝，再加上一次资源的释放。但是我们的移动构造是将我们的资源转移过来，不需要拷贝。

本来我们下面的代码应该是有一次拷贝构造和一次移动构造的，但是由于我们编译器的优化，因为我们这里的str出了我们的作用域就会销毁掉，所以我们的编译器会将其优化，也就是直接将其识别为右值（将亡值），然后就进行资源的转移，然后调用移动构造，然后再调用移动赋值，将str中的资源转移到我们的ret，从而实现拷贝的减少。

zhuyuan::string to_string(int value)
{zhuyuan::string str;//...//拷贝构造，返回结果作为左值return str;
}
int main()
{//移动构造zhuyuan::string ret= to_string(-3456);return 0;
}

我们这里的右值引用并不是直接起作用的，而是通过移动构造和移动赋值间接起作用的。
所以我们只要实现了移动构造和移动拷贝，我们就不用像前面那样传入一个对象，函数操作完成，再将其返回了，更加符合我们的使用习惯（可以直接将我们的对象返回了）。

我们再来看一下库中的实现

int main()
{std::string s1("hello world");std::string s2(s1); // 拷贝构造
//	 std::string s3(s1+s2);//表达式的返回对象是一个将亡值，也就是一个右值，这里我们使用的就是右值拷贝std::string s3 = s1 + s2; // 移动构造std::string s4 = move(s1);return 0;
}

我们通过调试来观察一下，这是初始状态

运行到s2(s1)之后，这里是深拷贝构造

执行到s3=s1+s2，这里的s1+s2的结果是一个将亡值，这个将亡值直接被移动构造给了s3

然后运行到s4=move(s1)，这里就是一个右值引用，我们s1中的内容直接移动给了s4，我们从下面的调试中观察到其实我们的s1中已经没有内容了

我们观察到在c++11之后，在我们的STL库中的容器都提供了这个移动构造的方法

和移动赋值

右值引用版本的插入

我们观察c++11的STL库中还增加了右值引用版本的插入

移动构造和移动赋值解决了传值返回这些类型对象的问题。

int main()
{vector<zhuyuan::string> v;//这里的hello是一个左值zhuyuan::string s1("hello");v.push_back(s1);cout << "----------------------------------" << endl;//这里的world是一个右值v.push_back(zhuyuan::string("world"));v.push_back("world");cout << "===================================" << endl;list<zhuyuan::string> lt;zhuyuan::string s2("hello");lt.push_back(s2);cout << "----------------------------------" << endl;lt.push_back(zhuyuan::string("world"));lt.push_back("world");return 0;
}

插入的过程中，如果传递对象是右值对象，那么进行资源转移，减少拷贝，STL中的插入的接口在C++11后都会提供。

六、万能引用和完美转发

1.万能引用

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; }// 万能引用：t既能引用左值，也能引用右值
// 引用折叠
template<typename T>
void PerfectForward(T&& t)
{Fun(t);
}

#include "list.h"int main()
{PerfectForward(10);int a;PerfectForward(a);   PerfectForward(std::move(a));const int b = 8;PerfectForward(b);		    PerfectForward(std::move(b)); return 0;
}

那这里的t的属性是什么呢？
我们发现无论我们传入的是左值还是右值，它调用的都是左值

2.完美转发

像上面的万能引用，我们的编译器全部都会被处理成左值，那么我们怎么才能保持我们的传入的参数原本的属性呢？这里我们就需要用到我们的完美转发

首先我们给我们自己写的list.h加上右值引用的插入函数

void push_back(T&& x)
{insert(end(), (x));
}iterator insert(iterator pos, T&& x)
{Node* cur = pos._node;Node* prev = cur->_prev;Node* newnode = new Node(x);// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);
}

template<typename T>
void PerfectForward(T&& t)
{// 完美转发：保持t引用对象属性Fun(std::forward<T>(t));
}#include "list.h"测试代码int main()
{PerfectForward(10);           // 右值int a;PerfectForward(a);            // 左值PerfectForward(std::move(a)); // 右值const int b = 8;PerfectForward(b);		      // const 左值PerfectForward(std::move(b)); // const 右值zhuyuan::list<zhuyuan::string> lt;zhuyuan::string s1("hello");lt.push_back(s1);cout << "----------------------------------" << endl;lt.push_back("world");return 0;
}

这里我们注意到，我们的拷贝构造全部都是深拷贝，没有匹配上我们的右值构造的版本，这是为什么？
因为我们上面的push_back中是我们上述的万能引用，所以传入的参数全部都被当成了左值引用，如果我们还想要使用右值引用的话，我们需要将其变成完美转发！

void push_back(T&& x)
{insert(end(), std::forward<T>(x));
}//然后给我们的list_node也写一个右值引用的版本
//只要往下一层传递，我们就需要完美转发一下
list_node(T&& x):_data(std::forward<T>(x)), _next(nullptr), _prev(nullptr){}iterator insert(iterator pos, T&& x)
{Node* cur = pos._node;Node* prev = cur->_prev;Node* newnode = new Node(std::forward<T>(x));// prev newnode curprev->_next = newnode;newnode->_prev = prev;newnode->_next = cur;cur->_prev = newnode;return iterator(newnode);
}

OK，我们下面的终于调用了资源转移（右值引用）。

七、新的类功能

原来的C++中，有6个默认的成员函数：

1.构造函数
2.析构函数
3.拷贝构造函数
4.拷贝赋值函数
5.取地址重载
6.const取地址重载

在C++11之后默认成员函数有8个，增加了移动构造和移动赋值运算符重载
（拷贝构造和拷贝赋值是针对于左值的拷贝（const左值引用既可以针对左值也可以针对右值））
（移动构造和移动赋值是针对右值的拷贝）

1.移动构造的自动生成条件

如果你没有自己实现移动构造函数，且没有实现析构函数 、拷贝构造、拷贝赋值重载中的任意一个（不过说实话，这里面只要有一个需要我们自己手写，其他的一般也都是需要我们手写的）。那么编译器会自动生成一个默认移动构造。

默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

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

1.拷贝对象需要深拷贝时，自己写移动构造和移动赋值，比如：string，vector，list

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& operator=(const Person& p){if(this != &p){_name = p._name;_age = p._age;}return *this;}~Person(){}private:zhuyuan::string _name;int _age;
};int main()
{Person s1("张三", 7);Person s2 = s1; // 拷贝构造Person s3 = std::move(s1); // 移动构造 （没有移动构造，再调用拷贝构造）return 0;
}

我们注意到我们这里的调用的都是拷贝构造，如果我们想要使用移动构造的话，我们就需要将我们上面自己写的析构，拷贝，负值重载给去掉

class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}// 会默认生成拷贝构造+移动构造
private:zhuyuan::string _name;int _age;
};int main()
{Person s1("张三", 7);Person s2 = s1; // 拷贝构造Person s3 = std::move(s1); // 移动构造 （没有移动构造，再调用拷贝构造）return 0;
}

移动赋值和移动构造类似

class Person
{
public:Person(const char* name = "", int age = 0):_name(name), _age(age){}// 会默认生成拷贝构造+移动构造
private:zhuyuan::string _name;int _age;
};int main()
{Person s1("张三", 7);Person s2 = s1; // 拷贝构造Person s3 = std::move(s1); // 移动构造 （没有移动构造，再调用拷贝构造）Person s4;s4 = std::move(s2);return 0;
}

也就是说深拷贝的类，一般都是需要我们自己手动写的。
如果是像上面这样的person类，让编译器自动生成就可以了。（自定义类型会自动调用析构）

default和delete

default

	//强制编译器生成默认的移动构造Person(Person&& p)=default;

比防说我们自己写了一个拷贝构造，那么编译器就不会自动生成拷贝构造了，那么，想要让我们的编译器生成默认的移动构造的话，我们可以像上面这样，加上一个default

delete
如果我们不想让编译器生成默认的构造方法，我们可以给我们的参数加上delete，这样我们的Person对象就不能被拷贝了。

	// 不想让Person对象拷贝Person(const Person& p) = delete;

要求delete关键字实现，一个类，只能在堆上创建对象

// 要求delete关键字实现，一个类，只能在堆上创建对象
class HeapOnly
{
public:HeapOnly(){_str = new char[10];}//将析构变成delete，没有一个对象能够创建对象//因为变量出了作用域，一定要调用析构函数~HeapOnly() = delete;void Destroy(){//将空间释放delete[] _str;//this的值就是我们的对象的地址，我们不能直接写delete (this)，因为delete被禁用了//operator delete(this);}private:char* _str;//...
};int main()
{//栈//HeapOnly hp1;//静态区//static HeapOnly hp2;//为什么new可以创建出来？//因为new出来的对象返回的是一个指针，这个指针会在堆上开辟一块空间，并不会去调用析构函数，所以可以成功创建出来HeapOnly* ptr = new HeapOnly;//析构函数被禁用了，没办法用delete//delete ptr;//调用我们自己写的Destory来释放空间//下面两个都是可以的ptr->Destroy();//operator delete(ptr);return 0;
}

继承中的final和override关键字

final：可以修饰我们的类，不能被继承，虚函数不能被重写
override：检查子类中的虚函数是否完成了重写，没有完成从写就会报错

八、可变参数模板

可变参数也就是说可以有0个或者多个参数。
它的底层就是用一个数组去接收的，实际函数执行的时候，再去数组里面去取。
函数参数传的是对象，变量，模板参数传的是类型！！
函数参数可以有多个，用逗号分隔，模板参数也可以有多个。
（非类型模板参数必须是整型，其余的都得是类型）

// Args是一个模板参数包，args是一个函数形参参数包，这两个参数包是配对的。
// 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。
// 这里可以是class，也可以是typename，这里的Args可以自己取名，但是最好是这个
template <class ...Args>
void ShowList(Args... args)
{}

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

下面这样直接打印args[i]的方式打开参数包是不允许的

using namespace std;//可变参数的函数模板
template <class ...Args>
void ShowList(Args... args)
{//可以用这种方式获取到我们的参数包里面的参数的个数cout << sizeof...(args) << endl;// 不支持，不能这么玩for (size_t i = 0; i < sizeof...(args); ++i){cout << args[i] << " ";}cout << endl;
}int main()
{string str("hello");ShowList();ShowList(1);ShowList(1, 'A');ShowList(1, 'A', str);return 0;
}

那如果我们想要拿到参数里面的参数怎么办呢？
首先sizeof可以帮助我们知道参数个数的多少。

using namespace std;//可变参数的函数模板
template <class ...Args>
void ShowList(Args... args)
{cout << sizeof...(args) << endl;
}int main()
{string str("hello");ShowList();ShowList(1);ShowList(1, 'A');ShowList(1, 'A', str);return 0;
}

1.通过递归调用的方式取出参数包中的内容

//当参数包中没有任何参数的时候，会匹配这个函数，从而让我们跳出递归循环
void ShowList()
{cout << endl;
}// Args... args代表N个参数包（N >= 0）
//增加一个模板参数T
template <class T, class ...Args>
void ShowList(const T& val, Args... args)
{cout << "ShowList("<<val<<", " << sizeof...(args) << "参数包)" <<" ";//通过递归推断我们参数包里面的元素//也就是用我们的val每次都取出参数包中的第一个参数，从而实现对于我们参数包的内容的读取ShowList(args...);
}int main()
{string str("hello");//第一个参数传给上面的val，后面的参数传给参数包ShowList(1, 'A', str);ShowList(1, 'A', str, 2, 3, 5.555);return 0;
}

这样我们的可变参数包就可以实现我们任意多个参数的传入和接收。

2.列表初始化读取参数包中的内容

template<class T>
int PrintArg(const T& x)
{cout << x << " ";return 0;
}// Args... args代表N个参数包（N >= 0）
template <class ...Args>
void ShowList(Args... args)
{//{}中有多少个值，我们的a就会开辟多大的空间，然后就会依次展开这个参数包中的内容，并且知道需要展开多少次//(因为我们的a在开辟的过程中会调用参数包的元素次构造函数，然后每一次构造的时候，就将参数包的一个元素展开，传入我们上面的PrintArg中，然后将我们PrintArg的返回值作为我们a[]中的元素)//然后再参数包展开的过程中，我们调用PrintArg(args)，从而将已经展开的参数给打印出来int a[] = { PrintArg(args)... };cout << endl;
}int main()
{string str("hello");ShowList(1, 'A', str);ShowList(1, 'A', str, 2, 3, 5.555);return 0;
}

3.emplace的实现

这里使用万能引用，就能够灵活地引用各种左值和右值

emplace_back和我们的push_back有什么区别？

emplace_back可以接收多个参数，但是我们的push_back只能接收一个参数

int main()
{// 没有区别vector<int> v1;v1.push_back(1);v1.emplace_back(2);//这里我们的vector中存储的是pair类型的vector<pair<zhuyuan::string, int>> v2;//如果是我们的push_back的话，我们一定只能传pair结构的对象进去//因为push_back只有一个参数v2.push_back(make_pair("sort", 1));//但是如果是emplace_back的话，我们可以不make_pair，直接传一个参数包进去//因为我们的empalce_back可以有多个参数v2.emplace_back(make_pair("sort", 1));v2.emplace_back("sort", 1);return 0;
}

区别在于push_back的话，先需要make_pair，make_pair需要先构造一个pair对象，然后push_back这个pair对象，这个pair对象构造出来，有可能是左值，也可能是右值，然后push_back可能调用左值版本，或者是右值版本。
也就是说，push_back的话，是构造+拷贝构造或者移动构造（左值走拷贝构造，右值走移动构造）

如果是emplace_back的话，我拿到的是pair的参数包，我们可以直接将这个参数包一直一层层传递，传到最后的时候，直接用这个参数包去构造我们的pair。所以emplace_back在这种场景下会显得更加高效。

代码验证：

class Date
{
public://构造函数Date(int year = 1, int month = 1, int day = 1):_year(year), _month(month), _day(day){cout << "Date(int year = 1, int month = 1, int day = 1)" << endl;}//拷贝构造Date(const Date& d):_year(d._year), _month(d._month), _day(d._day){cout << "Date(const Date& d)" << endl;}//拷贝赋值Date& operator=(const Date& d){cout << "Date& operator=(const Date& d))" << endl;return *this;}private:int _year;int _month;int _day;
};int main()
{vector<Date> v3;v3.push_back(Date(2022,11,16));cout <<"---------------------------------"<<endl;v3.emplace_back(2022, 11, 16);cout <<"---------------------------------"<<endl;list<Date> lt1;lt1.push_back(Date(2022, 11, 16));cout << "---------------------------------" << endl;lt1.emplace_back(2022,   11, 16);return 0;
}

从上面的运行结果来看，我们的再vector下并没有验证出来，但是在list的情况下，我们观察到emplace_back并没有拷贝构造，因为它是将我们的参数包一层层传到底层，然后再在底层用我们的可变参数包进行对象的构建。所以其中并没有拷贝构造的过程。

所以在一定程度上，使用emplace_back比push_back更加高效，建议使用。

九、lambda表达式

像函数使用的对象/类型
1.函数指针
2.仿函数/函数对象
3.lambda

greater< int >与greater< int >()

我们传类似于less或者是greater，什么时候我们要在其后面加上()？
如果是下面这种情况，我们传递的是对象的话，我们就需要加上()
也就是我们这里的compare comp，也就是写greater< int >()

那如果是这种模板参数传入类型的话，我们就不需要加上()
也就是直接写==greater< int >==就可以了

之前我们的排序，我们需要将我们具体的排序法则传入

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());
}

这样非常麻烦，还要单独定义一个比较的函数作为参数传入。
并且一个成员，我们就需要写两种比较方式，一种升序，一种降序，非常麻烦。
这时，我们就可以使用lambda表达式进行优化。

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函数不能做任何事情。

int main()
{// 两个数相加的lambda//捕捉列表，参数列表，返回值，函数体//这个对象没有明确的类型名称，这里我们先使用auto传给add1auto add1 = [](int a, int b)->int{return a + b; };//然后像普通函数一样去用就可以了。cout << add1(1, 2) << endl;
}

或者是省略返回值

int main()
{// 省略返回值auto add2 = [](int a, int b){return a + b; };cout << add2(1, 2) << endl;
}

交换变量的lambda

int main()
{// 交换变量的lambdaint x = 0, y = 1;//捕捉列表，参数列表，返回值类型，函数体auto swap1 = [](int& x1, int& x2)->void{int tmp = x1; x1 = x2; x2 = tmp; };swap1(x, y);cout << x << ":" << y << endl;
}

lambda可以定义在局部，作为一个简单的函数。
交换变量还可以像下面这样写

int main()
{// 交换变量的lambdaint x = 0, y = 1;auto swap2 = [](int& x1, int& x2){int tmp = x1;x1 = x2;x2 = tmp;};swap2(x, y);cout << x << ":" << y << endl;
}

不传参数交换x,y
我们可以不传参数，然后写一个捕捉列表

int main()
{// 交换变量的lambdaint x = 0, y = 1;//捕捉列表只能捕捉和lambda同一个作用域中的对象// 不传参数交换x y的lambda  -- 捕捉列表// 默认捕捉的对象不能修改，我们需要加上参数mutable，让其变成可变的// 虽然我们将x,y捕捉过来了，但是我们这里的捕捉是传值捕捉，并不会修改x,y本身。// 形参不影响实参！auto swap3 = [x, y]()mutable{int tmp = x;x = y;y = tmp;};swap3();cout << x << ":" << y << endl;
}

我们可以使用传引用捕捉的方式，让我们的x,y发生交换

int main()
{// 交换变量的lambdaint x = 0, y = 1;//传引用捕捉auto swap3 = [&x, &y]{int tmp = x;x = y;y = tmp;};swap3();cout << x << ":" << y << endl;return 0;
}

然后我们上面的代码就可以这样修改来改成我们的lambda表达式的版本，来对我们的商品进行排序

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._name < g2._name;});//按照名字进行降序排序sort(v.begin(), v.end(), [](const Goods& g1, const Goods& g2){return g1._name > g2._name;});//按照价格的升序排序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;});
}

捕捉列表的说明

捕捉列表描述了上下文中那些数据可以被lambda使用，以及使用的方式传值还是传引用。
[var]：表示值传递方式捕捉变量var
[=]：表示值传递方式捕获所有父作用域中的变量(包括this)
[&var]：表示引用传递捕捉变量var
[&]：表示引用传递捕捉所有父作用域中的变量(包括this)
[this]：表示值传递方式捕捉当前的this指针

注意：
a. 父作用域指包含lambda函数的语句块

b. 语法上捕捉列表可由多个捕捉项组成，并以逗号分割。
比如：
[=, &a, &b]：以引用传递的方式捕捉变量a和b，值传递方式捕捉其他所有变量。（所有变量都以传值捕捉，但是a和b用引用捕捉）
[&，a, this]：值传递方式捕捉变量a和this，引用方式捕捉其他变量

c. 捕捉列表不允许变量重复传递，否则就会导致编译错误。
比如：[=, a]：=已经以值传递方式捕捉了所有变量，捕捉a重复

d. 在块作用域以外的lambda函数捕捉列表必须为空。

e. 在块作用域中的lambda函数仅能捕捉父作用域中局部变量，捕捉任何非此作用域或者非局部变量都会导致编译报错。

f. lambda表达式之间不能相互赋值，即使看起来类型相同

举例：

int main()
{int a,b,c,d,e;a=b=c=d=e=1;//全部传值捕捉auto f1=[=](){cout<<a<<b<<c<<d<<e<<endl;};f1();//混合捕捉a=b=c=d=e=1;auto f2=[=,&a](){a++;cout<<a<<b<<c<<d<<e<<endl;};f2();//混合捕捉a=b=c=d=e=1;auto f3=[&,a](){b++;c++;d++;e++;cout<<a<<b<<c<<d<<e<<endl;};f3();return 0;
}

lambda可以捕捉父作用域的变量

int main()
{int a,b,c,d,e;a=b=c=d=e=1;//混合捕捉a=b=c=d=e=1;if(a){//混合捕捉auto f4=[&,a](){b++;c++;d++;e++;cout<<a<<b<<c<<d<<e<<endl;};f4();}return 0;
}

这里的父作用域值得是其lambda所在的函数，指的是当前函数所在的栈帧里面的变量。

int f=1;
int main()
{int a,b,c,d,e;a=b=c=d=e=1;//混合捕捉a=b=c=d=e=1;if(a){//混合捕捉auto f4=[&,a](){b++;c++;d++;e++;f++;cout<<a<<b<<c<<d<<e<<f<<endl;};f4();}return 0;
}

这里我们观察到这里的全局变量也是可以捕捉到的。全局变量在数据段，静态区，哪个位置都能够调用到全局变量。

下面这样写的话就捕捉不到了

void func()
{int a,b,c,d,e;a=b=c=d=e=1;
}
int main()
{func();auto f4=[&,a](){b++;c++;d++;e++;cout<<a<<b<<c<<d<<e<<endl;};f4();
}

1.对象的生命周期和存储区域有关系
2.对象的作用域会受全局，局部，类域，命名空间域的影响
作用域关联的是编译器编译的时候，用的地方能否找到的问题
现在自己所属的域里面去找，然后再去全局去找，找不到就报错。

捕捉列表本质上是在传参，然后看我们的捕捉列表中的写法，让有的参数传值，有的参数传引用

lambda是怎么实现的

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);
// lambdaauto r2 = [=](double monty, int year) -> double {return monty * rate * year;};r2(10000, 2);return 0;
}

所以lambda调用的时候是operate()
底层是将lambda转换成一个仿函数对象的类，然后这个类的名称是lambda_uuid。

//lambda_uuid
class lambda_xxx
{
};

这里（call）调用的函数是lambda::再加上UUID（唯一标识符（基本上是唯一的）），防止我们的lambda因为重名而出现不必要的错误。
然后你捕捉的参数都是通过传参传进去的。

所以说lambd的底层其实就是一个仿函数

所以这里的lambda对于我们来说是匿名的，但是对于编译器来说其实是有名字的。

lambda不能互相赋值的问题，由我们上面的原理中可以知道，我们两个不同的lambda的uuid是不同的，是两个不同的类型，所以不能相互赋值。

void (*PF)();
int main()
{auto f1 = []{cout << "hello world" << endl; };auto f2 = []{cout << "hello world" << endl; };
//f1 = f2; // 编译失败--->提示找不到operator=()
// 允许使用一个lambda表达式拷贝构造一个新的副本auto f3(f2);f3();
// 可以将lambda表达式赋值给相同类型的函数指针PF = f2;PF();return 0;
}

十、包装器

function包装器

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

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;
}

这里我们观察到我们的类模板被实例化成了三份

那有没有办法只实例化成一份呢？
我们就需要使用包装器将其包装一下
（比方说我们送礼，可以用红包包装一下，这样你红包给的多还是给得少就不会有影响了）

那为什么一定要包装呢？
比防说遇到事件响应问题，这里我们需要先知道什么是事件？
就是发生了某个行为（我们按了一个快捷键组合，对应的就需要有一个响应，比方说ctrl+c就会复制）
比方说map<string,函数>，也就是我们输入了一个string，也就是我们的快捷键，我们就需要从map中查找到对应的函数，并执行对应的函数，这样我们就能够做到事件响应。
（或者比方说网络中的增删查改，你传入一个命令，它就要执行对应的操作。）
我们这里对应的行为是一个函数调用，这里的函数调用可能是函数指针，也可能是函数对象，或者是lambda表达式对象，那么我们这里的map<string,函数>的函数这里的类型应该如何去定义呢？
这里我们就需要用到包装器进行包装。

std::function在头文件<functional>
// 类模板原型如下
template <class T> function; // undefined
template <class Ret, class... Args>
class function<Ret(Args...)>;

模板参数说明：
Ret: 被调用函数的返回类型（返回值的类型）
Args…：被调用函数的形参（可变参数的参数包，参数包作为函数的参数包）

那我们如何包装呢

// 使用方法如下：
#include <functional>
int f(int a, int b)
{return a + b;
}
struct Functor
{
public:int operator() (int a, int b){return a + b;}
};
class Plus
{
public:static int plusi(int a, int b){return a + b;}double plusd(double a, double b){return a + b;}
};
int main()
{// 函数名(函数指针)std::function<int(int, int)> func1 = f;cout << func1(1, 2) << endl;// 函数对象std::function<int(int, int)> func2 = Functor();cout << func2(1, 2) << endl;// lamber表达式std::function<int(int, int)> func3 = [](const int a, const int b){return a + b; };cout << func3(1, 2) << endl;//绑定静态的// 类的成员函数std::function<int(int, int)> func4 = Plus::plusi;cout << func4(1, 2) << endl;//绑定非静态的，需要加&std::function<double(Plus, double, double)> func5 = &Plus::plusd;//成员函数的指针不能直接调用，需要用对象去调用，所以我们需要传一个对象进去cout << func5(Plus(), 1.1, 2.2) << endl;return 0;
}

然后我们使用包装器解决我们上面模板多次实例化的问题

#include <functional>
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()
{// 函数名std::function<double(double)> func1 = f;cout << useF(func1, 11.11) << endl;
// 函数对象std::function<double(double)> func2 = Functor();cout << useF(func2, 11.11) << endl;
// lamber表达式std::function<double(double)> func3 = [](double d)->double{ return d /4; };cout << useF(func3, 11.11) << endl;return 0;
}

包装器的一些应用场景

/

这是我们之前的解题思路

然后在我们学习了C++11之后，我们就可以这样写了
这里写的就是一个类似于事件响应的代码。

class Solution {
public:int evalRPN(vector<string>& tokens) {stack<long long> st;//生成一个包装器，参数是long long ，返回值也是long longmap<string,function<long long(long long,long long)>> opFuncMap={//四个pair，多个pair的初始化列表直接使用initializer_list构造初始化{"+",[](long long a,long long b){return a+b;}},{"-",[](long long a,long long b){return a-b;}},{"*",[](long long a,long long b){return a*b;}},{"/",[](long long a,long long b){return a/b;}}};for(auto& str:tokens){if(opFuncMap.count(str))//操作符{//返回对应的lambda//栈中先出来的是右操作数，后出来的是左操作数long long right=st.top();st.pop();long long left=st.top();st.pop();st.push(opFuncMap[str](left,right));}else//操作数{//将其转换成longlong 类型再入栈st.push(stoll(str));}}return st.top();}
};

函数指针和仿函数可以写出实实在在的类型，但是lambda写不出类型，因为lambda函数对我们的使用者而言是匿名的，但是因为lambda可以用包装器包装，所以可以用包装器去包装lambda之后，然后使用我们的lambda。

绑定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);

可以将bind函数看作是一个通用的函数适配器，它接受一个可调用对象，生成一个新的可调用对象来“适应”原对象的参数列表。
调用bind的一般形式：auto newCallable = bind(callable,arg_list);
其中，newCallable本身是一个可调用对象，arg_list是一个逗号分隔的参数列表，对应给定的callable的参数。当我们调用newCallable时，newCallable会调用callable,并传给它arg_list中的参数。
arg_list中的参数可能包含形如_n的名字，其中n是一个整数，这些参数是“占位符”，表示newCallable的参数，它们占据了传递给newCallable的参数的“位置”。数值n表示生成的可调用对象中参数的位置：_1为newCallable的第一个参数，_2为第二个参数，以此类推

（第一个参数为函数，第二个参数为参数包）

（用来确定你要绑定的参数和不绑定的参数）

1.绑定参数调整顺序

using namespace placeholders;
int main()
{
//    function<int(int,int)> funcPlus=Plus;
//    function<int(Sub,int,int)> funcSub=&Sub::sub;
//    map<string,function<int(int,int)>> opFuncMap=
//    {
//            {'+', Plus},
//            {'-',&Sub::sub}
//    };int x=10,y=2;Div(x,y);//假设我们想要调整div的参数的顺序//第一个参数是可调用对象//你要调整的是形参，调整的不是实参//我们这里用占位去代表形参_1代表第一个参数，_2代表第二个参数，以此类推//调整顺序//_1 _2……是定义在命名空间中的，代表绑定函数对象的形参，1代表第一个形参，_2代表第二个形参，以此类推
//    bind(Div,placeholders::_1,placeholders::_2);
//要么让编译器自动推断auto bindFunc1=bind(Div,_1,_2);//或者这样写function<int(int,int)> bindFunc2=bind(Div,_1,_2);//然后我们想要调整形参的话，需要这样写function<int(int,int)> bindFunc3=bind(Div,_2,_1);cout<<bindFunc1(x,y)<<endl;cout<<bindFunc2(x,y)<<endl;cout<<bindFunc3(x,y)<<endl;
}

所以及时你这里交换了顺序，_1依旧代表的是第一个参数，_2代表的是第二个参数。

2.绑定参数的个数

#include <iostream>
#include <map>
#include <string>
using namespace std;
#include <functional>int Div(int a,int b)
{return a/b;
}
//普通的全局函数
int Plus(int a, int b)
{return a + b;
}int Mul(int a, int b,int rate)
{return a * b* rate;
}//如果这里的Sub是一个成员函数
class Sub
{
public://成员函数int sub(int a, int b){return a - b;}
};using namespace placeholders;
int main()
{//调整这个数，绑定死固定参数function<int(int,int)> funcPlus=Plus;function<int(int,int)> funcDiv=Div;//将三个参数绑定成两个参数function<int(int,int)> funcSub=bind(&Sub::sub,Sub(),_1,_2);//这里我们直接将这个第三个参数给定为1function<int(int,int)> funcMul=bind(Mul,_1,_2,1);map<string,function<int(int,int)>> opFuncMap={{"+", funcPlus},{"-",funcSub},{"*",funcMul},{"/",funcDiv}};cout<<funcPlus(1,2)<<endl;cout<<funcSub(1,2)<<endl;cout<<funcMul(1,2)<<endl;cout<<funcDiv(5,2)<<endl;cout<<opFuncMap["+"](1,2)<<endl;cout<<opFuncMap["-"](1,2)<<endl;cout<<opFuncMap["*"](1,2)<<endl;cout<<opFuncMap["/"](5,2)<<endl;
}