-
C++【C++11】
文章目录
一、统一的列表初始化
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
但是在C++11中，我们都可以使用{}来对我们的元素进行初始化
C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。#include#include #include #include 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; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
2.initializer_list
C++11中有了一种新的类型，initializer_list，语法上原生支持通过大括号的方式初始化给它。它就像一个顺序表一样，支持迭代器，但是不支持插入数据。
int main() { // 调用支持list (initializer_listil）类似这样的构造函数 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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
那我们的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); } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
测试代码
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
当然，我们的map,set,pair等容器也可以通过这种方式进行构造
#include#include #include #include 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; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
当然在我们的C++11的库中，还将许多赋值也进行了重载，让其能够支持initializer进行赋值
下面是我们的测试代码#include#include 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; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
总结：
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- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
如果我们这里使用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的类型，也就是int auto y2 = 20.22; cout << y1 << endl; cout << y2 << endl; return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
三、指针
5.nullptr
由于C++中NULL被定义成字面量0，这样就可能会带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，C++11中新增了nullptr，用于表示空指针。
#ifndef NULL #ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif #endif- 1
- 2
- 3
- 4
- 5
- 6
- 7
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
四、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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
< 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无法被修改 }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
右值
右值也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。右值引用就是对右值的引用，给右值取别名。
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
右值的特点就是不能取地址。
所以我们下面这样写的话是会报错的int main() { double x = 1.1, y = 2.2; // 右值:不能取地址 10; x + y; fmin(x, y); cout << &10 << endl; cout << &(x + y) << endl; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
右值引用就是给我们的右值取别名。
int main() { double x = 1.1, y = 2.2; // 以下几个都是对右值的右值引用 int&& rr1 = 10; double&& rr2 = x + y; double&& rr3 = fmin(x, y); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
那么左值引用能不能给右值取别名？
（左值引用可以引用右值嘛？）
int main() { // 有条件的支持 // 左值引用可以引用右值吗？ const的左值引用可以 //这里的r1是不可以的，这里的r2是可以的 double& r1 = x + y; const double& r2 = x + y; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
右值引用是没办法被改变的，所以我们如果想要通过左值引用去引用一个右值，我们就需要加上const。
所以我们最好给我们的函数传参的时候加上const，这样的话，我们的函数既能够接收左值也能够接收右值// x既能接收左值，也能接收右值 template<class T> void Func(const T& x) {}- 1
- 2
- 3
- 4
那么右值引用能不能给左值取别名
（右值引用可以引用左值嘛？不可以，需要有语法支持）
右值引用可以引用move以后的左值int main() { int b = 1; // 右值引用可以引用左值吗？可以引用move以后的左值 //这里的rr5编译器是会报错的，但是rr6不会，可以正常编译通过。 int&& rr5 = b; int&& rr6 = move(b); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
左值引用可以引用右值吗？ 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
- 3
- 4
- 5
- 6
- 7
- 8
- 9
右值引用的应用
引用的价值：减少拷贝，尤其是深拷贝
左值引用：还可以用作输出型参数左值引用解决了哪些问题？
①做参数：1.减少拷贝，提高效率 2.做输出型参数
②做返回值：1.减少拷贝，提高效率 2.引用返回可以修改返回对象（比方说operator[]就是这样使用的）左值引用在什么情况下有盲区？
如果我们有一个对象需要返回，那么如果我们采用的是左值引用的话，我们在将这个这个对象返回的时候，我么得这个对象已经被析构了，那么我们就没有办法成功返回对象。
比方说下面的情况//case1 string to_string (int val) //case2 vector<vector<int>> generate(int numRows)- 1
- 2
- 3
- 4
我们需要将上面的两行代码修改为下面的代码。
//case1 to_string(int val,string&str) //case2 void generate(int numRows,vector<vector<int>& w)- 1
- 2
- 3
- 4
也就是说我们需要将我们的对象用左值引用的方式传入我们的函数，这样才能够避免在我们的函数中开辟了一个对象，然后因为我们的函数执行完，这个对象被析构，没有办法被返回的问题。
但是这样不符合使用习惯。
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; } }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
- 139
移动构造和移动赋值
想要优化上面代码中的拷贝，我们就需要实现移动构造和移动赋值。
移动构造
// 移动构造 string(string&& s) :_str(nullptr) , _size(0) , _capacity(0) { cout << "string(string&& s) -- 资源转移" << endl; swap(s); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
移动赋值
// 移动赋值 string& operator=(string&& s) { cout << "string& operator=(string s) -- 移动赋值(资源移动)" << endl; swap(s); return *this; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
相比于拷贝构造和拷贝赋值，其参数都是左值引用，如果我们这里没有移动构造和移动赋值，因为我们上面的拷贝构造和拷贝赋值的参数为const类型的，所以我们调用左值的时候，都会走拷贝构造和拷贝赋值函数。
但是我们这里写了移动构造和移动赋值的话，左值引用就会调用我们这里的移动构造和移动赋值。
（编译器在匹配类型的之后，会去寻找最匹配的）C++11又对右值进行了进一步的划分
1、内置类型的右值：纯右值
2、自定义类型的右值：将亡值
右值一般是一些字面量，函数表达式的返回值，表达式的值，这些临时的对象的声明周青往往就只有在它所在的那一行，所以将其称为将亡值（资源即将被销毁）。
（这里我们需要将这里的右值的资源给swap另外一个对象，用另外一个对象的存在，实现资源转移。）int main() { zhuyuan::string str1("hello"); zhuyuan::string str2(str1); // 拷贝构造 //如果我们的右边是一个右值，move之后的就是右值 zhuyuan::string str3(move(str1)); // 移动构造 return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
我们观察到我们对象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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
我们这里的右值引用并不是直接起作用的，而是通过移动构造和移动赋值间接起作用的。
所以我们只要实现了移动构造和移动拷贝，我们就不用像前面那样传入一个对象，函数操作完成，再将其返回了，更加符合我们的使用习惯（可以直接将我们的对象返回了）。我们再来看一下库中的实现
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
我们通过调试来观察一下，这是初始状态
运行到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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
插入的过程中，如果传递对象是右值对象，那么进行资源转移，减少拷贝，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); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
#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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
那这里的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 cur prev->_next = newnode; newnode->_prev = prev; newnode->_next = cur; cur->_prev = newnode; return iterator(newnode); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
这里我们注意到，我们的拷贝构造全部都是深拷贝，没有匹配上我们的右值构造的版本，这是为什么？
因为我们上面的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 cur prev->_next = newnode; newnode->_prev = prev; newnode->_next = cur; cur->_prev = newnode; return iterator(newnode); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
我们注意到我们这里的调用的都是拷贝构造，如果我们想要使用移动构造的话，我们就需要将我们上面自己写的析构，拷贝，负值重载给去掉
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
移动赋值和移动构造类似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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
也就是说深拷贝的类，一般都是需要我们自己手动写的。
如果是像上面这样的person类，让编译器自动生成就可以了。（自定义类型会自动调用析构）default和delete
default
//强制编译器生成默认的移动构造 Person(Person&& p)=default;- 1
- 2
比防说我们自己写了一个拷贝构造，那么编译器就不会自动生成拷贝构造了，那么，想要让我们的编译器生成默认的移动构造的话，我们可以像上面这样，加上一个default
delete
如果我们不想让编译器生成默认的构造方法，我们可以给我们的参数加上delete，这样我们的Person对象就不能被拷贝了。// 不想让Person对象拷贝 Person(const Person& p) = delete;- 1
- 2
要求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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
继承中的final和override关键字
https://blog.csdn.net/weixin_62684026/article/details/127336464
final：可以修饰我们的类，不能被继承，虚函数不能被重写
override：检查子类中的虚函数是否完成了重写，没有完成从写就会报错八、可变参数模板
可变参数也就是说可以有0个或者多个参数。
它的底层就是用一个数组去接收的，实际函数执行的时候，再去数组里面去取。
函数参数传的是对象，变量，模板参数传的是类型！！
函数参数可以有多个，用逗号分隔，模板参数也可以有多个。
（非类型模板参数必须是整型，其余的都得是类型）// Args是一个模板参数包，args是一个函数形参参数包，这两个参数包是配对的。 // 声明一个参数包Args...args，这个参数包中可以包含0到任意个模板参数。 // 这里可以是class，也可以是typename，这里的Args可以自己取名，但是最好是这个 template <class ...Args> void ShowList(Args... args) {}- 1
- 2
- 3
- 4
- 5
- 6
上面的参数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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
那如果我们想要拿到参数里面的参数怎么办呢？
首先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
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
这样我们的可变参数包就可以实现我们任意多个参数的传入和接收。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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
区别在于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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
从上面的运行结果来看，我们的再vector下并没有验证出来，但是在list的情况下，我们观察到emplace_back并没有拷贝构造，因为它是将我们的参数包一层层传到底层，然后再在底层用我们的可变参数包进行对象的构建。所以其中并没有拷贝构造的过程。所以在一定程度上，使用emplace_back比push_back更加高效，建议使用。
九、lambda表达式
像函数使用的对象/类型
1.函数指针
2.仿函数/函数对象
3.lambdagreater< 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()); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
这样非常麻烦，还要单独定义一个比较的函数作为参数传入。
并且一个成员，我们就需要写两种比较方式，一种升序，一种降序，非常麻烦。
这时，我们就可以使用lambda表达式进行优化。lambda表达式的语法
lambda表达式书写格式：[capture-list] (parameters) mutable -> return-type {statement}
（捕捉列表，参数列表，返回值类型，函数体实现）-
lambda表达式各部分说明：
[capture-list] : 捕捉列表，该列表总是出现在lambda函数的开始位置，编译器根据[]来判断接下来的代码是否为lambda函数，捕捉列表能够捕捉上下文中的变量供lambda函数使用。(parameters)：参数列表。与普通函数的参数列表一致，如果不需要参数传递，则可以连同()一起省略（无参的时候可以省略）。
mutable：默认情况下，lambda函数总是一个const函数，mutable可以取消其常量性。使用该修饰符时，参数列表不可省略(即使参数为空)
->returntype：返回值类型。用追踪返回类型形式声明函数的返回值类型，没有返回值时此部分可省略（一般都是不写的，让它自己推）。返回值类型明确情况下，也可省略，由编译器对返回类型进行推导。
{statement}：函数体。在该函数体内，除了可以使用其参数外，还可以使用所有捕获到的变量。
注意：
在lambda函数定义中，参数列表和返回值类型都是可选部分，而捕捉列表和函数体可以为空。因此C++11中最简单的lambda函数为：[]{}; 该lambda函数不能做任何事情。int main() { // 两个数相加的lambda //捕捉列表，参数列表，返回值，函数体 //这个对象没有明确的类型名称，这里我们先使用auto传给add1 auto add1 = [](int a, int b)->int{return a + b; }; //然后像普通函数一样去用就可以了。 cout << add1(1, 2) << endl; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
或者是省略返回值int main() { // 省略返回值 auto add2 = [](int a, int b){return a + b; }; cout << add2(1, 2) << endl; }- 1
- 2
- 3
- 4
- 5
- 6
交换变量的lambda
int main() { // 交换变量的lambda int 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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
lambda可以定义在局部，作为一个简单的函数。
交换变量还可以像下面这样写int main() { // 交换变量的lambda int x = 0, y = 1; auto swap2 = [](int& x1, int& x2) { int tmp = x1; x1 = x2; x2 = tmp; }; swap2(x, y); cout << x << ":" << y << endl; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
不传参数交换x,y
我们可以不传参数，然后写一个捕捉列表int main() { // 交换变量的lambda int 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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
我们可以使用传引用捕捉的方式，让我们的x,y发生交换
int main() { // 交换变量的lambda int x = 0, y = 1; //传引用捕捉 auto swap3 = [&x, &y] { int tmp = x; x = y; y = tmp; }; swap3(); cout << x << ":" << y << endl; return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
然后我们上面的代码就可以这样修改来改成我们的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;}); }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
捕捉列表的说明
捕捉列表描述了上下文中那些数据可以被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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
这里的父作用域值得是其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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
这里我们观察到这里的全局变量也是可以捕捉到的。全局变量在数据段，静态区，哪个位置都能够调用到全局变量。
下面这样写的话就捕捉不到了
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
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
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); // lambda auto r2 = [=](double monty, int year) -> double {return monty * rate * year;}; r2(10000, 2); return 0; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
所以lambda调用的时候是operate()
底层是将lambda转换成一个仿函数对象的类，然后这个类的名称是lambda_uuid。//lambda_uuid class lambda_xxx { };- 1
- 2
- 3
- 4
这里（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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
十、包装器
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; }- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
这里我们观察到我们的类模板被实例化成了三份
那有没有办法只实例化成一份呢？
我们就需要使用包装器将其包装一下
（比方说我们送礼，可以用红包包装一下，这样你红包给的多还是给得少就不会有影响了）那为什么一定要包装呢？
比防说遇到事件响应问题，这里我们需要先知道什么是事件？
就是发生了某个行为（我们按了一个快捷键组合，对应的就需要有一个响应，比方说ctrl+c就会复制）
比方说map
（或者比方说网络中的增删查改，你传入一个命令，它就要执行对应的操作。）
我们这里对应的行为是一个函数调用，这里的函数调用可能是函数指针，也可能是函数对象，或者是lambda表达式对象，那么我们这里的map
这里我们就需要用到包装器进行包装。std::function在头文件<functional> // 类模板原型如下 template <class T> function; // undefined template <class Ret, class... Args> class function<Ret(Args...)>;- 1
- 2
- 3
- 4
- 5
模板参数说明：
Ret: 被调用函数的返回类型（返回值的类型）
Args…：被调用函数的形参（可变参数的参数包，参数包作为函数的参数包）那我们如何包装呢
// 使用方法如下： #includeint 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; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
然后我们使用包装器解决我们上面模板多次实例化的问题
#includetemplate<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; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
包装器的一些应用场景
https://leetcode.cn/problems/evaluate-reverse-polish-notation/
这是我们之前的解题思路
https://blog.csdn.net/weixin_62684026/article/details/127023299
然后在我们学习了C++11之后，我们就可以这样写了
这里写的就是一个类似于事件响应的代码。class Solution { public: int evalRPN(vector<string>& tokens) { stack<long long> st; //生成一个包装器，参数是long long ，返回值也是long long map<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(); } };- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
函数指针和仿函数可以写出实实在在的类型，但是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);- 1
- 2
- 3
- 4
- 5
- 6
可以将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- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
所以及时你这里交换了顺序，_1依旧代表的是第一个参数，_2代表的是第二个参数。2.绑定参数的个数
#include#include #include using namespace std; #include 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); //这里我们直接将这个第三个参数给定为1 function<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; } - 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
-
相关阅读:
〖Python 数据库开发实战 - MySQL篇⑰〗- 聚合函数的使用
华为c语言编程规范
mindspore-softmax进行鸢尾花多分类模型
【JVM】Java内存模型
详解Redis基础数据类型Set增删查（带Java源码）
webpack如何处理css
解决Could not find artifact *** in alimaven的问题
应用OPC解决方案实现控制系统数据的安全交换
【每日一题Day47】LC1774最接近目标价格的甜点成本 | 回溯 哈希表
oracle递归查询（start with connect by prior）以及 树形统计connect_by_root（子节点汇总到父节点）
- 原文地址：https://blog.csdn.net/weixin_62684026/article/details/127893764
