C++11：列表初始化 && 初始化列表initializer_list && decltype关键字 ...

目录
前言
列表初始化
初始化列表initializer_list
decltype关键字
左值和右值
move

---

前言

        2003年C++标准委员会曾经提交了一份技能勘误表（简称TC1），使得C++03这个名字代替了C++98成为了C++11前最新的C++标准名称。不过由于C++03主要是对C++98标准中的毛病进行修复，语言的核心部门则没有改动，因此人们风俗性的把两个标准归并成为C++98/03标准，从C++0x到C++11到，C++委员会十年磨一剑，第二个真正意义上的C++新标准C++11在2011年姗姗来迟。
        C++11则带来了数量可观的变化，其中包罗了约140个新特性，以及对C++03标准中约600个缺陷的修正，别的C++11能更好的用于系统开辟和库开辟、语言更加泛化和简单化、步伐更加稳定和安全，不但功能强盛，而且还能提拔步伐员的开辟效率，在公司现实项目开辟中也用的较多。
   

官网检察各编译器对C++11标准的接收环境：C++11 - 维基百科，自由的百科全书 (wikipedia.org)

  

   

补充：模板的概念是C++98引入的，不是C++11 

  列表初始化

根本概念：C++98只能使用{}对聚合范例进行聚合初始化（此时{}还不叫列表初始化），可以使用()对内置范例进行直接初始化，对自定义范例的对象进行构造和初始化（构造 != 初始化，先调用构造函数，可以在调用构造函数的同时进行初始化，也可以在调用构造函数后进行初始化）
   标题：什么是聚合范例？
  解释：聚合范例是一种特别的自定义范例，它具有以下四个特征：
  

• 没有用户定义的构造函数：聚合范例不能有用户自定义的构造函数
  
• 所有成员都是公有的：聚合范例的所有成员变量必须是公有的
  
• 没有基类：聚合范例不能继承自其他类
  
• 没有虚函数：聚合范例不能有虚函数
  

    C++98中{}的留意事项：
  1、对聚合范例进行的初始化叫做聚合初始化，聚合初始化与构造无关，不会调用构造函数

1. //聚合类型
2. struct Point {
3.     int x;
4.     int y;
5. };
6. Point p = {1, 2};

复制代码

2、{} 可对聚合范例进行部门初始化，未显式初始化的成员会被默认初始化为零

1. #include <iostream>
2. struct Point {
3.     int x;
4.     int y;
5.     int z;
6. };
8. int main() {
9.     Point p = { 1, 2 }; // 只初始化了 x 和 y，z 会被默认初始化为 0
10.     std::cout << "Point: (" << p.x << ", " << p.y << ", " << p.z << ")" << std::endl; // 输出：Point: (1, 2, 0)
11.     return 0;
12. }

复制代码

    标题：为什么可以使用()对内置范例进行直接初始化，对自定义范例进行构造和初始化？
  解释：C++98引入了模板的概念，使用 () 时，编译器会将其解释为调用相应范例的构造函数（()对内置范例int i(5)直接初始化的本质是调用int 范例的构造函数来将整数值 5 转换为 int 范例并初始化变量 i，但不能使用int i(); i = 5的情势，由于前者会被视为一个函数声明，赋值时会被视为向一个名为i函数进行赋值）
    C++98中()的留意事项：
  1、对自定义范例的对象进行构造时，没有（）时叫做默认构造，有（）时依据（）内参数的多少分为单参数和多参数构造，传入的参数叫做对该对象的初始化；一样平常不会使用（）对内置范例进行像int i(5)这样的直接初始化，但要了解为什么可以这样（本质还是调用了构造）
  2、使用() 对自定义范例的对象进行构造时必须要有得当的构造函数（传递单个参数对构造对象进行初始化时，对象中要有单参数的构造函数，传递多个参数对构造对象进行初始化时，对象中要有多参数的构造函数）构造时的情势为类名 对象名（）或  类名 对象名

1. #include <iostream>
2. using namespace std;
4. class Date
5. {
6. public:
7.         Date()
8.         {
9.                 cout << "Date()" << endl;
10.         }
12.         Date(int year)
13.                 :_year(year)
14.         {
15.                 cout << "Date(int year)" << endl;
16.         }
18.         Date(int year, int month, int day)
19.                 :_year(year)
20.                 , _month(month)
21.                 , _day(day)
22.         {
23.                 cout << "Date(int year, int month, int day)" << endl;
24.         }
26. private:
27.         int _year;
28.         int _month;
29.         int _day;
30. };
32. int main()
33. {
34.     Date d0;//默认构造
35.         Date d2(2024);//单参数构造
36.         Date d3(2024,5,26);//多参数构造
37.    
38.     int i(5);//单参数构造
39.     double f(3.14);//单参数构造
40.     return 0;
41. }

