C++11——神奇的右值引用与移动构造

前言

本篇博客将主要讲述c++11中新添的新特性——右值引用和移动构造等，从浅到深的了解这个新特性的用法，以及它的意义是什么，并且最后深入探究了一些右值引用的细节问题， 并且从中引出了什么是万能引用和完美转发以及其的一些意义，会通过一些例子帮助大家更好的理解这一语法。

左值引用和右值引用

我们直到，传统的c++语法中就有引用的语法，而C++11中新增了右值引用的语法特性，所以从现在开始我们之前学习的引用都叫做右值引用，但首先要说明的一个点就是:无论是右值引用还是左值引用，都是在给对象取别名。

那么，如果想要了解右值引用到底有什么用，我们就需要知道什么是右值？右值和左值有什么区别？

左值: 一个表示数据的表达式(如变量名或者解引用的指针)，我们可以获取它的地址，并且可以对它赋值。左值可以出现在赋值符号的左边，右值一般不可以出现在右值符号的左边。const修饰后的左值虽然不能赋值，但是可以取它的地址。
如下是一些左值的例子:

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13

右值：一个表示数据的表达式，如：字面常量，表达式返回值，函数返回值(除左值引用返回)等，一般来说，右值可以出现在赋值符号的右边，但不能出现在赋值符号左边，并且不能取地址！
内置类型的右值又叫做纯右值，而考虑自定义类型，我们知道对于自定义类型来说是没有字面常量的，也没有表达式返回值(对于运算符重载其本质也是函数调用的返回值)，只有函数返回值，所以自定义类型的右值也被叫做将亡值。

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);
	//通过使用标准库中的move函数可以将左值转化成右值
	double&& rr4 = std::move(x);
	// 下面编译会报错：error C2106: “=”: 左操作数必须为左值 
	//10 = 1; 
	//x + y = 1; 
	//fmin(x, y) = 1;
	return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

通过以上定义我们就可以发现，一般区分左值和右值是通过是否能取地址来分辨的。

一个常量字符串(例“aabbcc”是左值还是右值呢？)
是右值！虽然我们可以取得它的地址，但其并不是整个字符串的地址，而是字符串首元素的地址，并且它也不能放在赋值符号左边。

那么，了解了左值和右值的区别了之后，我们很容易发现，**const左值引用也是可以引用右值的！**既然如此，为什么又要创造右值引用这个新特性呢？如果想要解决这个问题，我们就要首先了解以下左值引用的缺陷并且引出右值引用的使用场景和意义了！

---

右值引用的使用场景和意义

为了更好的观察右值引用的意义所在，博主自己造了一个模仿c++string的简易轮子，这个模拟的string在进行构造和深拷贝的时候会打印信息，另外在这里还给出了移动拷贝和赋值的代码，进行移动拷贝和赋值也会打印信息(对于移动拷贝和赋值是什么后续会给出解答)

namespace lzz
{
	class string {
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str;
		}
		iterator end()
		{
			return _str + _size;
		}
		string(const char* str = "") :_size(strlen(str)), _capacity(_size)
		{ //
			cout << "string(char* str)" << endl;
			_str = new char[_capacity + 1]; strcpy(_str, str);
		}
		// s1.swap(s2) 
		void swap(string& s)
		{
			::swap(_str, s._str);
			::swap(_size, s._size);
			::swap(_capacity, s._capacity);
		}
		// 拷贝构造 
		string(const string& s) :
			_str(nullptr)
		{
			cout << "string(const string& s) -- 深拷贝" << endl;
			string tmp(s._str);
			swap(tmp);
		}
		// 赋值重载 
		string& operator=(const string& s)
		{
			cout << "string& operator=(string s) -- 深拷贝" << endl;
			string tmp(s);
			swap(tmp);
			return *this;
		}
		// 移动构造 
		string(string&& s) noexcept
			:_str(nullptr), _size(0), _capacity(0)
		{
			cout << "string(string&& s) -- 移动语义" << endl;
			swap(s);
		}
		// 移动赋值 
		string& operator=(string&& s) noexcept
		{
			cout << "string& operator=(string&& s) -- 移动语义" << endl;
			swap(s);
			return *this;
		}
		~string()
		{
			delete[] _str;
			_str = nullptr;
		}
		char& operator[](size_t pos)
		{
			assert(pos < _size);
			return _str[pos];
		}
		void reserve(size_t n)
		{
			if (n > _capacity)
			{
				char* tmp = new char[n + 1];
				strcpy(tmp, _str);
				delete[] _str;
				_str = tmp;
				_capacity = n;
			}
		}
		void push_back(char ch)
		{
			if (_size >= _capacity)
			{
				size_t newcapacity = _capacity == 0 ? 4 : _capacity * 2;
				reserve(newcapacity);
			}
			_str[_size] = ch; ++_size;
			_str[_size] = '\0';
		}
		//string operator+=(char)
		string& operator+=(char ch)
		{
			push_back(ch);
			return *this;
		}
		const char* c_str() const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;

	};
};
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
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

首先，我们知道左值引用的诞生其实是为了提高程序运行的效率，做参数和做返回值是都可以提高效率！

void func1(lzz::string s) {}
void func2(const lzz::string& s) ()
int main()
{
	lzz::string s1("hello world");
	func1(s1);
	func2(s1);
	return 0;
}
1
2
3
4
5
6
7
8
9

注意，由于在模拟实现时深拷贝中调用了常量字符串构造函数，所以每次深拷贝时都会打印两次。
这极大的提高了大对象调用函数的效率。

