[C++11]花括号{}、initializer_list、auto、decltype

1.花括号{ }的扩展

int main()
{
	//C++98花括号{ }支持 1.数组 2.结构体
	struct Point
	{
		int _x;
		int _y;
	};
	int arr1[] = { 1, 2, 3, 4, 5 };
	int arr2[5] = { 0 };
	Point p = { 1, 2 }; 
	//C++11:1.内置类型 2.自定义类型
	struct Point2
	{
		int _x;
		int _y;
	};
	// = 号可以省略
	int x1 = { 1 };
	int x2{ 2 };

	int array1[]{ 1, 2, 3, 4, 5 };
	int array2[5]{ 0 };
	Point2 p2{ 1, 2 };
	//拓展
	int x(1); //int的构造函数
	
	//申请4个int 初始化成0
	int* pa = new int[4]{ 0 };


	//列表初始化方式调用构造函数初始化
	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;
	};
	Date d1(2023, 10, 12); 
	Date d2{ 2023, 10,12 };
	Date d3 = { 2023, 10, 12 }; 
	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

2.initializer_list

//vector/list中的花括号{ }

//1.查看a,b的类型
auto a = { 10,20,30,40,50,60 };
auto b = { 10,20,30 };
cout << typeid(a).name() << endl;//class std::initializer_list
cout << typeid(b).name() << endl;//class std::initializer_list

//2.initializer_list的迭代器
initializer_list<int>::iterator it1 = a.begin();
initializer_list<int>::iterator it2 = b.begin();
cout << it1 << endl;
cout << it2 << endl;
// *it1 = 1;不可修改

//3.initializer_list的对象
initializer_list<int> c = { 10,20,30 };
initializer_list<int>::iterator it3 = c.begin();
cout << it3 << endl;

//vector/list中的{ }
//vector(
//      initializer_list il,
//      const allocator_type& alloc = allocator_type()
//      );
vector<int> v1 = { 1,2,3,4,5 };
vector<int> v2 = { 10,20,30 };
vector<int> v3 = { 10,20,30,40,50,60 };
list<int> lt1 = { 1,2,3,4,5 };
list<int> lt2 = { 10,20,30 };

//vecotr中数据为自定义数据类型
Date D1(2023, 5, 20);
Date D2(2023, 5, 21);
vector<Date> vd1 = { d1, d2 }; 
vector<Date> vd2 = { Date(2023,5,20), Date(2023,5,21) }; //匿名对象
vector<Date> vd3 = { {2023,5,20}, {2023,5,20} };         //先调用Date构造函数

map<string, string> dict = { {"sort", "排序"},{"string", "字符串"},{"Date", "日期"} };
pair<string, string> pair1 = { "Date", "日期" };
pair<string, string> pair2{ "Date", "日期" }; 
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

3.auto

C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。
C++11中废弃auto原来的用法，将其用于实现自动类型推断。

4.decltype

template<class T1, class T2>
void Func(T1 a, T2 b)
{
	decltype(a * b) x;
	cout << typeid(x).name() << endl;
}
int main()
{
//关键字decltype
//将变量的类型 声明为 表达式指定的类型
const int X = 1;
double y = 2.2;
cout << typeid(x * y).name() << endl;

decltype(x* y) j ;
decltype(&x) k ;
cout << typeid(j).name() << endl;
cout << typeid(k).name() << endl;
//使用场景
//1.传类型
vector<decltype(x* y)> v;
//2.函数内部
Func(1, 'a');
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

5.容器的增加

5.1array[useless]

数组是固定大小的序列容器：它们包含按严格线性序列排序的特定数量的元素。在内部，数组除了包含的元素之外，不保留任何数据（甚至不保留其大小，这是一个模板参数，在编译时固定）。就存储大小而言，它与使用该语言的括号语法（[]）声明的普通数组一样高效。这个类只添加了一层成员和全局函数，这样数组就可以用作标准容器。与其他标准容器不同，数组具有固定大小，并且不通过分配器管理其元素的分配：它们是封装固定大小元素数组的聚合类型。因此，它们不能动态地展开或收缩（请参阅可以展开的类似容器的矢量）。零大小的数组是有效的，但不应取消对它们的引用（成员前、后和数据）。与标准库中的其他容器不同，交换两个数组容器是一种线性操作，涉及单独交换范围中的所有元素，这通常是一种效率低得多的操作。另一方面，这允许两个容器中元素的迭代器保持其原始容器关联。数组容器的另一个独特特性是，它们可以被视为元组对象：＜array＞标头重载get函数以访问数组的元素，就像它是元组一样，以及专门的tuple_size和tuple_element类型。

C++大佬太想把C++做的完美了 想把它搞得更泛型 替代了C语言的静态数组 另外 [ ]可以检查越界 但是vector可以实现她所实现的功能

5.2forward_list[useless]

比起list而言，每个节点可以节省一个指针的空间
头插头删是效率较高
但是现在一般都不缺内存 用list更好

5.3unordered_map/unordered_set

由[哈希/散列]模拟实现[unordered_map/unordered_set] (手撕迭代器)

5.4统一增加

1、为容器增加支持initializer_list的构造函数
2、增加cbegin和cend系列迭代器接口


3.移动构造/移动赋值
4.右值引用插入接口函数

6.知乎文章

C++23的目标