【C++11】右值引用和移动语义

C++11——右值引用和移动语义

一、基本概念

传统的C++语法中就有引用的语法，而C++11中新增了的右值引用语法特性，所以从现在开始我们之前学习的引用就叫做左值引用。无论左值引用还是右值引用，都是给对象取别名。

---

1.左值引用和右值引用

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

左值是一个表示数据的表达式(如变量名或解引用的指针)，有如下特性：

• 1、我们可以获取它的地址+可以对它赋值（不一定能赋值，但一定能取地址）

• 2、左值可以出现赋值符号的左边，右值不能出现在赋值符号左边

• 3、定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址

• 左值引用就是给左值的引用，给左值取别名。

void cpp11_test4()
{
     
     
	//以下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;

	cout << p << ":" << rp << endl;
	cout << b << ":" << rb << endl;
	cout << c << ":" << rc << endl;
	cout << *p << ":" << pvalue << endl;
}

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

右值也是一个表示数据的表达式，如临时变量：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回，要是传值返回)等等，有如下特性：

• 1、右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，

• 2、右值不能取地址。

综上左值和右值最大区别在于左值可以取地址，右值不可以取地址（因为右值是临时变量，没有实际被存储起来。)

补充：

C++里又把右值分为两类（纯右值和将亡值）：

1.纯右值（内置类型的对象）：10、x + y、‘a’

2.**将亡值（自定义类型的对象）：**传值返回的拷贝对象：to_string(1234)、匿名对象：string(“xxxxx”)、s1 + “hello”

右值引用：

• 右值引用就是对右值的引用，给右值取别名。

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;
	*/

	/*
	这里编译会报错，右值不能取地址
	cout << &10 << endl;
	cout << &(x + y) << endl;
	cout << &fmin(x, y) << endl;
	*/
	return 0;
}

注意：

• 右值是不能取地址的，但是给右值取别名后，会导致右值被存储到特定位置，且可以取到该位置的地址，也就是说例如：不能取字面量10的地址，但是rr1引用后，可以对rr1取地址，也可以修改rr1。如果不想rr1被修改，可以用const int&& rr1 去引用，是不是感觉很神奇，这个了解一下实际中右值引用的使用场景并不在于此，这个特性也不重要。

int main()
{
     
     
	double x = 1.1, y = 2.2;
	int&& rr1 = 10;
	const double&& rr2 = x + y;
	rr1 = 20;
	rr2 = 5.5; // 报错
	return 0;
}

---

2.左值引用与右值引用的比较

左值引用总结：

1. 左值引用只能引用左值，不能引用右值
2. 但是const左值引用既可以应用左值，也可以引用右值

int main()
{
     
     
	// 左值引用只能引用左值，不能引用右值。
	int a = 10;
	int& ra1 = a; // ra为a的别名
	//int& ra2 = 10; // 编译失败，因为10是右值
	// const左值引用既可引用左值，也可引用右值。
	const int& ra3 = 10;
	const int& ra4 = a;
	return 0;
}

右值引用总结：

1. 右值引用只能引用右值，不能引用左值
2. 但是右值引用可以引用move以后的左值

int main()
{
     
     
	// 右值引用只能右值，不能引用左值。
	int&& r1 = 10;
	int a = 10;
	/*
	error C2440: “初始化”: 无法从“int”转换为“int &&”
	message : 无法将左值绑定到右值引用
	int&& r2 = a;
	*/
	// 右值引用可以引用move以后的左值
	int&& r3 = move(a);
	return 0;
}

再次强调这四句话：

1. 左值引用只能引用左值，不能引用右值
2. 但是const左值引用既可以引用左值，也可以引用右值
3. 右值引用只能引用右值，不能引用左值
4. 但是右值引用可以引用move以后的左值

右值引用是通过移动构造和移动赋值来极大提高深拷贝的效率，详情见下文：

---

二、右值引用使用场景和意义

前面我们可以看到和const左值引用既可以引用左值又可以引用右值，那为什么C++11还要提出右值引用呢？这不是画蛇添足呢？下面我们来看看左值引用的使用场景与短板（深拷贝的问题），以及右值引用是如何补齐这个短板的！

---

1.左值引用的使用场景

为了把整个过程说的通俗易懂，需要一个深拷贝的类，我们以先前模拟实现的string类来作为示例：简易版string类的模拟实现

类当中实现了一些基本的成员函数，并在string的拷贝构造函数和赋值运算符重载函数当中打印了一条提示语句，这样当调用这两个函数时我们就能够知道。

