【C++高阶】：C++11的深度解析上

✨ 心似白云常自在，意如流水任东西 🌏

🔥个人专栏：C++学习

🚀 欢迎关注：👍点赞 👂🏽留言 😍收藏 💞 💞 💞

🚀 前言

相比于C++98/03，C++11则带来了数量可观的变化，其中包含了约140个新特性，以及对C++03标准中约600个缺陷的修正，这使得C++11更像是从C++98/03中孕育出的一种新语言。相比较而言，C++11能更好地用于系统开发和库开发、语法更加泛华和简单化、更加稳定和安全，不仅功能更强大，而且能提升程序员的开发效率，公司实际项目开发中也用得比较多，所以我们要作为一个重点去学习

1. 统一的列表初始化

💫1.1 { }初始化

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

cpp 复制代码

struct Pxt // C++98
{
	int _x;
	int _y;
};
int main(){
	Pxt p = { 1, 2 };
	return 0;
}

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

cpp 复制代码

struct Pxt // C++11
{
	int _x;
	int _y;
};
int main(){
	int a = 1;
	int b{ 2 };
	Pxt p{ 1, 2 };
	
	// C++11中列表初始化也可以适用于new表达式中
	int* pa = new int[4]{ 0 };
	return 0;
}

我们的自定义创建的对象也可以使用列表初始化方式调用构造函数初始化

cpp 复制代码

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(2024, 7, 28); // old style
	// C++11支持的列表初始化，这里会调用构造函数初始化
	Date d2{ 2024, 7, 29 }; 
	Date d3 = { 2024, 7, 30 };  //{} 必须和Date构造参数个匹配
   
    vector<int> v1 = { 2024,7,25 }; // {} 列表中可以有任意多个值
	return 0;    
}

💫1.2 std::initializer_list

initialize_list相关文档

initializer_list 是 C++11 引入的一个特性，它提供了一种方式来初始化容器类对象或函数参数列表，使得可以使用花括号 { } 来直接初始化对象或传递参数。initializer_list 是一个轻量级的模板类，它用于表示一个给定类型的值的数组，但大小是固定的，且生命周期与包含它的对象相同。

代码示例如下：

cpp 复制代码

int main()
{
	auto it = { 1 ,2 };
	// initializer_list
	cout << typeid(it).name() << endl;
	return 0;
}

std::initializer_list一般是作为构造函数的参数，C++11对STL中的不少容器就增加

std::initializer_list作为参数的构造函数，这样初始化容器对象就更方便了。也可以作为operator=的参数，这样就可以用大括号赋值

代码示例如下：

cpp 复制代码

int main()
{
	std::initializer_list<int> mylist; //相当于在栈上开了一个数组
	mylist = { 10,20,30 };
	cout << sizeof(mylist) << endl;

	cout << mylist.begin() << endl;
	cout << mylist.end() << endl;
	cout <<&d1 << endl;

	map<string, string> dict = { {"sort","排序"},{"left","左边"} };

	return 0;
}

2. 变量类型推导

🌈2.1auto关键字

在C++98中auto是一个存储类型的说明符，表明变量是局部自动存储类型，但是局部域中定义局部的变量默认就是自动存储类型，所以auto就没什么价值了。C++11中废弃auto原来的用法，将其用于实现自动类型腿断。这样要求必须进行显示初始化，让编译器将定义对象的类型设置为初始化值的类型。

由于之前我们介绍过，这里我们就不过多介绍，详情请见 【C++ 初阶】内联 auto&范围for循环&指针空值

🌈2.2 decltype

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

代码如下：

cpp 复制代码

// decltype的一些使用使用场景
template<class T1, class T2>
void F(T1 t1, T2 t2){
	decltype(t1 * t2) ret;
	cout << typeid(ret).name() << endl;
}
int main(){
	const int x = 1;
	double y = 2.2;
	decltype(x * y) ret;
	decltype(&y) p;
	
	cout << typeid(ret).name() << endl; // ret的类型是double
	cout << typeid(p).name() << endl;   // p的类型是int*
	
	F(1, 'a');
	return 0;
}