复制代码

  2、不建议以Date d =（）的情势对自定义范例的对象进行构造，由于此时（）会被编译器视为逗号表达式，（）内为空时会报错，（）有参数时，参数个数无论为多少都会去调用单参数构造函数，纵然是内置范例也是一样的

1. #include <iostream>
2. using namespace std;
4. class Date
5. {
6. public:
7.         Date()
8.         {
9.                 cout << "Date()" << endl;
10.         }
12.         Date(int year)
13.                 :_year(year)
14.         {
15.                 cout << "Date(int year)" << endl;
16.         }
18.         Date(int year, int month, int day)
19.                 :_year(year)
20.                 , _month(month)
21.                 , _day(day)
22.         {
23.                 cout << "Date(int year, int month, int day)" << endl;
24.         }
25. private:
26.         int _year;
27.         int _month;
28.         int _day;
29. };
31. int main()
32. {
33.         Date d = (2024);
34.         Date d1 = (2024, 5, 26);
36.         int z = (5, 6);
37.         cout << "z = " << z << endl;
38.         return 0;
39. };

复制代码

  3、string s = "1111" 也是直接构造，但本质是 构造 + 拷贝构造，只是编译器将它们优化为了直接构造（便于用户使用），我们将这样的优化称为单参数的构造函数支持隐式范例转换（所谓的隐式范例转换即将一个cosnt char*范例的对象转为string范例的对象）
  4、进行默认构造时，要以Date d情势进行，不能以Data d（）的情势，由于后者在编译器看来不是构造而是一个函数声明（这也被称为C++最烦人的解析）

1. #include <iostream>
2. using namespace std;
4. class Date
5. {
6. public:
7.         Date()
8.         {
9.                 cout << "Date()" << endl;//最后打印的Date()应该只有一行
10.         }
11. };
13. int main()
14. {
15.         Date d1();//函数声明，不是初始化对象
16.         cout << endl;
17.         cout << "上面有Date()吗？" << endl;
18.         Date d1;//默认构造
19.         cout << "上面有Date()吗？" << endl;
20.         return 0;
21. }

复制代码

    结论：使用（）对自定义范例的对象构造或对内置范例进行直接初始化时，要留意（）可能被解析为逗号表达式或函数声明的环境 
  根本概念：C++11中扩大了{}的使用范围，使其可以对所有范例进行初始化（且=可以省略）此时我们将使用{}进行初始化的行为叫做列表初始化，（）的用法稳定
   1、此时{}对聚合范例的初始化仍叫做聚合初始化，而不是列表初始化，且初始化规则稳定

1. //对聚合类型进行聚合初始化
2. struct Point {
3.     int x;
4.     int y;
5. };
7. Point P = {1};    // C++98支持使用{}进行部分聚合初始化
8. Point p = {1, 2}; // C++98支持使用{}进行完全聚合初始化
9. Point p{3, 4};    // C++11及以后版本均支持使用{}进行部分聚合初始化，且=可省略
10. Point p{3, 4};    // C++11及以后版本均支持使用{}进行聚合初始化，且=可省略
12. int arr[]{1,2,3,4,5}//对数组进行部分聚合化

复制代码

   2、使用（）对内置范例进行初始化时仍叫直接初始化，而使用{}对内置范例进行初始化时叫做列表初始化

1. //对内置类型进行初始化的多种方式
2. int x = 1;               //每个C++版本一定支持的
3. int y(5) 或 y = (5);     //C++98后开始支持的
4. int z{3} 或 z = {3};     //C++11后开始支持的

复制代码

   3、此时{}和（）均可以对自定义范例的对象进行构造和初始化

1. class Date
2. {
3. public:
4.     Date(int year)
5.                 :_year(year)
6.         {
7.                 cout << "Date(int year)" << endl;
8.         }
10.         Date(int year, int month, int day)
11.                 :_year(year)
12.                 , _month(month)
13.                 , _day(day)
14.         {
15.                 cout << "Date(int year, int month, int day)" << endl;
16.         }
17. private:
18.         int _year;
19.         int _month;
20.         int _day;
21. };
23. Date d1;//C++11和C++98均支持这样做
25. Date d2(2024);//C++98支持的使用（）进行单参数构造
26. Date d3(2024,5,26);//C++98支持的使用（）进行多参数构造
28. //省略=
29. Date d4{2024};//C++11支持的使用{}进行单参数构造
30. Date d5{2024,5,26};//C++11支持的使用{}进行多参数构造
32. //不省略=
33. Date d6 = {2024};//C++11支持的使用{}进行单参数构造
34. Date d6 = {2024,5,6};//C++11支持的使用{}进行多参数构造

