• C++11 --------- 知识点补充

    目录

    1.C++11简介

    2.统一的列表初始化

    (1){ }的初始化

     (2)initializer_list容器

    3.声明

    (1)auto

    (2)decltype (了解)

    (3)nullptr

    4.STL变化

    (1)array容器

    (2)forward_list容器本质就是一个单链表。

    (3)字符串转换函数

    (4)C++11为每个容器都增加了一些新方法

     

    1.C++11简介

    • 在2003年C++标准委员会提交了一份技术勘误表（简称TC1），使得C++03这个名字取代了C++98成为C++11之前的最新C++标准名称。
    • 但由于C++03主要是对C++98标准中的漏洞进行修复，语言的核心部分则没有改动，因此人们习惯性的把这两个标准合并称为C++98/03标准。
    • 从C++0x到C++11，C++标准10年磨一剑，第二个真正意义上的标准姗姗来迟。相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。
    • 相比较而言，C++11能更好地用于系统开发和库开发、语言更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多。

                    

                    

    2.统一的列表初始化

    (1){ }的初始化

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

    1. struct Point
    2. {
    3. 	int _x;
    4. 	int _y;
    5. };
    6.  
    7. int main()
    8. {
    9. 	//使用大括号对数组元素进行初始化
    10. 	int array1[] = { 1, 2, 3, 4, 5 };
    11. 	int array2[5] = { 0 };
    12.  
    13. 	//使用大括号对结构体元素进行初始化
    14. 	Point p = { 1, 2 };
    15. 	return 0;
    16. }

                     

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

    1. struct Point
    2. {
    3. 	int _x;
    4. 	int _y;
    5. };
    6.  
    7. int main()
    8. {
    9. 	//使用大括号对内置类型进行初始化
    10. 	int x1 = { 1 }; //可添加等号
    11. 	int x2{ 2 };    //可不添加等号
    12.  
    13. 	//使用大括号对数组元素进行初始化
    14. 	int array1[]{1, 2, 3, 4, 5}; //可不添加等号
    15. 	int array2[5]{0};            //可不添加等号
    16.  
    17. 	//使用大括号对结构体元素进行初始化
    18. 	Point p{ 1, 2 }; //可不添加等号
    19.  
    20. 	//C++11中列表初始化也可以用于new表达式中（C++98无法初始化）
    21. 	int* p1 = new int[4]{0};       //不可添加等号
    22. 	int* p2 = new int[4]{1,2,3,4}; //不可添加等号
    23. 	return 0;
    24. }

                             

     ③创建对象时也可以使用列表初始化方式调用构造函数初始化

    • 这里虽然可以这么用，但是我们不建议用，这种用法是为其他地方准备的
    1. class Date
    2. {
    3. public:
    4. 	Date(int year, int month, int day)
    5. 		:_year(year)
    6. 		, _month(month)
    7. 		, _day(day)
    8. 	{
    9. 		cout << "Date(int year, int month, int day)" << endl;
    10. 	}
    11. private:
    12. 	int _year;
    13. 	int _month;
    14. 	int _day;
    15. };
    16.  
    17. int main()
    18. {
    19. 	//一般调用构造函数创建对象的方式
    20. 	Date d1(2022, 8, 29);
    21.  
    22. 	//C++11支持的列表初始化，这里也会调用构造函数初始化
    23. 	Date d2 = { 2022, 8, 30 }; //可添加等号
    24. 	Date d3{ 2022, 8, 31 };    //可不添加等号
    25. 	return 0;
    26. }

                             

     (2)initializer_list容器

    ①C++11中新增了initializer_list容器，该容器没有提供过多的成员函数

    • 提供了begin和end函数，用于支持迭代器遍历。
    • 以及size函数支持获取容器中的元素个数。

                    

    ②initializer_list本质就是一个大括号括起来的列表，如果用auto关键字定义一个变量来接收一个大括号括起来的列表，然后以 typeid(变量名).name() 的方式查看该变量的类型，此时会发现该变量的类型就是initializer_list。 

    1. int main()
    2. {
    3. 	auto il = { 1, 2, 3, 4, 5 };
    4. 	cout << typeid(il).name() << endl; //class std::initializer_list
    5. 	return 0;
    6. }

                    

    ③initializer_list的使用场景 

    • initializer_list容器没有提供对应的增删查改等接口，因为initializer_list并不是专门用于存储数据的，而是为了让其他容器支持列表初始化的
    1. class Date
    2. {
    3. public:
    4. 	Date(int year, int month, int day)
    5. 		:_year(year)
    6. 		, _month(month)
    7. 		, _day(day)
    8. 	{
    9. 		cout << "Date(int year, int month, int day)" << endl;
    10. 	}
    11. private:
    12. 	int _year;
    13. 	int _month;
    14. 	int _day;
    15. };
    16.  
    17. int main()
    18. {
    19. 	//用大括号括起来的列表对容器进行初始化
    20. 	vector<int> v = { 1, 2, 3, 4, 5 };
    21. 	list<int> l = { 10, 20, 30, 40, 50 };
    22. 	vector vd = { Date(2022, 1, 1), Date{ 2022, 2, 2}, { 2022, 3, 3 } };
    23. 	map m{ make_pair("sort", "排序"), { "insert", "插入" } };
    24.  
    25. 	//用大括号括起来的列表对容器赋值
    26. 	v = { 5, 4, 3, 2, 1 };
    27. 	return 0;
    28. }

            

    ④补充

    • C++98并不支持直接用列表对容器进行初始化，这种初始化方式是在C++11引入initializer_list后才支持的。
    • 这些容器之所以支持使用列表进行初始化，根本原因是因为C++11给这些容器都增加了一个构造函数，这个构造函数就是以initializer_list作为参数的。
    • 当用列表对容器进行初始化时，这个列表被识别成initializer_list类型，于是就会调用这个新增的构造函数对该容器进行初始化。
    • 这个新增的构造函数要做的就是遍历initializer_list中的元素，然后将这些元素依次插入到要初始化的容器当中即可。

                            

    ⑤initializer_list使用示例 

    •  如果要让vector支持列表初始化，就需要增加一个以initializer_list作为参数的构造函数
    • 在构造函数中遍历initializer_list时可以使用迭代器遍历，也可以使用范围for遍历，因为范围for底层实际采用的就是迭代器方式遍历。
    • 使用迭代器方式遍历时，需要在迭代器类型前面加上typename关键字，指明这是一个类型名字。因为这个迭代器类型定义在一个类模板中，在该类模板未被实例化之前编译器是无法识别这个类型的。
    • 最好也增加一个以initializer_list作为参数的赋值运算符重载函数，以支持直接用列表对容器对象进行赋值，但实际也可以不增加。
    1.  
    2. 	template<class T>
    3. 	class vector
    4. 	{
    5. 	public:
    6. 		typedef T* iterator;
    7. 		vector(initializer_list il)
    8. 		{
    9. 			_start = new T[il.size()];
    10. 			_finish = _start;
    11. 			_endofstorage = _start + il.size();
    12.  
    13. 			//迭代器遍历
    14. 			//typename initializer_list::iterator it = il.begin();
    15. 			//while (it != il.end())
    16. 			//{
    17. 			//	push_back(*it);
    18. 			//	it++;
    19. 			//}
    20.  
    21. 			//范围for遍历
    22. 			for (auto e : il)
    23. 			{
    24. 				push_back(e);
    25. 			}
    26. 		}
    27.  
    28. 		vector& operator=(initializer_list il)
    29. 		{
    30. 			vector tmp(il);
    31. 			std::swap(_start, tmp._start);
    32. 			std::swap(_finish, tmp._finish);
    33. 			std::swap(_endofstorage, tmp._endofstorage);
    34. 			return *this;
    35. 		}
    36.  
    37. 	private:
    38. 		iterator _start;
    39. 		iterator _finish;
    40. 		iterator _endofstorage;
    41. 	};

                             

    ⑥如果没有增加以initializer_list作为参数的赋值运算符重载函数，下面的代码也可以正常执行

    1. vector<int> v = { 1, 2, 3, 4, 5 };
    2. v = { 5, 4, 3, 2, 1 };
    • 对于第一行代码，就是调用以initializer_list作为参数的构造函数完成对象的初始化。
    • 而对于第二行代码，会先调用initializer_list作为参数的构造函数构造出一个vector对象，然后再调用vector原有的赋值运算符重载函数完成两个vector对象之间的赋值。

                            

                    

                    

    3.声明

    (1)auto

    • 在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。
    • C++11中废弃auto原来的用法，将其用于实现自动类型推断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。
    1. int main()
    2. {
    3. 	int i = 10;
    4. 	auto p = &i;
    5. 	auto pf = strcpy;
    6.  
    7. 	cout << typeid(p).name() << endl;  //int *
    8. 	cout << typeid(pf).name() << endl; //char * (__cdecl*)(char *,char const *)
    9.  
    10. 	map dict = { { "sort", "排序" }, { "insert", "插入" } };
    11. 	//map::iterator it = dict.begin();
    12. 	auto it = dict.begin();  //简化代码
    13.  
    14. 	return 0;
    15. }

                                     

    • 自动类型推断在某些场景下还是非常必要的，因为编译器要求在定义变量时必须先给出变量的实际类型，而如果我们自己设定类型在某些情况下可能会出问题
    1. int main()
    2. {
    3. 	char a = 127;
    4. 	char b = 127;
    5. 	//c如果给成char，会造成数据丢失，如果能够让编译器根据a+b的结果推导c的实际类型，就不会存在问题
    6. 	char c = a + b;
    7. 	return 0;
    8. }

                     

    (2)decltype (了解)

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

    • 通过typeid(变量名).name()的方式可以获取一个变量的类型，但无法用获取到的这个类型去定义变量。
    1. template<class T1, class T2>
    2. void F(T1 t1, T2 t2)
    3. {
    4. 	decltype(t1*t2) ret;
    5. 	cout << typeid(ret).name() << endl;
    6. }
    7.  
    8. int main()
    9. {
    10. 	const int x = 1;
    11. 	double y = 2.2;
    12.  
    13. 	decltype(x*y) ret;
    14. 	decltype(&x) p;
    15. 	cout << typeid(ret).name() << endl; //double
    16. 	cout << typeid(p).name() << endl;   //int const *
    17.  
    18. 	F(1, 'a'); //int
    19. 	F(1, 2.2); //double
    20.  
    21. 	return 0;
    22. }

                     

    ②decltype除了能够推演表达式的类型，还能推演函数返回值的类型 

    1. void* GetMemory(size_t size)
    2. {
    3. 	return malloc(size);
    4. }
    5. int main()
    6. {
    7. 	//如果没有带参数，推导函数的类型
    8. 	cout << typeid(decltype(GetMemory)).name() << endl;
    9.  
    10. 	//如果带参数列表，推导的是函数返回值的类型，注意：此处只是推演，不会执行函数
    11. 	cout << typeid(decltype(GetMemory(0))).name() << endl;
    12. 	return 0;
    13. }

                             

    ③decltype不仅可以指定定义出的变量类型，还可以指定函数的返回类型

    1. template<class T1, class T2>
    2. auto Add(T1 t1, T2 t2)->decltype(t1+t2)
    3. {
    4. 	decltype(t1+t2) ret;
    5. 	ret = t1 + t2;
    6. 	cout << typeid(ret).name() << endl;
    7. 	return ret;
    8. }
    9.  
    10. int main()
    11. {
    12. 	cout << Add(1, 2) << endl;;   //int
    13. 	cout << Add(1, 2.2) << endl;; //double
    14. 	return 0;
    15. }

                     

    (3)nullptr

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

    1. /* Define NULL pointer value */
    2. #ifndef NULL
    3. #ifdef __cplusplus
    4. #define NULL    0
    5. #else  /* __cplusplus */
    6. #define NULL    ((void *)0)
    7. #endif  /* __cplusplus */
    8. #endif  /* NULL */

                     

     ②在大部分情况下使用NULL不会存在什么问题，但是在某些极端场景下就可能会导致匹配错误

    •  NULL和nullptr的含义都是空指针，所以这里调用函数时肯定希望匹配到的都是参数类型为int*的重载函数，但最终却因为NULL本质是字面量0，而导致NULL匹配到了参数为int类型的重载函数，因此在C++中一般推荐使用nullptr。
    1. void f(int arg)
    2. {
    3. 	cout << "void f(int arg)" << endl;
    4. }
    5.  
    6. void f(int* arg)
    7. {
    8. 	cout << "void f(int* arg)" << endl;
    9. }
    10.  
    11. int main()
    12. {
    13. 	f(NULL);    //void f(int arg)
    14. 	f(nullptr); //void f(int* arg)
    15. 	return 0;
    16. }

                            

                    

                     

    4.STL变化

    • C++11中新增了四个容器，分别是array、forward_list、unordered_map和unordered_set。

                     

    (1)array容器

    • array容器本质就是一个静态数组，即固定大小的数组。
    • array容器有两个模板参数，第一个模板参数代表的是存储的类型，第二个模板参数是一个非类型模板参数，代表的是数组中可存储元素的个数。
    1. int main()
    2. {
    3. 	array<int, 10> a1;   //定义一个可存储10个int类型元素的array容器
    4. 	array<double, 5> a2; //定义一个可存储5个double类型元素的array容器
    5. 	return 0;
    6. }

                    

    ①与普通数组相比:

    • array容器与普通数组一样，支持通过[ ]访问指定下标的元素，也支持使用范围for遍历数组元素，并且创建后数组的大小也不可改变。
    • array容器与普通数组不同之处就是，array容器用一个类对数组进行了封装，并且在访问array容器中的元素时会进行越界检查。用[ ]访问元素时采用断言检查，调用at成员函数访问元素时采用抛异常检查。
    • 而对于普通数组来说，一般只有对数组进行写操作时才会检查越界，如果只是越界进行读操作可能并不会报错。

    ②但array容器与其他容器不同的是，array容器的对象是创建在栈上的，因此array容器不适合定义太大的数组。

                     

    (2)forward_list容器本质就是一个单链表。

    ①forward_list很少使用

    • forward_list只支持头插头删，不支持尾插尾删，因为单链表在进行尾插尾删时需要先找尾，时间复杂度为O(N)。
    • forward_list提供的插入函数叫做insert_after，也就是在指定元素的后面插入一个元素，而不像其他容器是在指定元素的前面插入一个元素，因为单链表如果要在指定元素的前面插入元素，还要遍历链表找到该元素的前一个元素，时间复杂度为O(N)。
    • forward_list提供的删除函数叫做erase_after，也就是删除指定元素后面的一个元素，因为单链表如果要删除指定元素，还需要还要遍历链表找到指定元素的前一个元素，时间复杂度为O(N)。

    ②一般情况下要用链表我们还是选择使用list容器。
                    

    (3)字符串转换函数

    • C++11提供了各种内置类型与string之间相互转换的函数，比如to_string、stoi、stol、stod等函数。

                     

    ①内置类型转换为string

    • 将内置类型转换成string类型统一调用to_string函数，因为to_string函数为各种内置类型重载了对应的处理函数 

                     

    ②string转换成内置类型

    • 如果要将string类型转换成内置类型，则调用对应的转换函数即可。 

                                     

    (4)C++11为每个容器都增加了一些新方法

    • 提供了一个以initializer_list作为参数的构造函数，用于支持列表初始化。
    • 提供了cbegin和cend方法，用于返回const迭代器。
    • 提供了emplace系列方法，并在容器原有插入方法的基础上重载了一个右值引用版本的插入函数，用于提高向容器中插入元素的效率。
    • emplace系列方法和新增的插入函数提高容器插入效率的原理，涉及C++11中的右值引用、移动语义和模板的可变参数等机制

                     

                     

                     

  • 相关阅读:
    一对一，屏对屏，菊风远程同屏解决方案，助力多行业实现数字化协同
    Istio中流量劫持机制
    部署之缓存问题
    企业知识库管理系统怎么做？
    Wespeaker框架数据集准备（1）
    拯救“消失的她”——双系统grub完美恢复方案
    SBT40100VFCT-ASEMI塑封肖特基二极管SBT40100VFCT
    从预训练到通用智能（AGI）的观察和思考
    频繁调一个http请求和多个不同http请求性能一样吗
    嵌入式开发：技巧和窍门——干净地从引导加载程序跳转到应用程序代码
  • 原文地址：https://blog.csdn.net/m0_52169086/article/details/126903107