namespace cpp
{
     
     
	class string
	{
     
     
	public:
		typedef char* iterator;
		iterator begin()
		{
     
     
			return _str; //返回字符串中第一个字符的地址
		}
		iterator end()
		{
     
     
			return _str + _size; //返回字符串中最后一个字符的后一个字符的地址
		}
		//构造函数
		string(const char* str = "")
		{
     
     
			_size = strlen(str); //初始时，字符串大小设置为字符串长度
			_capacity = _size; //初始时，字符串容量设置为字符串长度
			_str = new char[_capacity + 1]; //为存储字符串开辟空间（多开一个用于存放'\0'）
			strcpy(_str, str); //将C字符串拷贝到已开好的空间
		}
		//交换两个对象的数据
		void swap(string& s)
		{
     
     
			//调用库里的swap
			::swap(_str, s._str); //交换两个对象的C字符串
			::swap(_size, s._size); //交换两个对象的大小
			::swap(_capacity, s._capacity); //交换两个对象的容量
		}
		//拷贝构造函数（现代写法）
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
     
     
			cout << "string(const string& s) -- 深拷贝" << endl;

			string tmp(s._str); //调用构造函数，构造出一个C字符串为s._str的对象
			swap(tmp); //交换这两个对象
		}
		//赋值运算符重载（现代写法）
		string& operator=(const string& s)
		{
     
     
			cout << "string& operator=(const string& s) -- 深拷贝" << endl;

			string tmp(s); //用s拷贝构造出对象tmp
			swap(tmp); //交换这两个对象
			return *this; //返回左值（支持连续赋值）
		}
		//析构函数
		~string()
		{
     
     
			delete[] _str;  //释放_str指向的空间
			_str = nullptr; //及时置空，防止非法访问
			_size = 0;      //大小置0
			_capacity = 0;  //容量置0
		}
		//[]运算符重载
		char& operator[](size_t i)
		{
     
     
			assert(i < _size); //检测下标的合法性
			return _str[i]; //返回对应字符
		}
		//改变容量，大小不变
		void reserve(size_t n)
		{
     
     
			if (n > _capacity) //当n大于对象当前容量时才需执行操作
			{
     
     
				char* tmp = new char[n + 1]; //多开一个空间用于存放'\0'
				strncpy(tmp, _str, _size + 1); //将对象原本的C字符串拷贝过来（包括'\0'）
				delete[] _str; //释放对象原本的空间
				_str = tmp; //将新开辟的空间交给_str
				_capacity = n; //容量跟着改变
			}
		}
		//尾插字符
		void push_back(char ch)
		{
     
     
			if (_size == _capacity) //判断是否需要增容
			{
     
     
				reserve(_capacity == 0 ? 4 : _capacity * 2); //将容量扩大为原来的两倍
			}
			_str[_size] = ch; //将字符尾插到字符串
			_str[_size + 1] = '\0'; //字符串后面放上'\0'
			_size++; //字符串的大小加一
		}
		//+=运算符重载
		string& operator+=(char ch)
		{
     
     
			push_back(ch); //尾插字符串
			return *this; //返回左值（支持连续+=）
		}
		//返回C类型的字符串
		const char* c_str()const
		{
     
     
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

---

左值引用解决的是拷贝构造引发的深拷贝而带来的开销过大、效率低的问题：

• 左值引用做参数，防止传值传参引发的拷贝构造问题（导致效率低）
• 左值引用做返回值，防止返回对象发生拷贝构造的操作（导致效率低）

void func1(cpp::string s)
{
     
     }
void func2(const cpp::string& s)
{
     
     }
int main()
{
     
     
	cpp::string s1("hello");
	func1(s1);//值传参
	func2(s1);//传引用传参

    // string operator+=(char ch) 传值返回存在深拷贝
    // string& operator+=(char ch) 传左值引用没有拷贝提高了效率
	s1 += '!';//左值引用作为返回值
	return 0;
}

总结：

• 我们都清楚string类的+=运算符是左值引用作为返回值，这样做避免了传值返回引发的拷贝构造，而这样做的原因在于string类的拷贝构造为深拷贝，需要开辟空间，拷贝数据等操作，资源开销太大了，导致效率低，传值传参同样也是会发生拷贝构造（深拷贝）这个问题，为了避免如此之大的开销，使用左值引用可以很好的解决此问题，因为左值引用就是取别名，无开销，提高了效率。
• 此外，因为string的+=运算符重载函数是左值引用返回的，因此在返回+=后的对象时不会调用拷贝构造函数，但如果将+=运算符重载函数改为传值返回，那么重新运行代码后你就会发现多了一次拷贝构造函数的调用。

---

2.左值引用的短板

左值引用可以避免一些不必要的拷贝构造操作，但是并不是所有情况都是可以避免的：

• 左值引用做参数，能够完全避免传参时不必要的拷贝操作
• 左值引用做返回值，并不能完全避免函数返回对象时不必要的拷贝操作

当函数返回的是一个临时对象时，不能使用引用返回，因为临时对象出了函数作用域就销毁了，只能使用传值返回，而传值返回难免会引发拷贝构造带来的深拷贝问题，但是无法避免，这就是左值引用的短板。

比如下面我们模拟实现一个int版本的to_string函数，这个to_string函数就不能使用左值引用返回，因为to_string函数返回的是一个局部变量。

示例：

namesapce cpp
{
     
     
	cpp::string to_string(int value)
	{
     
     
		bool flag = true;
		if (value < 0)
		{
     
     
			flag = false;
			value = 0 - value;
		}
		cpp::string str;
		while (value > 0)
		{
     
     
			int x = value % 10;
			value /= 10;
			str += ('0' + x);
		}
		if (flag == false)
		{
     
     
			str += '-';
		}
		std::reverse(str.begin(), str.end());
		return str;
	}
}

因为这里的to_string是传值返回，所以在调用to_string的时候一定会调用拷贝构造，而拷贝构造实现的又是一个深拷贝，效率低：

int main()
{
     
     
	cpp::string str = cpp::to_string(1234);
	return 0;
}

解释此情况不能用左值引用返回的原因：

• 如果强硬的把上面的to_string实现成左值引用返回，那么又会出现一个问题，str是临时对象，因为是左值引用返回，所以返回的是str的别名，把别名作为返回值再去拷贝构造ret对象，但是临时对象str出了作用域就调用析构函数销毁了，即使能够访问对象的值，但是空间已经不存在了，此时就发生了内存错误。

综上所述，为了解决左值引用的短板，C++11引出了右值引用，但并不是简单的把右值引用作为返回值，要对string进行改造，详情见下文：

---

3.移动语义

移动构造：

• string拷贝构造的const左值引用会接收左值和右值，但是编译器遵循最匹配原则，如果我们单独增加一个右值引用版本的拷贝构造函数，使其只能接收右值，根据最匹配原则，遇到右值，传入右值引用版本的拷贝构造函数，遇到左值传入左值引用版本的拷贝构造函数，这样就能解决了左值引用带来的弊端，而上述单独增加的函数就是我们的移动构造！！！

移动赋值：

• operator=函数采用的是const左值引用接收参数，因此无论赋值时传入的是左值还是右值，都会调用原有的operator=函数。增加移动赋值之后，由于移动赋值采用的是右值引用接收参数，因此如果赋值时传入的是右值，那么就会调用移动赋值函数（最匹配原则）。string原有的operator=函数做的是深拷贝，而移动赋值函数中只需要调用swap函数进行资源的转移，因此调用移动赋值的代价比调用原有operator=的代价小。

---

3.1.移动构造

为了解决左值引用的短板，我们需要在cpp::string中增加移动构造，移动构造的本质是将参数右值（将亡值）的资源窃取过来，占为已有，那么就不用做深拷贝了，所以它叫做移动构造，就是窃取别人的资源来构造自己。因为将亡值的特点就是很快就要被销毁了，在你销毁之前不如把这份资源通过移动构造传给别人。

• 该移动构造函数要做的就是调用swap函数将传入右值的资源窃取过来，为了能够更好的得知移动构造函数是否被调用，可以在该函数当中打印一条提示语句。

namespace cpp
{
     
     
	class string
	{
     
     
	public:
		//移动构造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
     
     
			cout << "string(string&& s) -- 移动构造" << endl;
			swap(s);
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

测试代码如下：

int main()
{
     
     
	cpp::string ret = cpp::to_string(1234);//转移将亡值的资源
	cpp::string s1("hello");
	cpp::string s2(s1);//深拷贝，左值拷贝时不会被资源转移
	cpp::string s3(move(s1));//转移将亡值的资源
	return 0;
}

• 注意：

当增加了string类的移动构造后，对于返回局部的string对象的函数，在返回对象时就会调用移动构造进行资源的移动，而不会再调用拷贝构造。

再来区分下移动构造和拷贝构造：

1. 在没有添加移动构造之前，拷贝构造采用的是const左值引用接收参数，所以无论拷贝对象时传的是左值还是右值，一定会引发调用拷贝构造函数。
2. 添加移动构造后，由于移动构造采用右值引用接收参数，只能接收右值。
3. 根据编译器的最匹配原则，左值传入左值引用的拷贝构造，右值传入右值引用的移动构造。
4. string的拷贝构造函数做深拷贝，而移动构造函数中只需要调用swap函数进行资源转移，所以调用移动构造的代价要小于拷贝构造。

---

3.2.移动赋值

我们用一个之前已经定义出来的对象来接收函数的返回值，当函数返回局部对象时，会先用这个局部对象拷贝构造出一个临时对象，然后再调用赋值运算符重载函数将这个临时对象赋值给接收函数返回值的对象。

移动赋值是一个赋值运算符重载函数，该函数的参数是右值引用类型的，移动赋值也是将传入右值的资源窃取过来，占为己有，这样就避免了深拷贝，所以它叫移动赋值，就是窃取别人的资源来赋值给自己的意思。

• 在当前的string类中增加一个移动赋值函数，该函数要做的就是调用swap函数将传入右值的资源窃取过来，为了能够更好的得知移动赋值函数是否被调用，可以在该函数中打印一条提示语句。

namespace cpp
{
     
     
	class string
	{
     
     
	public:
		//移动赋值
		string& operator=(string&& s)
		{
     
     
			cout << "string& operator=(string&& s) -- 移动赋值" << endl;
			swap(s);
			return *this;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

移动赋值和operator=的区别：

1. 在没有增加移动赋值之前，由于原有operator=函数采用的是const左值引用接收参数，因此无论赋值时传入的是左值还是右值，都会调用原有的operator=函数。
2. 增加移动赋值之后，由于移动赋值采用的是右值引用接收参数，因此如果赋值时传入的是右值，那么就会调用移动赋值函数（最匹配原则）。
3. string原有的operator=函数做的是深拷贝，而移动赋值函数中只需要调用swap函数进行资源的转移，因此调用移动赋值的代价比调用原有operator=的代价小。

测试代码如下：

int main()
{
     
     
	cpp::string ret;//string(string&& s) -- 移动构造，资源转移
	ret = cpp::to_string(1234);//string& operator=(string&& s) -- 移动赋值，资源转换
	return 0;
}

总结：

• 这里运行后，我们看到调用了一次移动构造和一次移动赋值。因为如果是用一个已经存在的对象接收，编译器就没办法优化了。cpp::to_string函数中会先用str构造生成一个临时对象，但是我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时对象做为cpp::to_string函数调用的返回值赋值给ret1，这里调用的移动赋值。
• 这里虽然调用两次函数，但都只是资源的移动，不需要进行深拷贝，大大提高了效率。

---

3.3.编译器做的优化

以如下代码为测试案例：

int main()
{
     
     
	cpp::string ret = cpp::to_string(1234);
	return 0;
}

3.1、先来看下没有移动构造编译器做的优化：

不优化：

• 如果没有移动构造，那我们先前实现的to_string只能够传值返回，传值返回会先拷贝构造出一个临时对象，再用这个临时对象再拷贝构造我们接收返回值的对象。如图所示：

优化：

• C++11标准出来之前，也就是C++98的情况，本来应该是两次拷贝构造，但是编译器对其进行了优化，连续两次的拷贝构造函数最终被优化成一次，直接拿str拷贝构造ret。

3.2、再来看看有移动构造编译器做的优化：

不优化：

• C++11出来后，我们假设它不优化，根据先前的了解，不优化的话，左值str会拷贝构造给一个临时对象，这个临时对象就是一个右值（将亡值），随后进行移动构造，也就是先拷贝构造再移动构造：

优化：

• C++11这里编译器进行优化后，左值str会被优化成右值（通过move把左值变为右值），再移动构造给一个临时对象，此临时对象再移动构造给ret，但是编译器还会再进行一次优化，把左值str识别出右值后直接移动构造给ret。也就是只进行一次移动构造：

3.3、来看看编译器对移动赋值的处理：

• 当我们不是用函数的返回值来构造一个对象，而是用一个之前已经定义出来的对象来接收函数的返回值，测试代码如下：

int main()
{
     
     
	cpp::string ret;
	ret = cpp::to_string(1234);
	return 0;
}

此时编译器会把左值str会被优化成右值（通过move把左值变为右值），再移动构造给一个临时对象，此临时对象再通过移动赋值传给之前已经定义出来的对象。

这里编译器并没有对这种情况进行优化，因为如果是用一个已经存在的对象接收，编译器就没办法优化了。cpp::to_string函数中会先用str生成构造生成一个临时对象，但是我们可以看到，编译器很聪明的在这里把str识别成了右值，调用了移动构造。然后在把这个临时对象做为cpp::to_string函数调用的返回值赋值给ret1，这里调用的移动赋值。

---

3.4.总结

1. 左值引用的深拷贝 – 拷贝构造 / 拷贝赋值
2. 右值引用的深拷贝 – 移动构造 / 移动赋值

C++11后STL中的容器都是增加了移动构造和移动赋值：

• https://cplusplus.com/reference/string/string/string/
• http://www.cplusplus.com/reference/vector/vector/vector/

---

4.右值引用引用左值

这部分内容我在一开始简要提了一下，下面来正式了解下move函数：

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

来看下move函数的定义：

template<class _Ty>
inline typename remove_reference<_Ty>::type&& move(_Ty&& _Arg) _NOEXCEPT
{
     
     
	// forward _Arg as movable
	return ((typename remove_reference<_Ty>::type&&)_Arg);
}

注意：

• move函数中_Arg参数的类型不是右值引用，而是万能引用。万能引用跟右值引用的形式一样，但是右值引用需要是确定的类型。
• 一个左值被move以后，它的资源可能就被转移给别人了，因此要慎用一个被move后的左值。

测试如下：

int main()
{
     
     
	cpp::string s1("hello world");
	// 这里s1是左值，调用的是拷贝构造
	cpp::string s2(s1);//string(const string& s) -- 深拷贝
	// 这里我们把s1 move处理以后, 会被当成右值，调用移动构造
	// 但是这里要注意，一般是不要这样用的，因为我们会发现s1的
	// 资源被转移给了s3，s1被置空了。
	cpp::string s3(std::move(s1));//string(string&& s) -- 移动构造
	return 0;
}

---

5.右值引用的其它场景

C++11后STL容器中的插入接口函数也增加了右值引用的版本：

注意：

• C++98的时候，push_back函数只有const左值引用版本，所以这就会导致无论是左值还是右值都会被传入这个左值引用版本的push_back，势必会引发后续的深拷贝而带来的开销过大等问题。
• C++11出来后，push_back函数增加了右值引用版本，如果传入push_back函数的是一个右值，那么在push_back函数构造节点时，这个右值就可以匹配到容器的移动构造函数进行资源的转移，这样就避免了深拷贝，提高了效率。

示例：

int main()
{
     
     
	list<cpp::string> lt;
	cpp::string s1("1111");
	// 这里调用的是拷贝构造
	lt.push_back(s1);//string(const string& s) -- 深拷贝
	// 下面调用都是移动构造
	lt.push_back("2222");//string(string&& s) -- 移动构造
	lt.push_back(std::move(s1));//string(string&& s) -- 移动构造
	return 0;
}

上述代码中的插入第一个元素s1就会匹配到push_back的左值引用版本，在push_back函数内部就会调用string的拷贝构造函数进行深拷贝，而后面插入的两个元素时由于传入的是右值，因此会匹配到push_back的右值引用版本，此时在push_back函数内部就会调用string的移动构造函数进行资源的转移。

---

三、完美转发

1.万能引用&&

&&应用在模板中时，不代表右值引用，而是万能引用，万能引用既能接收左值，也能接收右值。

template<typename T>
void PerfectForward(T&& t)//万能引用
{
     
     
	//……
}

1. 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
2. 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力.
3. 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值.

右值引用和万能引用的区别就是，右值引用需要是确定的类型，而万能引用是根据传入实参的类型进行推导，如果传入的实参是一个左值，那么这里的形参t就是左值引用，如果传入的实参是一个右值，那么这里的形参t就是右值引用。

示例：

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;
}

注意看上面的Fun函数我写了四个，分别是左值引用、const左值引用、右值引用、const右值引用。main函数中我把左值、右值、const左值、const右值均作为参数传入了函数模板PerfectForward里头，因为其参数类型是万能引用&&，所以既可以接收左值也可以接收右值，可是最终的测试结果令人惊奇：

• 实际调用PerfectForward函数时传入左值和右值均匹配到了左值引用版本的Fun函数，而调用PerfectForward函数时传入的const左值和const右值均匹配到了const左值引用版本的Fun函数。
• 造成此现象的根本原因在于右值被引用后会导致右值被存储到特定位置，这时这个右值可以被取到地址，并且可以被修改，所以在PerfectForward函数中调用Func函数时会将t识别成左值。

这就意味着，右值经过一次参数传递后其属性会退化成左值，如果想要在这个过程中保持右值的属性，就需要用到完美转发。

这也就是我们上文所提到的万能引用限制了接收的类型，在后续使用中均退化成了左值，但是我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用我们下面学习的完美转发。

---

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

我们想要在传参的过程中保留对象的原生类型属性，就需要用到forward函数：

template<typename T>
void PerfectForward(T&& t)
{
     
     
    	//完美转发
	Fun(std::forward<T>(t));
    	//std::forward<T>(t)在传参的过程中保持了t的原生类型属性。
}

测试结果如下：

完美转发后，左值、右值、左值引用、右值引用就可以被传入到理想状态下的函数接口了。

---

3.完美转发的使用场景

这里我们把先前模拟实现的list拖过来做测试案例，链接：list_realize/list.h · wei/cplusplus - 码云 - 开源中国 (gitee.com)

• 先前实现的list是没有对push_back函数和insert函数写一个右值引用版本的，所以这就会导致无论数据是左值还是右值都会传入左值引用的版本，势必在构建节点的时候引发深拷贝，测试代码如下：

int main()
{
     
     
	cpp::list<cpp::string> lt;
	cpp::string s1("string");//右值
	lt.push_back(s1);//左值
	lt.push_back("vector");//右值
	lt.push_back(std::move(s1));//右值
}

为了避免深拷贝带来的开销过大，我们对push_back和insert函数单独写一个右值引用的版本，同样也要对构造函数写一个右值引用的版本，因为创建节点需要用到节点类的构造函数：

namespace cpp
{
     
     
	template<class T>
	{
     
     
        //……
        //右值引用节点类构造函数
        list_node(T&& val)
            :_next(nullptr)
            , _prev(nullptr)
            , _data(val)
        {
     
     }
	};
	template<class T>
	class list
	{
     
     
		typedef List_node<T> node;
	public:
		//构造函数
		list()
		{
     
     
			_head = new node;
			_head->_next = _head;
			_head->_prev = _head;
		}
		//左值引用版本的push_back
		void push_back(const T& x)
		{
     
     
			insert(_head, x);
		}
		//右值引用版本的push_back
		void push_back(T&& x)
		{
     
     
			insert(_head, std::forward<T>(x)); //完美转发
		}
		//左值引用版本的insert
		void insert(node* pos, const T& x)
		{
     
     
			node* prev = pos->_prev;
			node* newnode = new node;
			newnode->_data = x;

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = pos;
			pos->_prev = newnode;
		}
		//右值引用版本的insert
		void insert(node* pos, T&& x)
		{
     
     
			node* prev = pos->_prev;
			node* newnode = new node;
			newnode->_data = std::forward<T>(x); //完美转发

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = pos;
			pos->_prev = newnode;
		}
	private:
		node* _head; //指向链表头结点的指针
	};
}

虽然这里实现了右值引用版本，但是实际的运行结果依然是深拷贝的，和没写之前的运行结果一模一样，原因如下：

• 根据先前的了解我们得知：&&应用在模板中时，不代表右值引用，而是万能引用，万能引用既能接收左值，也能接收右值。但是在后续的使用中，会把接收的类型全部退化成左值，既然退化成左值，那么自然会进入后续的深拷贝。

此情况就是典型的完美转发的使用场景，解决办法如下：

• 我们需要在传参的过程中保留对象的原生类型属性，就需要用到forward函数：

//右值引用节点类的构造函数
List_node(T&& val)
	:_next(nullptr)
	, _prev(nullptr)
	, _data(std::forward<T>(val))//完美转发
{
     
     }
//右值引用版本的push_back
void push_back(T&& xx)
{
     
     
	//完美转发
	insert(end(), std::forward<T>(xx));
}
//右值引用版本的insert
iterator insert(iterator pos, T&& xx)
{
     
     
	//完美转发
	node* newnode = new node(std::forward<T>(xx));
	//……
	return iterator(newnode);
}

修改好后再次运行，结果就是我们想要的啦：

---