复制代码

• 对自定义范例的对象进行构造时仍建议使用（）进行，{}华而不实，且使用{}时也不建议省略=，由于会导致代码可读性降低
  

  留意事项：
1、列表初始化是一种直接调用构造函数的方式，C++11及以后版本使用列表初始化时，{}会去寻找最为得当的构造函数，假如找不到最合适的，会实行将{}中的内容进行隐式范例转换，从而找到一个较为得当的构造函数，假如还找不到就会报错
2、单参数和多参数的构造函数支持隐式范例转换 中的隐式范例转换指的是它们支持将其它范例转换为它们自己的自定义范例（比如：{int,int} -> B）而在这一隐式范例转换的过程中会进行构造 + 拷贝构造（编译器会进行优化），同时它们还支持传入{1，21.1}但是构造函数只有（double,double）时会将{1，21.1}转换为{1.0，21.1}再去调用构造函数的这种情势的隐式范例转换

1. #include <iostream>
2. #include <string>
4. class Person {
5. public:
6.     std::string name;
7.     int age;
8.     int height;
10.     // 单参数构造函数
11.     Person(std::string n) : name(n), age(0) {
12.         std::cout << "Person(std::string n)" << std::endl;
13.     }
15.     Person(int a) : name("Unknown"), age(a) {
16.         std::cout << "Person(int a)" << std::endl;
17.     }
19.     Person(std::string n, int a) : name(n), age(a) {
20.         std::cout << "Person(std::string n, int a)" << std::endl;
21.     }
23.     Person(double n, double a) : height(n), age(a) {
24.         std::cout << "Person(double n, double a)" << std::endl;
25.     }
27.     Person(const char* s) : name(s) {
28.         std::cout << "Person(const char * s)" << std::endl;
29.     }
30. };  
32. int main()
33. {
34.     Person a = { "Alice", 30}; // const char* -> string, 直接调用 Person(std::string, int) 构造函数
35.     Person b = { "fwqfq" };    // 直接调用 Person(const char * s) 构造函数
36.     Person c = { 5 , 6 };      // 隐式类型转换： int -> double，然后直接调用 构造Person(double n, double a) 函数
37.     Person d = (52.5);         // 隐式类型转换：double -> int，然后直接调用  Person(int a) 构造函数
38.     Person e = "fewfew";       // 直接调用Person(const char* s)构造函数，如果只有Person(string s)，就会先进行隐式类型转换然后再调用该构造函数
39.     Person f = 40;             // 直接调用 Person(int a) 构造函数
40.     return 0;
41. }

复制代码

2、列表初始化不支持窄化的隐式范例转换，窄化转换就是大范围转小范围，但是（）支持

   

关于C++的隐式范例转换的其它文章：彻底理解c++的隐式范例转换 - apocelipes - 博客园

  初始化列表initializer_list

根本概念：是一个模板类，用于向自定义范例或函数（条件是得有支持该范例的构造函数或者参数）传递一组同范例的参数，它通常与列表初始化{}配合使用（初始化列表 != 列表初始化）

1. template<class T> class initializer_list;

复制代码

1. #include <iostream>
2. #include <vector>
4. //printList函数有initializer_list类型的参数
5. void printList(std::initializer_list<int> list) {
6.     for (auto elem : list) {
7.         std::cout << elem << " ";
8.     }
9.     std::cout << std::endl;
10. }
12. class MyClass {
13. public:
14.     //MyClass有支持initializer_list类型的构造函数
15.     MyClass(std::initializer_list<int> list) {
16.         for (auto elem : list) {
17.             std::cout << elem << " ";
18.         }
19.         std::cout << std::endl;
20.     }
21. };
23. int main() {
24.     printList({10, 20, 30, 40, 50});  
25.     MyClass obj = {1, 2, 3, 4, 5};   
26.     return 0;
27. }

复制代码

留意事项：
1、{10, 20, 30, 40, 50}在正常环境下还是列表初始化，但是当{10, 20, 30, 40, 50}要作为函数参数或者要赋值给一个自定义范例时，编译器会将{10, 20, 30, 40, 50}识别为initializer_list范例（不会构造initializer_list范例的匿名对象），然后直接向某个有initializer_list范例形参的函数进行传参，或者调用某个支持自定义范例对象的支持initializer_list范例的构造函数