注意：可能大多数人都会认为decltype和auto是一样的，但是对于以下场景只有decltype能做到 ，例如：decltype推导的类型可以作为容量里面的参数。

cpp 复制代码

int main(){
	map<string, string> m = { { "insert", "插入" }, { "sort", "排序" } };
	auto it = m.begin();
	//vector<auto it> v;   //错误
	vector<decltype(it)> v;//正确
	return 0;
}

🌈2.3 nullptr

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

cpp 复制代码

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

3. 右值引用和移动语义

🎈3.1 概念

①什么是左值？什么是左值引用？

左值是一个表示数据的表达式（如变量名和解引用的指针），我们可以获取它的地址，也可以对它赋值，左值可以出现在赋值符号的左边，右值不可以出现在左边。左引用加const修饰，不能对其赋值，但可取地址，是一种特殊情况。左值引用就是给左值取别名。

左值可以取地址，可以出现在等号左边，可以改变值的大小（const类型除外）。

cpp 复制代码

int main(){
	// 以下的p、b、c、*p都是左值，都能被取地址
	int* p = new int(0);
	int b = 1;
	const int c = 2;
	// 以下几个是对上面左值的左值引用
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue = *p;
	return 0;
}

②什么是右值？什么是右值引用？

右值也是一个表示数据的表达式，如：字面常量、表达式返回值、传值返回函数的返回值（不能是左值引用返回）等 ，右值可以出现在赋值符号的右边，但是不能出现在左边 。右值引用就是给右值取别名。右值引用是C++11引入的一种新类型的引用，它通过类型后加&& 来表示。右值引用可以绑定到右值上，但也可以绑定到左值 上（需要std::move来显式转换）。右值引用的主要目的是允许函数或操作以"移动"而不是"复制"的方式处理资源，这通常意味着资源的所有权从源对象转移到目标对象，源对象则变为一个安全可销毁的状态。

右值不可以被取地址，不可以出现在等号左边，只能出现在等号右边，不可以改变值的大小。右值一般有两种，一种是纯右值 ，一种是将亡值（函数返回的临时变量）

cpp 复制代码

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);
	// 以下编译会报错：error C2106: "=": 左操作数必须为左值
	//10 = 1; 
	//x + y = 1;
	//fmin(x, y) = 1;
	return 0;
}

总结：

可以取地址的对象就是左值，不取地址的对象就是右值。给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址(可以理解为对右值取别名之后，这个别名就变为了左值)，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用

移动语义

移动语义允许对象通过转移其资源（如动态分配的内存）而不是复制它们来初始化或赋值另一个对象。这通常是通过一个特殊的成员函数------移动构造函数和移动赋值操作符来实现的。这两个函数都接受右值引用作为参数，表示它们可以从一个即将被销毁的对象中"窃取"资源。

移动构造函数： 接受一个右值引用参数，用于初始化新对象，通过转移源对象的资源而不是复制它们，从而避免不必要的资源分配和复制。

移动赋值操作符： 同样接受一个右值引用参数，用于将一个对象的资源转移到另一个已经存在的对象上，并将源对象置于一个可析构的状态。

🎈3.2 左值引用和右值引用比较

左值引用总结：

左值引用只能引用左值，不能引用右值

const左值引用既可引用左值，也可引用右值

cpp 复制代码

// 左值引用只能引用左值，不能引用右值
int a = 10;
int& ra1 = a; // ra为a的别名
//int& ra2 = 10; // 编译失败，因为10是右值
 
//const左值引用既可以引用左值，也可以引用右值
const int& ra3 = 10;
const int& ra4 = a;

右值引用总结：

右值引用只能引用右值，一般情况下不能引用左值

右值引用可以引用move以后的左值

cpp 复制代码

int a = 10;
int b = 20;
//不能引用左值
//int&& rr1 = a;
int&& rr2 = 10;
int&& rr3 = move(a);//强制转换为右值引用

