【C++进阶】C++11新特性上篇（万字详解） ﹏ヽ暗。殇╰゛Y 2024-04-20 06:34 77阅读 0赞 > **?C++学习历程：入门** > > -------------------- > > * **博客主页：**[一起去看日落吗][Link 1] > * **持续分享博主的C++学习历程** > * **`博主的能力有限，出现错误希望大家不吝赐教`** > * **分享给大家一句我很喜欢的话：** 也许你现在做的事情，暂时看不到成果，但不要忘记，树?成长之前也要扎根，也要在漫长的时光?中沉淀养分。静下来想一想，哪有这么多的天赋异禀，那些让你羡慕的优秀的人也都曾默默地翻山越岭?。 > > -------------------- > > ![在这里插入图片描述][eabca17da9704379a5f15832a495b4cc.jpeg_pic_center] ♠️ ♥️ ♣️ ♦️ #### 目录 #### * ♠️ 1. C++11简介 * ♠️ 2. 列表初始化 * * ♥️ 2.1 \{\} 初始化 * ♥️ 2.2 std::initializer\_list * ♠️ 3. 声明 * * ♥️ 3.1 auto * ♥️ 3.2 decltype * ♥️ 3.3 nullptr * ♠️ 4. STL中一些变化 * ♠️ 5. final 和 override * ♠️ 6. 右值引用和移动语义 * * ♥️ 6.1 左值引用和右值引用 * ♥️ 6.2 左值引用和右值引用比较 * ♥️ 6.3 右值引用使用场景和意义 * ♥️ 6.4 左值引用使用场景 * ♥️ 6.4 左值引用短板 * ♥️ 6.5 右值引用和移动语义解决上述问题 * ♥️ 6.6 STL容器插入接口函数也增加了右值引用版本 ## ♠️ 1. C++11简介 ## 相比C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，**C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率。** ## ♠️ 2. 列表初始化 ## ### ♥️ 2.1 \{\} 初始化 ### * 在C++98中，标准允许使用花括号\{\}对数组元素进行统一的列表初始值设定。 struct Point { int _x; int _y; }; int main() { int array1[] = { 1, 2, 3, 4, 5 }; int array2[5] = { 0 }; //0 0 0 0 0 Point p = { 1, 2 }; //运用了struct结构体的语法 初始化 return 0; } * C++11扩大了用大括号括起的列表(初始化列表)的使用范围，使其可用于所有的内置类型和用户自定义的类型，使用初始化列表时，可添加等号(=)，也可不添加。 struct Point { int _x; int _y; Point(int x, int y) :_x(x) , _y(y) { } }; 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() { Point p = { 1, 2 }; //Point p{ 1, 2 }; Point* p3 = new Point[3]{ { 1, 1}, { 2, 2 }, { 3, 3 } }; int* p1 = new int(0); int* p2 = new int[5]{ 1,2,3,4,5}; //C++11中 new可以初始化数组 //自定义类型的列表初始化 Date d1(2022, 3, 13); Date d2 = { 2022, 3, 15 }; Date d3{ 2022, 3, 15 }; Date{ 2022,3,15}; int i = 1; int j = { 2 }; int k{ 3 }; return 0; } -------------------- ### ♥️ 2.2 std::initializer\_list ### [std::initializer\_list介绍文档][std_initializer_list] * std::initializer\_list是什么类型 int main() { // the type of il is an initializer_list auto il = { 10, 20, 30 }; cout << typeid(il).name() << endl; return 0; } ![在这里插入图片描述][67be34219bf345e789ebf843ab196f2a.png] * 模拟实现的vector支持\{\}初始化和赋值 template<class T> class vector { public: typedef T* iterator; vector(initializer_list<T> l) { _start = new T[l.size()]; _finish = _start + l.size(); _endofstorage = _start + l.size(); iterator vit = _start; typename initializer_list<T>::iterator lit = l.begin(); while (lit != l.end()) { *vit++ = *lit++; } //for (auto e : l) // *vit++ = e; } vector<T>& operator=(initializer_list<T> l) { vector<T> tmp(l); std::swap(_start, tmp._start); std::swap(_finish, tmp._finish); std::swap(_endofstorage, tmp._endofstorage); return *this; } private: iterator _start; iterator _finish; iterator _endofstorage; }; * std::initializer\_list使用场景 **std::initializer\_list一般是作为构造函数的参数，C++11对STL中的不少容器（像map、vector、list）就增加std::initializer\_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值** class A { public: A(int a, double d, int b) :_a(a) , _d(d) , _b(b) { } private: int _a; double _d; int _b; }; 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() { //内置类型的列表初始化 vector<int> v1 = { 1, 2, 3, 4, 5 }; vector<int> v2{ 1, 2, 3, 4, 5 }; //vector (initializer_list<value_type> il,const allocator_type& alloc = allocator_type()); auto lt1 = { 1, 2, 3, 4}; initializer_list<int> lt2 = { 1, 2, 3, 4 }; //auto=initializer_list<int> map<string, int> dict1 = { pair<string, int>("sort", 1), pair<string, int>("insert", 2) }; map<string, int> dict2 = { { "sort", 1 }, { "insert", 2 } }; //首先{ "sort", 1 }, { "insert", 2 }创建成initializer_list<map<string,int>>类型的对象 //最后map (initializer_list<value_type> il,const key_compare& comp = key_compare(),const allocator_type& alloc = allocator_type()); //这个构造函数初始化dict2 //自定义类型的列表初始化 Date d1(2022, 3, 13); Date d2 = { 2022, 3, 15 }; Date d3{ 2022, 3, 15 }; Date{ 2022, 3, 15 }; A aa1 = { 1, 1.11, 1}; list<A> lt = { { 1, 1.11, 1}, { 2, 2.22, 1} }; //首先{ { 1, 1.11, 1}, { 2, 2.22, 1} }创建成initializer_list<list<A>>类型的对象（首先是A类得有相应的构造函数才行） //最后list的构造函数初始化it return 0; } -------------------- ## ♠️ 3. 声明 ## c++11提供了多种简化声明的方式，尤其是在使用模板时。 ### ♥️ 3.1 auto ### 在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。**C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。** int main() { int i = 10; auto p = &i; auto pf = strcpy; //输出p、pf的类型 cout << typeid(p).name() << endl; cout << typeid(pf).name() << endl; map<string, string> dict = { { "sort", "排序"}, { "insert", "插入"} }; //map<string, string>::iterator it = dict.begin(); auto it = dict.begin(); return 0; } -------------------- ### ♥️ 3.2 decltype ### **关键字decltype将变量的类型声明为表达式指定的类型** // decltype的一些使用使用场景 template<class T1, class T2> void F(T1 t1, T2 t2) { decltype(t1 * t2) ret = t1 * t2; vector<decltype(t1* t2)> v; v.push_back(ret); cout << typeid(ret).name() << endl; } int main() { int i = 10; auto p = &i; auto pf = strcpy; decltype(pf) pf1; //char * (__cdecl*)(char *,char const *) vector<decltype(pf)> v; cout << typeid(p).name() << endl; cout << typeid(pf).name() << endl; return 0; } **注意：decltype与auto的差别：auto必须要求显式初始化，而decltype没要求** -------------------- ### ♥️ 3.3 nullptr ### 由于C++中NULL被定义成字面量0，这样就可能回带来一些问题，因为0既能指针常量，又能表示整形常量。所以出于清晰和安全的角度考虑，**C++11中新增了nullptr，用于表示空指针。** #ifndef NULL #ifdef __cplusplus #define NULL 0 #else #define NULL ((void *)0) #endif #endif -------------------- ## ♠️ 4. STL中一些变化 ## **新容器** 用橘色圈起来是C++11中的一些几个新容器，但是实际最有用的是unordered\_map和 unordered\_set。其他的大家了解一下即可。 ![在这里插入图片描述][077e3e9e611c41df8e7045d42d95168a.png] **容器中的一些新方法** 如果我们再细细去看会发现基本每个容器中都增加了一些C++11的方法，但是其实很多都是用得比较少的。 比如提供了cbegin和cend方法返回const迭代器等等，但是实际意义不大，因为begin和end也是可以返回const迭代器的，这些都是属于锦上添花的操作。 -------------------- ## ♠️ 5. final 和 override ## **final** * final修饰类的时候，表示该类不能被继承 class A final //表示该类是最后一个类 { private: int _year; }; class B : public A //无法继承 { }; * final修饰虚函数时，这个虚函数不能被重写 class A { public: virtual void fun() final//修饰虚函数 { cout << "this is A" << endl; } private: int _year; }; class B : public A { public: virtual void fun()//父类虚函数用final修饰，表示最后一个虚函数，无法重写 { cout << "this is B" << endl; } }; -------------------- **override** * 检查派生类虚函数是否重写了基类某个虚函数，如果没有重写编译报错 class A { public: virtual void fun() { cout << "this is A" << endl; } private: int _year; }; class B : public A { public: virtual void fun() override { cout << "this is B" << endl; } }; -------------------- ## ♠️ 6. 右值引用和移动语义 ## ### ♥️ 6.1 左值引用和右值引用 ### 传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，**无论左值引用还是右值引用，都是给对象取别名。** * 左值引用 左值是一个表示数据的表达式(如变量名或解引用的指针)，我们**可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边**。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。左值引用就是给左值的引用，给左值取别名。 int main() { // 以下的p、b、c、*p都是左值 int* p = new int(0); int b = 1; const int c = 2; // 可以取地址 cout << &p << endl; cout << &b << endl; cout << &c << endl; cout << &(*p) << endl; b = c; // 以下几个是对上面左值的左值引用 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); // 以下几个都是对右值的右值引用 int&& rr1 = 10; double&& rr2 = x + y; double&& rr3 = fmin(x, y); // // 不能取地址 // cout << &10 << endl; // cout << &(x+y) << endl; // cout << &fmin(x, y) << endl; // 这里编译会报错：error C2106: “=”: 左操作数必须为左值 //10 = 1; //x + y = 1; //fmin(x, y) = 1; return 0; } 需要注意的是右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量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; int& rr = rr1; //rr2 = 5.5; // 报错 return 0; } **注意：左值引用可以连续左值引用，而右值引用是不可以连续右值引用的（右值引用后该变量为左值，不能使用右值引用了）** -------------------- ### ♥️ 6.2 左值引用和右值引用比较 ### **左值引用总结：** 1. 左值引用只能引用左值，不能引用右值。 2. 但是const左值引用既可引用左值，也可引用右值 int main() { // 左值引用只能引用左值，不能引用右值。 int a = 10; int& ra1 = a;// ra为a的别名 //int& ra2 = 10;// 编译失败，因为10是右值 // const左值引用既可引用左值，也可引用右值。 const int& ra3 = 10; const int& ra4 = a; return 0; } **右值引用总结：** 1. 右值引用只能右值，不能引用左值。 2. 但是右值引用可以move以后的左值。 int main() { // 右值引用只能右值，不能引用左值 int&& r1 = 10; // error C2440: “初始化”: 无法从“int”转换为“int &&” // message : 无法将左值绑定到右值引用 int a = 10; //int&& r2 = a; //报错 右值引用只能右值，不能引用左值 // 右值引用可以引用move以后的左值 int&& r3 = move(a); return 0; } -------------------- ### ♥️ 6.3 右值引用使用场景和意义 ### **右值引用可以补齐左值引用的短板** namespace lc { class string { public: typedef char* iterator; iterator begin() { return _str; } iterator end() { return _str + _size; } string(const char* str = "") :_size(strlen(str)) , _capacity(_size) { //cout << "string(char* str)" << endl; _str = new char[_capacity + 1]; strcpy(_str, str); } // s1.swap(s2) void swap(string& s) { ::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(tmp); } // 移动构造 string(string&& s) :_str(nullptr) , _size(0) , _capacity(0) { cout << "string(string&& s) -- 移动拷贝" << endl; //this->swap(s); swap(s); } // 赋值重载 string& operator=(const string& s) { cout << "string& operator=(string s) -- 深拷贝" << endl; string tmp(s); swap(tmp); return *this; } ~string() { delete[] _str; _str = nullptr; } char& operator[](size_t pos) { assert(pos < _size); return _str[pos]; } void reserve(size_t n) { if (n > _capacity) { char* tmp = new char[n + 1]; strcpy(tmp, _str); delete[] _str; _str = tmp; _capacity = n; } } void push_back(char ch) { if (_size >= _capacity) { size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2; reserve(newcapacity); } _str[_size] = ch; ++_size; _str[_size] = '\0'; } //string operator+=(char ch) string& operator+=(char ch) { push_back(ch); return *this; } const char* c_str() const { return _str; } private: char* _str; size_t _size; size_t _capacity; // 不包含最后做标识的\0 }; } -------------------- ### ♥️ 6.4 左值引用使用场景 ### void func1(bit::string s) { } void func2(const bit::string& s) { } int main() { bit::string s1("hello world"); // func1和func2的调用我们可以看到左值引用做参数减少了拷贝，提高效率的使用场景和价值 func1(s1); func2(s1); // string operator+=(char ch) 传值返回存在深拷贝 // string& operator+=(char ch) 传左值引用没有拷贝提高了效率 s1 += '!'; return 0; } ### ♥️ 6.4 左值引用短板 ### 但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回，只能传值返回。例如：bit::string to\_string(int value)函数中可以看到，这里只能使用传值返回，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造)。 ![在这里插入图片描述][4b6d08eaa245441aba542012d5371436.png] ![在这里插入图片描述][e578098cedb64706a13e02de290047a4.png] ![在这里插入图片描述][db0f46c68d4942e8838866cf818a9596.png] -------------------- ### ♥️ 6.5 右值引用和移动语义解决上述问题 ### 移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人（将亡值）的资源来构造自己。 ![在这里插入图片描述][d49dbf3df68a4fb3981552851f24cce1.png] **注意：出了作用域，如果返回对象不在了，不能使用引用返回(左值引用和右值引用都不可以)** namespace byih { class string { public: typedef char* iterator; iterator begin() { return _str; } iterator end() { return _str + _size; } string(const char* str = "") :_size(strlen(str)) , _capacity(_size) { //cout << "string(char* str)" << endl; _str = new char[_capacity + 1]; strcpy(_str, str); } // s1.swap(s2) void swap(string& s) { ::swap(_str, s._str); ::swap(_size, s._size); ::swap(_capacity, s._capacity); } // 拷贝构造 string(const string& s) :_str(nullptr) , _size(0) , _capacity(0) { cout << "string(const string& s) -- 深拷贝" << endl; string tmp(s._str); swap(tmp); } // 移动构造 string(string&& s) :_str(nullptr) , _size(0) , _capacity(0) { cout << "string(string&& s) -- 移动拷贝" << endl; //this->swap(s); swap(s); } // 拷贝赋值 string& operator=(const string& s) { cout << "string& operator=(const string& s) -- 深拷贝" << endl; string tmp(s); swap(tmp); return *this; } // 移动赋值 string& operator=(string&& s) { cout << "string& operator=(string&& s) -- 移动赋值" << endl; swap(s); return *this; } ~string() { delete[] _str; _str = nullptr; } char& operator[](size_t pos) { assert(pos < _size); return _str[pos]; } void reserve(size_t n) { if (n > _capacity) { char* tmp = new char[n + 1]; strcpy(tmp, _str); delete[] _str; _str = tmp; _capacity = n; } } void push_back(char ch) { if (_size >= _capacity) { size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2; reserve(newcapacity); } _str[_size] = ch; ++_size; _str[_size] = '\0'; } //string operator+=(char ch) string& operator+=(char ch) { push_back(ch); return *this; } const char* c_str() const { return _str; } void clear() { _str[0] = '\0'; _size = 0; } private: char* _str; size_t _size; size_t _capacity; // 不包含最后做标识的\0 }; string to_string(int val) { string str; while (val) { int i = val % 10; str += ('0' + i); val /= 10; } reverse(str.begin(), str.end()); return str; } } ![在这里插入图片描述][9fff499cee7347abb903c98885fa35f0.png] ![在这里插入图片描述][2103a1fb345d450db5ced8fb44ee2d7a.png] **右值是将亡值而将亡值不一定是右值** **注意：** 按照语法，右值引用只能引用右值，但右值引用也能引用左值。因为：有些场景下，可能 真的需要用右值去引用左值实现移动语义。当需要用右值引用引用一个左值时，可以通过move 函数将左值转化为右值。C++11中，std::move()函数位于 头文件中，该函数名字具有迷惑性， 它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。 使用move函数时，要注意该对象的资源（所开空间），该对象的资源会根据移动赋值、移动拷贝来决定，建议使用完move函数之后不要再使用该对象了 -------------------- ### ♥️ 6.6 STL容器插入接口函数也增加了右值引用版本 ### void push_back (value_type&& val); int main() { list<bit::string> lt; bit::string s1("1111"); // 这里调用的是拷贝构造 lt.push_back(s1); // 下面调用都是移动构造 lt.push_back("2222"); lt.push_back(std::move(s1)); return 0; } 运行结果： // string(const string& s) -- 深拷贝 // string(string&& s) -- 移动语义 // string(string&& s) -- 移动语义 ![在这里插入图片描述][dc2fb397341542dd8ca5f0d06776b46c.png] -------------------- [Link 1]: https://blog.csdn.net/m0_60338933?type=blog [eabca17da9704379a5f15832a495b4cc.jpeg_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/d708d1a6fce54820af74cb821892357a.jpeg [std_initializer_list]: https://cplusplus.com/reference/initializer_list/initializer_list/ [67be34219bf345e789ebf843ab196f2a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/27cf8970923043a8b9b05de0298098c8.png [077e3e9e611c41df8e7045d42d95168a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/e875b2c259464d8ea6c0c47b1b46d3d7.png [4b6d08eaa245441aba542012d5371436.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/08bd584706664638ad9c524986ee43a4.png [e578098cedb64706a13e02de290047a4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/7ba3b2b959004daab609203ccdb4dbcc.png [db0f46c68d4942e8838866cf818a9596.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/029adc561d314c78b93049df8993fe06.png [d49dbf3df68a4fb3981552851f24cce1.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/1fd35d97d62e4d0e82346eb224851331.png [9fff499cee7347abb903c98885fa35f0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/a16a30c662914e948568b4ca23e20fe3.png [2103a1fb345d450db5ced8fb44ee2d7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/80ddde1064ec43259c7996da10c067b2.png [dc2fb397341542dd8ca5f0d06776b46c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/20/a83bfcef91f3490f8486e4ad82f67e32.png
相关 【C++】C++11的新特性（上） C++11作为C++标准的一个重要版本，引入了许多令人振奋的新特性，极大地丰富了这门编程语言的功能和表达能力。本章将为您介绍C++11的一些主要变化和改进，为接下来的章节铺垫。 喜欢ヅ旅行/ 2024年04月22日 22:20/ 0 赞/ 80 阅读
相关 【C++进阶】map和set（ 万字详解）—— 上篇 C++map和set详解上篇，很快就会更新下篇，实现avl树红黑树和封装map和set 旧城等待，/ 2024年04月20日 06:24/ 0 赞/ 69 阅读
相关 【C++进阶】：C++11新增特性 C++11 一.统一列表的初始化 1.\{\}初始化 2.initializer\_list 二.声明 1.declty 阳光穿透心脏的1/2处/ 2024年03月01日 07:01/ 0 赞/ 54 阅读
相关 C++ 11新特性详解 目录 一、C++11 二、列表初始化 1. 列表初始化的使用 2. 初始化列表的底层原理 三、C++11新的声明 你的名字/ 2023年09月26日 09:47/ 0 赞/ 85 阅读
喜欢ヅ旅行
分手后的思念是犯贱
朱雀
你的名字
还没有评论，来说两句吧...