• MyClass obj = {1, 2, 3, 4, 5}：将{1, 2, 3, 4, 5}解析为initializer_list范例—>直接调用MyClass类中支持initializer_list范例的构造函数
  
• Myclass obj({10, 20, 30, 40, 50})：将{10, 20, 30, 40, 50}解析为initializer_list范例—>直接调用Myclass 类中支持initializer_list范例的构造函数构造
  
• printList({10, 20, 30, 40, 50})：将{10, 20, 30, 40, 50}解析为initializer_list范例—>直接向printList函数传参
  

2、对于C++库中提供的各种容器，它们都有支持initializer_list范例的构造函数，不用担心直接使用即可，但是对于自定义范例假如没有支持initializer_list范例的构造函数就不能使用，上面的MyClass obj = {1, 2, 3, 4, 5}；假如没有支持initializer_list范例的构造函数就会报错

3、编译器会优先调用支持initializer_list范例的构造函数，而不是写死参数个数的构造函数

1. #include <iostream>
2. #include <vector>
4. class MyClass {
5. public:
6.     MyClass(int a,int b,int c,int d,int e)
7.     {
8.         std::cout << "MyClass(int a,int b,int c,int d,int e)" << std::endl;
9.     }
11.     MyClass(std::initializer_list<int> list)
12.     {
13.         for (auto elem : list) {
14.             std::cout << elem << " ";
15.         }
16.         std::cout << std::endl;
17.     }
18.   
19. };
21. int main()
22. {
23.     MyClass obj = { 1, 2, 3, 4, 5 };
24.     return 0;
25. }

复制代码

4、initializer_list模板类的引入，使得我们在向容器中写入数据时更加的简单

1. //原来
2. std::vector<int> v;
3. v.push_back(1);
4. v.push_back(2);
5. v.push_back(3);
6. v.push_back(4);
8. std::set<int> st;
9. v.insert(1);
10. v.insert(2);
11. v.insert(3);
12. v.insert(4);
14. std::map<string,string> mt;
15. dict.insert(make_pair("right", "右边"));
16. dict.insert(make_pair("right", "右边"));
17. dict.insert(make_pair("right", "右边"));
18. dict.insert(make_pair("right", "右边"));
20. //现在
21. std::vector<int> v = {1，2，3，4};//直接调用支持 initializer_list 类型的构造函数
22. std::set<int> st = {1,2,3,4,5};//直接调用支持 initializer_list 类型的构造函数
23. std::map<string,string> mt = {{"right", "右边"},{"right", "右边"}};

复制代码

  对于std::set<int> st = {1,2,3,4,5}：{1,2,3,4,5}是使用{}的列表初始化，又由于左边是vector容器范例，因此编译器会解析为一个initializer_list范例，然后直接调用vector中支持initializer_list范例的构造函数
  对于std::map<string,string> mt = {{"right", "右边"},{"right", "右边"}}：编译器会先识别出{{"right", "右边"}, {"right", "右边"}}是一个用于初始化map范例对象的initializer_list，接着调用 pair 的构造函数生成两个 pair<const std::string, std::string> 对象，然后将生成的 两个 pair 对象组合成一个 initializer_list<std::pair<const std::string, std::string>> ，末了直接调用map支持initializer_list范例的构造函数
   补充：
   1、pair范例不支持initializer_list 范例的构造函数，因此pair<?> p = {}是列表初始化而不是initializer_list范例
  

  2、map 有一个担当initializer_list 的构造函数，其定义如下（set也类似）：

1. map(std::initializer_list<std::pair<const Key, T>> init);

复制代码

3、pair差别范例间的pair可以进行拷贝构造，是由于pair的拷贝构造是一个函数模板

1. template<class U, class V>
2. pair(const pair<U, V>& pr);
3. ​
4. pair<const char*,char*> kv3 = {"sort","排序"};
5. pair<const string,string> kv4(kv3);

复制代码

decltype关键字

根本概念：是 C++11 引入的一个关键字，用于查询表达式的范例，它办理了typeid只能进行打印变量范例但是不能作为一个范例的使用
常见使用方式：
1、 获取变量范例

1. int x = 0;
2. decltype(x) y = 5;  //y的类型是int

复制代码

2、获取表达式范例

1. int a = 5;
2. double b = 3.14;
3. decltype(a + b) c = a + b; //因为a + b的类型是double,所以c的类型是 double

复制代码

 3、decltype关键字通常会与获取lambda表达式配合使用

~over~ 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。