注意：当对一个对象使用move时，你实际上是在告诉编译器："这个对象我之后可能不再需要了，或者我可以接受它处于某种未定义状态，所以你可以安全地'窃取'它的资源。"，从而变成将亡值**，然后，编译器会寻找接收该对象的函数是否支持移动语义（即是否有一个接受右值引用的构造函数或赋值运算符）**

🎈3.3 右值引用使用场景和意义

前面我们可以看到左值引用既可以引用左值和又可以引用右值，那为什么C++11还要提出右值引

用呢？是不是化蛇添足呢？下面我们来看看左值引用的短板，右值引用是如何补齐这个短板的!

我们先来看一下左值引用的优势：在左值引用做参数或者做返回值时能够很好的减少拷贝次数，从而提高效率。

举个例子：

cpp 复制代码

void fun1(bit::string s)
{}
void fun2(bit::string& s)
{}
int main()
{
	bit::string s("1234");
	//fun1(s);
	//fun2(s);//左值引用提高了效率，不存在拷贝临时对象的问题
 
	//可以使用左值引用返回，这个对象还在
	s += 'a';
	//不能使用左值引用返回，这个就是左值引用的一个短板
	//函数返回对象出了作用域就不在了，就不能用左值引用返回（因为返回的是本身地址，栈帧已销毁）
	//所以会存在拷贝问题
	bit::string ret = bit::to_string(1234);
	return 0;
}

分析：

但是当函数返回对象是一个局部变量，出了函数作用域就不存在了，就不能使用左值引用返回 ，只能传值返回 。例如：bit::string to_string(int value)函数中可以看到，这里只能使用传值返回**，传值返回会导致至少1次拷贝构造(如果是一些旧一点的编译器可能是两次拷贝构造，先把这个值拷贝给一个临时变量** ，然后临时变量在拷贝给接收值)。

图解如下：

to_string的返回值是一个右值，用这个右值构造ret2，如果没有移动构造，调用就会匹配调用拷贝构造，因为const左值引用是可以引用右值的，这里就是一个深拷贝

因此可知在值拷贝过程中发生了深拷贝，这导致效率是很低的，然后为了解决这一问题，c++增加了移动构造 和移动赋值。

移动构造和移动拷贝代码示例如下：

cpp 复制代码

// 移动构造，右值走移动构造
// 临时创建的对象，不能取地址，用完就要消亡
// 深拷贝的类，移动构造才有意义
string(string&& s)
	:_str(nullptr)
	, _size(0)
	, _capacity(0)
{
	cout << "string(string&& s) -- 移动拷贝" << endl;
	swap(s);
}

// 移动赋值
string& operator=(string&& s)
{
	cout << "string& operator=(string&& s) -- 移动赋值" << endl;
	swap(s);
	return *this;
}

🌸①移动构造

如果既有拷贝构造又有移动构造调用就会匹配调用移动构造，因为编译器会选择最匹配的参数调用。那么这里就是一个移动语义

在发生拷贝时，编译器会优先把bit::string to_string(int value)函数的返回值当成右值处理，如果类中有移动构造则调用移动构造，没有移动构造再调用拷贝构造。

移动构造本质是将参数右值的资源窃取过来，占位已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己，而移动构造中没有新开空间，拷贝数据，所以效率就提高了

🌸②移动赋值

只有在定义ret1时接收返回值编译器才能进行优化成一次构造，像下面这样写编译器需要将bit::string to_string(1234)的值构造形成临时变量，再将临时变量赋值给ret1。上面提到过，编译器会优先返回值当成右值去处理，故移动构造出临时变量，再移动赋值给ret1。

总结：移动构造和移动赋值的效率是很高的，它的本质是把右值的资源窃取过来占为己有，就不用再花力气拷贝了。反正右值一般是会快速消失的，即便资源被窃取了也不会有影响。

🎈3.4 move函数

