🌈欢迎来到C++专栏~~C++11

---

• (꒪ꇴ꒪(꒪ꇴ꒪ )🐣,我是Scort
• 目前状态：大三非科班啃C++中
• 🌍博客主页：张小姐的猫~江湖背景
• 快上车🚘，握好方向盘跟我有一起打天下嘞！
• 送给自己的一句鸡汤🤔：
• 🔥真正的大师永远怀着一颗学徒的心
• 作者水平很有限，如果发现错误，可在评论区指正，感谢🙏
• 🎉🎉欢迎持续关注！
  

一. 十年磨不出一剑

众所周知C++不像python，是比较严谨的，C++ 标准委员会按常理都会一段时间对 C++ 进行更新修正，但是很明显标准委员会摸鱼的摸鱼，犹豫的犹豫，计划一拖再拖最后问世于 2011 年，索性得名——C++11。

相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。

相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习

话不多说，坐稳发车了

二. 统一的列表初始化

C++98 允许使用大括号 {} 对数组或者结构体元素进行统一的列表初始值设定，举个栗子：

struct Point
{
	 int _x;
	 int _y;
};
int main()
{
	//数组元素初始化
	int a[] = { 1, 2, 3};
	int b[3] = { 1 };

	//结构体元素初始化
	Pointn = { 1, 2 };
	return 0;
}

众所周知，{} 的内容就是初始化列表，C++11 拓宽了 {} 业务范围，所有的内置类型和自义定类型都可以使用初始化列表初始化，在 {} 之后可以使用 = ，也可以不使用，但是在进行 new 表达式初始化时一定不能加 = （C++11新增语法）：

struct Num
{
	int _x;
	int _y;
};
int main()
{
	//对内置类型初始化
	int x1 = { 1 }; 
	int x2{ 2 };    

	//{}对数组元素进行初始化
	int a[]{ 1, 2, 3 }; 
	int b[3]{ 1 };      

	//{}对结构体元素进行初始化
	Num p{ 1, 2 }; 

	//C++11中列表初始化也可用于new表达式中（C++98无法初始化）
	int* p1 = new int[3]{ 0 };
	int* p2 = new int[3]{ 1,2,3 };//不能加等号
}

同样的，构造函数初始化也可以这样写

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(2023, 1, 29);

	//C++11的 ~ 不建议使用了
	Date d2 = { 2023, 1, 29 };   
	Date d3{ 2023, 1, 29 };      //不加等号
	return 0;
}

上面的都是小case，主要更方便的用于容器的初始化

	//就不用慢慢的push_back数据了
	vector<int> v1 = { 1,2,3,4,5,6 };
	vector<int> v2 { 1,2,3,4,5,6 };

	list<int> v3 = { 1,2,3,4,5,6 };
	list<int> v4 { 1,2,3,4,5,6 };

但是为什么可以这样实现呢？就要牵扯到一个新的容器了

initializer_list

itializer_list 是一个容器，是 C++11 新增的，但是他不像其他容器一样提供了花里胡哨的成员函数

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

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

	auto num = { 1,2,3 };
	cout << typeid(num).name() << endl;

💦应用场景

思考一下为什么 initializer_list 没有提供相应的增删查改的接口函数，其实内涵就是告诉你咱们 initializer_list 的目的不是去存储数据的，而是为了让其他容器支持列表初始化：

C++98 不支持直接用列表对容器进行初始化，这种初始化方式是在C++11引入initializer_list后才支持的，而这些容器之所以支持使用列表进行初始化：

• 根本的原因在于C++11给这些函数增加了一个构造函数，这个构造函数是以initializer_list 作为参数的

当用列表对容器进行初始化时，这个列表被识别成 initializer_list 类型，于是就会调用这个新增的构造函数对该容器进行初始化。这个新增的构造函数要做的就是遍历 initializer_list 中的元素，然后将这些元素依次插入到要初始化的容器当中即可

//构造函数遍历 initializer_list 中的元素
vector(initializer_list<T> il)
	:_start = (nullptr)
	, _finish = (nullptr)
	, _endofstorage =(nullptr)
{
	reserve(il.size());
	//范围for遍历
	for (auto& e：il)
	{
		push_back(e);
	}
}

我们知道单参数的构造函数支持隐式类型的转换

string s1 = "11111";  //先构造一个匿名的string，再拷贝构造 -> 编译器优化成构造
//多参数隐式类型转换
vector<Date> v5 = { d1, d2, d3 };
vector<Date> v6 = { {2023, 1, 29}, {2023, 1, 30} };