左值引用的短板:
我们来想想左值引用还有什么短板，考虑当函数返回对象时一个局部变量时，当函数调用结束后，该变量就被销毁了，所以此时我们不能用左值引用返回，只能用传值引用返回。这样对性能是有比较大的损失的。

对于传值返回，较旧的编译器会进行两次拷贝构造，较新的编译器会进行优化，但也需要一次拷贝构造。

---

那么，此时右值引用就派生用场了。
右值引用和移动语义解决上述问题:
移动构造的本质是利用右值引用，将参数右值的资源窃取过来，占为己有，这样就不用做深拷贝了，就是窃取别人的资源来构造自己，移动赋值同理。

		// 移动构造 
		string(string&& s) 
			:_str(nullptr), _size(0), _capacity(0)
		{
			cout << "string(string&& s) -- 移动语义" << endl;
			swap(s);
		}

1
2
3
4
5
6
7
8

移动构造和移动赋值内部其实完成的是数据的交换工作，因为我们知道右值中的数据是会销毁的，如果不进行交换，就会导致在销毁时将需要保留的数据直接销毁，另外在进行移动赋值的时候还有可能导致原来的数据无法找到，造成内存泄漏。

加上移动构造后上述代码的打印结果:

右值引用引用左值

按照语法，右值引用可以引用右值，但是右值引用可以引用左值吗？正常情况下是不可以的，但是标准库中为我们提供了一个函数move()可以做到这件事，传入左值之后，将会返回右值。

int main()
{
	lzz::string s1("xxx");
	//调用拷贝构造
	lzz::string s2(s1);
	//调用移动构造
	lzz::string s3(move(s1));
}
1
2
3
4
5
6
7
8

这里需要注意的是，虽然move()函数返回的是该对象的右值，但是仍然会修改该对象的数据，如下：

万能引用

右值引用出现的同时，c++还退出了一个模板的万能引用规则，语法如下:

template<typename T>
void func(T&& t)
{
	//...
}
1
2
3
4
5

也就是说模板中的&&并不是代表左值引用，而是万能引用，也就是说其既可以接受左值也可以接受右值！另外，如果传输的是对应const类型的引用，其也会自动推导成对应的const类型。

那么，在知道了万能引用之后，我们通过下面这些代码再次引出关于右值引用的一些问题。

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;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

可能有些人觉得，既然有万能引用，那肯定是穿什么类型调用什么类型的函数啊！这还不简单。

可是真有这么简单吗，我们先看结论，后解释结果。

结果既然是全是调用左值引用版本的func()！！这是为什么呢，难道是万能引用并不能引用右值吗？但是实际情况是万能引用确实可以引用左值，这里可以通过监视窗口进行查看：

这里我们传入10这个右值，可以发现此时t的类型是int&&，是右值引用，说明万能引用没有问题！那为什么会出现这种情况呢，这其实跟右值引用的属性有关，接下来我们就来深入探讨一下这一问题！

右值引用的属性

要探究这个问题，首先我们对PerfectForward(T&& t) 做一个修改，让其能够打印变量所在的地址

template<typename T> 
void PerfectForward(T&& t) 
{ 
	cout << &t << endl;
	Fun(t); 
}
1
2
3
4
5
6

我们知道右值是不能打印地址的，所以这样子做正常来说应该会报错，但是呢结果如下：

没错，程序成功运行！并且打印出了所有地址！

这就说明了一个性质：右值引用的属性是左值！！！

其实，之所以这么搞，是为了右值引用更好的使用，想象一下，如果右值引用的属性是右值，那么我们就无法修改其中的内容，那么对于上面的移动构造和移动赋值，就无法进行swap()函数交换内容，也就无法提高效率，因此右值引用在这种场景下不能是右值。
const &&禁止了对其的修改权限

其实对于右值引用来说，对于将亡值而言可以理解为当其作为返回值返回时先暂时保留这快空间中的内容，并且能够修改这块空间，在使用结束后才真正销毁。

那么，有没有办法能够让参数保持当前的属性继续向下传递呢？答案是有的，c++考虑到了这个问题，所以设计了完美转发功能

完美转发

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

使用方法如下：

template<typename T> 
void PerfectForward(T&& t) 
{ 
	Fun(std::forward<T>(t)); 
}
1
2
3
4
5

上面的代码加上完美转发之后，就可以属性原生属性的保持，打印结果如下：

完美转发的使用场景：

例如list ls中，如果我们想要插入一个通过隐式类型转换的临时string，如ls.push_back("hello world")，我们想在push_back()内部调用string的移动构造函数，就必须使用完美转发，如下：

新的默认构造函数

原来的c++中，有6个默认成员函数

1. 构造函数
2. 析构函数
3. 拷贝构造函数
4. 拷贝赋值函数
5. 取地址重载
6. const取地址重载
   C++11新增两个：默认移动构造函数和默认移动赋值函数

但这两个函数的生成条件是有限制的：

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

强制和禁止生成默认函数

C++11中还添加了一个强制生成默认函数的关键字default和禁止默认生成函数的关键字delete

如下：

class A
{
private:
	int _a;
public:
	~A() {}
	//提供了析构函数，不满足默认生成移动构造的性质
	A(A&& a) = default //强制自动生成
	//没有提供拷贝构造，禁止自动生成
	A(const A& a) = delete;
}；
1
2
3
4
5
6
7
8
9
10
11

总结

以上就是关于C++11中右值引用的具体内容了，这段内容可以说是比较容易搞混，大家一定要自己去敲代码自己实验一下这些特性加深理解！另外，如果博主哪里写的有问题或者有疑惑的，欢迎评论区提出！