move：当需要用右值引用引用一个左值时，可以通过move函数将左值转化为右值。C++11中，std::move()函数位于头文件中，该函数名字具有迷惑性，它并不搬移任何东西，唯一的功能就是将一个左值强制转化为右值引用，然后实现移动语义。

但要注意，被强制转化为右值的左值资源可能会被掠夺，掠夺之后不能在使用这些资源，否则会出错。

代码示例：

cpp 复制代码

int main()
{
	list<bit::string> lt;
	bit::string s1("1111");
	// 这里调用的是拷贝构造
	lt.push_back(s1);
	// 下面调用都是移动构造
	lt.push_back("2222");
     
    // 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
	// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
	// 资源被转移给了s3，s1被置空了。
    bit::string s3(std::move(s1));
	//lt.push_back(std::move(s1));

	return 0;
}

🎈3.5 完美转发

模板中的&& 万能引用：

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力。

代码测试如下：

cpp 复制代码

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }
void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }

template<typename T>
void PerfectForward(T&& t)
{
	Fun(t);
}
int main()
{
	PerfectForward(10); // 右值
	int a;
	PerfectForward(a); // 左值
	PerfectForward(std::move(a)); // 右值
	const int b = 8;
	PerfectForward(b); // const 左值
	PerfectForward(std::move(b)); // const 右值
	
	return 0;
}

但是结果却出乎意料，打印的都是左值引用

这是因为右值引用的对象，再次传递时会退化成左值引用，其实这很好理解，上文我们提到过，右值一旦被引用就会被存在一个特定的地方并且可以取到地址，所以再次使用时编译器就会把它当成左值了。想要保持它的右值属性，就要使用完美转发
因此我们得到如下结论：

模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值

模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力

但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值

这个时候我们就应该用到我们需要的完美转发了

std::forward 完美转发在传参的过程中保留对象原生类型属性：

只要在传参是时候加上完美转发，就可以保留右值属性。

cpp 复制代码

template<typename T>
void PerfectForward(T&& t){
    Fun(std::forward<T>(t));
}

在实际中的应用：

cpp 复制代码

void Insert(Node* pos, T&& x)
{
	Node* prev = pos->_prev;
	Node* newnode = new Node;
	newnode->_data = std::forward<T>(x); // 关键位置
	// prev newnode pos
	prev->_next = newnode;
	newnode->_prev = prev;
	newnode->_next = pos;
	pos->_prev = newnode;
}

4. 新的类功能

🧩4.1 新增默认成员函数

C++11在原来的基础上新增了两个默认成员函数：移动构造函数和移动赋值运算符重载

关于这两个函数需要注意:

如果你没有自己实现移动构造函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个 。那么编译器会自动生成一个默认移动构造 。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝 ，自定义类型成员 ，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。

如果你没有自己实现移动赋值重载函数，且没有实现析构函数、拷贝构造、拷贝赋值重载中的任意一个 ，那么编译器会自动生成一个默认移动赋值。默认生成的移动构造函数，对于内置类型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动赋值，如果实现了就调用移动赋值，没有实现就调用拷贝赋值。(默认移动赋值跟上面移动构造完全类似)

如果你提供了移动构造或者移动赋值，编译器不会自动提供拷贝构造和拷贝赋值

🧩4.2 default和delete

强制生成默认函数的关键字default:

C++11可以让你更好的控制要使用的默认函数。假设你要使用某个默认的函数，但是因为一些原因这个函数没有默认生成。比如：我们提供了拷贝构造，就不会生成移动构造了，那么我们可以使用default关键字显示指定移动构造生成。

cpp 复制代码

Person(Person&& p) = default;

禁止生成默认函数的关键字delete:

如果能想要限制某些默认函数的生成，在C++98中，是该函数设置成private，并且只声明补丁，这样只要其他人想要调用就会报错。在C++11中更简单，只需在该函数声明加上=delete即可，该语法指示编译器不生成对应函数的默认版本，称=delete修饰的函数为删除函数。

cpp 复制代码

Person(const Person& p) = delete;