总结：C++11以后的一切对象都可以用列表初始化，但是建议普通对象还是用以前方式初始化，容器如果有需求的可以使用列表初始化

三 . 简化声明

1️⃣auto

一般当一个类型过长，比如迭代器，我们就会经常使用auto，用于实现自动类型推断

int main()
{
	int i = 10;
	auto p = &i;
	auto pf = strcpy;

	cout << typeid(p).name() << endl;  //int *
	cout << typeid(pf).name() << endl; //char * (__cdecl*)(char *,char const *)

	map<string, string> dict = { { "sort", "排序" }, { "insert", "插入" } };
	//map<string, string>::iterator it = dict.begin();
	auto it = dict.begin();  //简化代码

	return 0;
}

2️⃣decltype

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

int main()
{
	int x = 10;
	//typeid拿到的只是类型的字符串，不能用这个再去定义对象
	typeid(x).name() y = 20;   //报错

	decltype(x) y = 20;
	return 0;
}

注意：通过typeid(变量名).name()的方式可以获取一个变量的类型，但无法用获取到的这个类型去定义变量

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

但是细心的同学就会问：auto不也能做到吗？

int main()
{
	int x = 10;
	decltype(x) y1 = 20.11;   //由x决定： int
	auto y2 = 20.11;          //由右边的值推导决定

	cout << y1 << endl;
	cout << y2 << endl;
	return 0;
}

3️⃣nullptr

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

#ifndef NULL
#ifdef __cplusplus
#define NULL    0
#else  
#define NULL    ((void *)0)
#endif  
#endif  /* NULL */

💢例子传送门~详细解析

四. 范围for循环

C++11中引入了基于范围的for循环，for循环后的括号由冒号分为两部分，第一部分是范围内用于迭代的变量，第二部分则表示被迭代的范围。比如

int main()
{
	int arr[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	//将数组元素值全部乘以2
	for (auto& e : arr)
	{
		e *= 2;
	}
	//打印数组中的所有元素
	for (auto e : arr)
	{
		cout << e << " ";
	}
	cout << endl;
	return 0;
}

注意： 与普通循环类似，可用continue来结束本次循环，也可以用break来跳出整个循环

一、for循环迭代的范围必须是确定的
  对于数组而言，就是数组中第一个元素和最后一个元素的范围；对于类而言，应该提供begin和end的方法，begin和end就是for循环迭代的范围。

二、迭代的对象要支持++和==操作
  范围for本质上是由迭代器支持的，在代码编译的时候，编译器会自动将范围for替换为迭代器的形式。而由于在使用迭代器遍历时需要对对象进行++和 ==操作，因此使用范围for的对象也需要支持++和 ==操作

STL中一些变化

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

🎨array容器

array容器本质就是一个静态数组，即固定大小的数组

array容器有两个模板参数，第一个模板参数代表的是存储的类型，第二个模板参数是一个非类型模板参数，代表的是数组中可存储元素的个数。比如：

int main()
{
	array<int, 10> a1;   //定义一个可存储10个int类型元素的array容器
	array<double, 5> a2;
	return 0;
}

那么array和普通数组的区别是什么呢？

• 对于C语言数组越界检测，越界读基本检查不出来，越界写是抽查（看情况），array的越界读写都能检查出来
• 因为array容器用一个类对数组进行了封装，并且在访问array容器中的元素时会进行越界检查。用[]访问元素时采用断言检查，调用at成员函数访问元素时采用抛异常检查
• array容器与普通数组一样，支持通过[]访问指定下标的元素，也支持使用范围for遍历数组元素，并且创建后数组的大小也不可改变

但array容器与其他容器不同的是，array容器的对象是创建在栈上的，因此array容器不适合定义太大的数组，所以实际用途不如vector

🎨forward_list容器

forward_list容器本质就是一个单链表

forward_list很少使用，原因如下：

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

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

🎨容器中的新方法

C++11为每个容器都增加了一些新方法，比如：

• ✨提供了一个以initializer_list作为参数的构造函数，用于支持列表初始化（中规中矩）
• ❌比较鸡肋的接口：cbegin 、cend系列（差）
• 🔥移动构造和移动赋值（满分）
• 🔥右值引用参数的插入（满分）

右值引用下一篇详细解析！

📢写在最后

流浪地球2给我冲