C++11右值引用和移動語義的實例解析

更新時間：2022年09月08日 13:14:00 作者：2021dragon

左值和右值都是針對表達式,左值是指表達式結(jié)束后依然存在的持久對象,右值是指表達式結(jié)束時就不再存在的臨時對象,下面這篇文章主要給大家介紹了關(guān)于C++11右值引用和移動語義的相關(guān)資料,需要的朋友可以參考下

基本概念

左值 vs 右值

什么是左值？

左值是一個表示數(shù)據(jù)的表達式，如變量名或解引用的指針。

左值可以被取地址，也可以被修改（const修飾的左值除外）。
左值可以出現(xiàn)在賦值符號的左邊，也可以出現(xiàn)在賦值符號的右邊。

int main()
{
	//以下的p、b、c、*p都是左值
	int* p = new int(0);
	int b = 1;
	const int c = 2;
	return 0;
}

什么是右值？

右值也是一個表示數(shù)據(jù)的表達式，如字母常量、表達式的返回值、函數(shù)的返回值（不能是左值引用返回）等等。

右值不能被取地址，也不能被修改。
右值可以出現(xiàn)在賦值符號的右邊，但是不能出現(xiàn)在賦值符號的左邊。

int main()
{
	double x = 1.1, y = 2.2;

	//以下幾個都是常見的右值
	10;
	x + y;
	fmin(x, y);

	//錯誤示例（右值不能出現(xiàn)在賦值符號的左邊）
	//10 = 1;
	//x + y = 1;
	//fmin(x, y) = 1;
	return 0;
}

右值本質(zhì)就是一個臨時變量或常量值，比如代碼中的10就是常量值，表達式x+y和函數(shù)fmin的返回值就是臨時變量，這些都叫做右值。
這些臨時變量和常量值并沒有被實際存儲起來，這也就是為什么右值不能被取地址的原因，因為只有被存儲起來后才有地址。
但需要注意的是，這里說函數(shù)的返回值是右值，指的是傳值返回的函數(shù)，因為傳值返回的函數(shù)在返回對象時返回的是對象的拷貝，這個拷貝出來的對象就是一個臨時變量。

而對于左值引用返回的函數(shù)來說，這些函數(shù)返回的是左值。比如string類實現(xiàn)的[]運算符重載函數(shù)：

namespace cl
{
	//模擬實現(xiàn)string類
	class string
	{
	public:
		//[]運算符重載（可讀可寫）
		char& operator[](size_t i)
		{
			assert(i < _size); //檢測下標的合法性
			return _str[i]; //返回對應(yīng)字符
		}
		//...
	private:
		char* _str;       //存儲字符串
		size_t _size;     //記錄字符串當前的有效長度
		//...
	};
}
int main()
{
	cl::string s("hello");
	s[3] = 'x';    //引用返回，支持外部修改
	return 0;
}

這里的[]運算符重載函數(shù)返回的是一個字符的引用，因為它需要支持外部對該位置的字符進行修改，所以必須采用左值引用返回。之所以說這里返回的是一個左值，是因為這個返回的字符是被存儲起來了的，是存儲在string對象的_str對象當中的，因此這個字符是可以被取到地址的。

左值引用 vs 右值引用

傳統(tǒng)的C++語法中就有引用的語法，而C++11中新增了右值引用的語法特性，為了進行區(qū)分，于是將C++11之前的引用就叫做左值引用。但是無論左值引用還是右值引用，本質(zhì)都是給對象取別名。

左值引用

左值引用就是對左值的引用，給左值取別名，通過“&”來聲明。比如：

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

右值引用

右值引用就是對右值的引用，給右值取別名，通過“&&”來聲明。比如：

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);
	return 0;
}

需要注意的是，右值是不能取地址的，但是給右值取別名后，會導(dǎo)致右值被存儲到特定位置，這時這個右值可以被取到地址，并且可以被修改，如果不想讓被引用的右值被修改，可以用const修飾右值引用。比如：

int main()
{
	double x = 1.1, y = 2.2;
	int&& rr1 = 10;
	const double&& rr2 = x + y;

	rr1 = 20;
	rr2 = 5.5; //報錯
	return 0;
}

左值引用可以引用右值嗎？

左值引用不能引用右值，因為這涉及權(quán)限放大的問題，右值是不能被修改的，而左值引用是可以修改。
但是const左值引用可以引用右值，因為const左值引用能夠保證被引用的數(shù)據(jù)不會被修改。

因此const左值引用既可以引用左值，也可以引用右值。比如：

template<class T>
void func(const T& val)
{
	cout << val << endl;
}
int main()
{
	string s("hello");
	func(s);       //s為左值

	func("world"); //"world"為右值
	return 0;
}

右值引用可以引用左值嗎？

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

move函數(shù)是C++11標準提供的一個函數(shù)，被move后的左值能夠賦值給右值引用。比如：

int main()
{
	int a = 10;

	//int&& r1 = a;     //右值引用不能引用左值
	int&& r2 = move(a); //右值引用可以引用move以后的左值
	return 0;
}

右值引用使用場景和意義

雖然const左值引用既能接收左值，又能接收右值，但左值引用終究存在短板，而C++11提出的右值引用就是用來解決左值引用的短板的。

為了更好的說明問題，這里需要借助一個深拷貝的類，下面模擬實現(xiàn)了一個簡化版的string類。類當中實現(xiàn)了一些基本的成員函數(shù)，并在string的拷貝構(gòu)造函數(shù)和賦值運算符重載函數(shù)當中打印了一條提示語句，這樣當調(diào)用這兩個函數(shù)時我們就能夠知道。

代碼如下：

namespace cl
{
	class string
	{
	public:
		typedef char* iterator;
		iterator begin()
		{
			return _str; //返回字符串中第一個字符的地址
		}
		iterator end()
		{
			return _str + _size; //返回字符串中最后一個字符的后一個字符的地址
		}
		//構(gòu)造函數(shù)
		string(const char* str = "")
		{
			_size = strlen(str); //初始時，字符串大小設(shè)置為字符串長度
			_capacity = _size; //初始時，字符串容量設(shè)置為字符串長度
			_str = new char[_capacity + 1]; //為存儲字符串開辟空間（多開一個用于存放'\0'）
			strcpy(_str, str); //將C字符串拷貝到已開好的空間
		}
		//交換兩個對象的數(shù)據(jù)
		void swap(string& s)
		{
			//調(diào)用庫里的swap
			::swap(_str, s._str); //交換兩個對象的C字符串
			::swap(_size, s._size); //交換兩個對象的大小
			::swap(_capacity, s._capacity); //交換兩個對象的容量
		}
		//拷貝構(gòu)造函數(shù)（現(xiàn)代寫法）
		string(const string& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(const string& s) -- 深拷貝" << endl;

			string tmp(s._str); //調(diào)用構(gòu)造函數(shù)，構(gòu)造出一個C字符串為s._str的對象
			swap(tmp); //交換這兩個對象
		}
		//賦值運算符重載（現(xiàn)代寫法）
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 深拷貝" << endl;

			string tmp(s); //用s拷貝構(gòu)造出對象tmp
			swap(tmp); //交換這兩個對象
			return *this; //返回左值（支持連續(xù)賦值）
		}
		//析構(gòu)函數(shù)
		~string()
		{
			delete[] _str;  //釋放_str指向的空間
			_str = nullptr; //及時置空，防止非法訪問
			_size = 0;      //大小置0
			_capacity = 0;  //容量置0
		}
		//[]運算符重載
		char& operator[](size_t i)
		{
			assert(i < _size); //檢測下標的合法性
			return _str[i]; //返回對應(yīng)字符
		}
		//改變?nèi)萘?，大小不?
		void reserve(size_t n)
		{
			if (n > _capacity) //當n大于對象當前容量時才需執(zhí)行操作
			{
				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; //返回左值（支持連續(xù)+=）
		}
		//返回C類型的字符串
		const char* c_str()const
		{
			return _str;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

左值引用的使用場景

在說明左值引用的短板之前，我們先來看看左值引用的使用場景：

左值引用做參數(shù)，防止傳參時進行拷貝操作。
左值引用做返回值，防止返回時對返回對象進行拷貝操作。

void func1(cl::string s)
{}
void func2(const cl::string& s)
{}
int main()
{
	cl::string s("hello world");
	func1(s);  //值傳參
	func2(s);  //左值引用傳參

	s += 'X';  //左值引用返回
	return 0;
}

因為我們模擬實現(xiàn)是string類的拷貝構(gòu)造函數(shù)當中打印了提示語句，因此運行代碼后通過程序運行結(jié)果就知道，值傳參時調(diào)用了string的拷貝構(gòu)造函數(shù)。

此外，因為string的+=運算符重載函數(shù)是左值引用返回的，因此在返回+=后的對象時不會調(diào)用拷貝構(gòu)造函數(shù)，但如果將+=運算符重載函數(shù)改為傳值返回，那么重新運行代碼后你就會發(fā)現(xiàn)多了一次拷貝構(gòu)造函數(shù)的調(diào)用。

我們都知道string的拷貝是深拷貝，深拷貝的代價是比較高的，我們應(yīng)該盡量避免不必要的深拷貝操作，因此這里左值引用起到的作用還是很明顯的。

左值引用的短板

左值引用雖然能避免不必要的拷貝操作，但左值引用并不能完全避免。

左值引用做參數(shù)，能夠完全避免傳參時不必要的拷貝操作。
左值引用做返回值，并不能完全避免函數(shù)返回對象時不必要的拷貝操作。

如果函數(shù)返回的對象是一個局部變量，該變量出了函數(shù)作用域就被銷毀了，這種情況下不能用左值引用作為返回值，只能以傳值的方式返回，這就是左值引用的短板。

比如下面我們模擬實現(xiàn)一個int版本的to_string函數(shù)，這個to_string函數(shù)就不能使用左值引用返回，因為to_string函數(shù)返回的是一個局部變量。

代碼如下：

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

此時調(diào)用to_string函數(shù)返回時，就一定會調(diào)用string的拷貝構(gòu)造函數(shù)。比如：

int main()
{
	cl::string s = cl::to_string(1234);
	return 0;
}

C++11提出右值引用就是為了解決左值引用的這個短板的，但解決方式并不是簡單的將右值引用作為函數(shù)的返回值。

右值引用和移動語義

右值引用和移動語句解決上述問題的方式就是，給當前模擬實現(xiàn)的string類增加移動構(gòu)造和移動賦值方法。

移動構(gòu)造

移動構(gòu)造是一個構(gòu)造函數(shù)，該構(gòu)造函數(shù)的參數(shù)是右值引用類型的，移動構(gòu)造本質(zhì)就是將傳入右值的資源竊取過來，占為己有，這樣就避免了進行深拷貝，所以它叫做移動構(gòu)造，就是竊取別人的資源來構(gòu)造自己的意思。

在當前的string類中增加一個移動構(gòu)造函數(shù)，該函數(shù)要做的就是調(diào)用swap函數(shù)將傳入右值的資源竊取過來，為了能夠更好的得知移動構(gòu)造函數(shù)是否被調(diào)用，可以在該函數(shù)當中打印一條提示語句。

代碼如下：

namespace cl
{
	class string
	{
	public:
		//移動構(gòu)造
		string(string&& s)
			:_str(nullptr)
			, _size(0)
			, _capacity(0)
		{
			cout << "string(string&& s) -- 移動構(gòu)造" << endl;
			swap(s);
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

移動構(gòu)造和拷貝構(gòu)造的區(qū)別：

在沒有增加移動構(gòu)造之前，由于拷貝構(gòu)造采用的是const左值引用接收參數(shù)，因此無論拷貝構(gòu)造對象時傳入的是左值還是右值，都會調(diào)用拷貝構(gòu)造函數(shù)。
增加移動構(gòu)造之后，由于移動構(gòu)造采用的是右值引用接收參數(shù)，因此如果拷貝構(gòu)造對象時傳入的是右值，那么就會調(diào)用移動構(gòu)造函數(shù)（最匹配原則）。
string的拷貝構(gòu)造函數(shù)做的是深拷貝，而移動構(gòu)造函數(shù)中只需要調(diào)用swap函數(shù)進行資源的轉(zhuǎn)移，因此調(diào)用移動構(gòu)造的代價比調(diào)用拷貝構(gòu)造的代價小。

給string類增加移動構(gòu)造后，對于返回局部string對象的這類函數(shù)，在返回string對象時就會調(diào)用移動構(gòu)造進行資源的移動，而不會再調(diào)用拷貝構(gòu)造函數(shù)進行深拷貝了。比如：

int main()
{
	cl::string s = cl::to_string(1234);
	return 0;
}

說明一下：

雖然to_string當中返回的局部string對象是一個左值，但由于該string對象在當前函數(shù)調(diào)用結(jié)束后就會立即被銷毀，我可以把這種即將被消耗的值叫做“將亡值”，比如匿名對象也可以叫做“將亡值”。
既然“將亡值”馬上就要被銷毀了，那還不如把它的資源轉(zhuǎn)移給別人用，因此編譯器在識別這種“將亡值”時會將其識別為右值，這樣就可以匹配到參數(shù)類型為右值引用的移動構(gòu)造函數(shù)。

編譯器做的優(yōu)化

實際當一個函數(shù)在返回局部對象時，會先用這個局部對象拷貝構(gòu)造出一個臨時對象，然后再用這個臨時對象來拷貝構(gòu)造我們接收返回值的對象。如下：

因此在C++11標準出來之前，對于深拷貝的類來說這里就會進行兩次深拷貝，所以大部分編譯器為了提高效率都對這種情況進行了優(yōu)化，這種連續(xù)調(diào)用構(gòu)造函數(shù)的場景通常會被優(yōu)化成一次。比如：

因此按道理來說，在C++11標準出來之前這里應(yīng)該調(diào)用兩次string的拷貝構(gòu)造函數(shù)，但最終被編譯器優(yōu)化成了一次，減少了一次無意義的深拷貝。（并不是所有的編譯器都做了這個優(yōu)化）

在C++11出來之后，編譯器的這個優(yōu)化仍然起到了作用。

如果編譯器不優(yōu)化這里應(yīng)該調(diào)用兩次移動構(gòu)造，第一次調(diào)用移動構(gòu)造用返回的局部string對象構(gòu)造出一個臨時對象，第二次調(diào)用移動構(gòu)造用這個臨時對象構(gòu)造接收返回值的對象。
而經(jīng)過編譯器優(yōu)化后，最終這兩次移動構(gòu)造就被優(yōu)化成了一次，也就是直接將返回的局部string對象的資源移動給了接收返回值的對象。
此外，C++11之后就算編譯器沒有進行這個優(yōu)化問題也不大，因為不優(yōu)化也就是調(diào)用兩次移動構(gòu)造進行兩次資源的轉(zhuǎn)移而已。

但如果我們不是用函數(shù)的返回值來構(gòu)造一個對象，而是用一個之前已經(jīng)定義出來的對象來接收函數(shù)的返回值，這時編譯器就無法進行優(yōu)化了。比如：

這時當函數(shù)返回局部對象時，會先用這個局部對象拷貝構(gòu)造出一個臨時對象，然后再調(diào)用賦值運算符重載函數(shù)將這個臨時對象賦值給接收函數(shù)返回值的對象。

編譯器并沒有對這種情況進行優(yōu)化，因此在C++11標準出來之前，對于深拷貝的類來說這里就會存在兩次深拷貝，因為深拷貝的類的賦值運算符重載函數(shù)也需要以深拷貝的方式實現(xiàn)。
但在深拷貝的類中引入C++11的移動構(gòu)造后，這里仍然需要再調(diào)用一次賦值運算符重載函數(shù)進行深拷貝，因此深拷貝的類不僅需要實現(xiàn)移動構(gòu)造，還需要實現(xiàn)移動賦值。

這里需要說明的是，對于返回局部對象的函數(shù)，就算只是調(diào)用函數(shù)而不接收該函數(shù)的返回值，也會存在一次拷貝構(gòu)造或移動構(gòu)造，因為函數(shù)的返回值不管你接不接收都必須要有，而當函數(shù)結(jié)束后該函數(shù)內(nèi)的局部對象都會被銷毀，所以就算不接收函數(shù)的返回值也會調(diào)用一次拷貝構(gòu)造或移動構(gòu)造生成臨時對象。

移動賦值

移動賦值是一個賦值運算符重載函數(shù)，該函數(shù)的參數(shù)是右值引用類型的，移動賦值也是將傳入右值的資源竊取過來，占為己有，這樣就避免了深拷貝，所以它叫移動賦值，就是竊取別人的資源來賦值給自己的意思。

在當前的string類中增加一個移動賦值函數(shù)，該函數(shù)要做的就是調(diào)用swap函數(shù)將傳入右值的資源竊取過來，為了能夠更好的得知移動賦值函數(shù)是否被調(diào)用，可以在該函數(shù)中打印一條提示語句。

代碼如下：

namespace cl
{
	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=函數(shù)的區(qū)別：

在沒有增加移動賦值之前，由于原有operator=函數(shù)采用的是const左值引用接收參數(shù)，因此無論賦值時傳入的是左值還是右值，都會調(diào)用原有的operator=函數(shù)。
增加移動賦值之后，由于移動賦值采用的是右值引用接收參數(shù)，因此如果賦值時傳入的是右值，那么就會調(diào)用移動賦值函數(shù)（最匹配原則）。
string原有的operator=函數(shù)做的是深拷貝，而移動賦值函數(shù)中只需要調(diào)用swap函數(shù)進行資源的轉(zhuǎn)移，因此調(diào)用移動賦值的代價比調(diào)用原有operator=的代價小。

現(xiàn)在給string增加移動構(gòu)造和移動賦值以后，就算是用一個已經(jīng)定義過的string對象去接收to_string函數(shù)的返回值，此時也不會存在深拷貝。比如：

int main()
{
	cl::string s;
	//...
	s = cl::to_string(1234);

	return 0;
}

此時當to_string函數(shù)返回局部的string對象時，會先調(diào)用移動構(gòu)造生成一個臨時對象，然后再調(diào)用移動賦值將臨時對象的資源轉(zhuǎn)移給我們接收返回值的對象，這個過程雖然調(diào)用了兩個函數(shù)，但這兩個函數(shù)要做的只是資源的移動，而不需要進行深拷貝，大大提高了效率。

說明一下： 在實現(xiàn)移動賦值函數(shù)之前，該代碼的運行結(jié)果理論上應(yīng)該是調(diào)用一次拷貝構(gòu)造，再調(diào)用一次原有的operator=函數(shù)，但由于原有operator=函數(shù)實現(xiàn)時復(fù)用了拷貝構(gòu)造函數(shù)，因此代碼運行后的輸出結(jié)果會多打印一次拷貝構(gòu)造函數(shù)的調(diào)用，這是原有operator=函數(shù)內(nèi)部調(diào)用的。

STL中的容器

C++11標準出來之后，STL中的容器都增加了移動構(gòu)造和移動賦值。

以我們剛剛說的string類為例，這是string類增加的移動構(gòu)造：

這是string類增加的移動賦值：

右值引用引用左值

右值引用雖然不能引用左值，但也不是完全不可以，當需要用右值引用引用一個左值時，可以通過move函數(shù)將左值轉(zhuǎn)化為右值。

move函數(shù)的名字具有迷惑性，move函數(shù)實際并不能搬移任何東西，該函數(shù)唯一的功能就是將一個左值強制轉(zhuǎn)化為右值引用，然后實現(xiàn)移動語義。

move函數(shù)的定義如下：

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函數(shù)中_Arg參數(shù)的類型不是右值引用，而是萬能引用。萬能引用跟右值引用的形式一樣，但是右值引用需要是確定的類型。
一個左值被move以后，它的資源可能就被轉(zhuǎn)移給別人了，因此要慎用一個被move后的左值。

右值引用的其他使用場景

右值引用版本的插入函數(shù)

C++11標準出來之后，STL中的容器除了增加移動構(gòu)造和移動賦值之外，STL容器插入接口函數(shù)也增加了右值引用版本。

以list容器的push_back接口為例：

右值引用版本插入函數(shù)的意義

如果list容器當中存儲的是string對象，那么在調(diào)用push_back向list容器中插入元素時，可能會有如下幾種插入方式：

int main()
{
	list<cl::string> lt;
	cl::string s("1111");

	lt.push_back(s); //調(diào)用string的拷貝構(gòu)造

	lt.push_back("2222");             //調(diào)用string的移動構(gòu)造
	lt.push_back(cl::string("3333")); //調(diào)用string的移動構(gòu)造
	lt.push_back(std::move(s));       //調(diào)用string的移動構(gòu)造
	return 0;
}

list容器的push_back函數(shù)需要先構(gòu)造一個結(jié)點，然后將該結(jié)點插入到底層的雙鏈表當中。

在C++11之前l(fā)ist容器的push_back接口只有一個左值引用版本，因此在push_back函數(shù)中構(gòu)造結(jié)點時，這個左值只能匹配到string的拷貝構(gòu)造函數(shù)進行深拷貝。
而在C++11出來之后，string類提供了移動構(gòu)造函數(shù)，并且list容器的push_back接口提供了右值引用版本，此時如果傳入push_back函數(shù)的string對象是一個右值，那么在push_back函數(shù)中構(gòu)造結(jié)點時，這個右值就可以匹配到string的移動構(gòu)造函數(shù)進行資源的轉(zhuǎn)移，這樣就避免了深拷貝，提高了效率。
上述代碼中的插入第一個元素時就會匹配到push_back的左值引用版本，在push_back函數(shù)內(nèi)部就會調(diào)用string的拷貝構(gòu)造函數(shù)進行深拷貝，而插入后面三個元素時由于傳入的是右值，因此會匹配到push_back的右值引用版本，此時在push_back函數(shù)內(nèi)部就會調(diào)用string的移動構(gòu)造函數(shù)進行資源的轉(zhuǎn)移。

完美轉(zhuǎn)發(fā)

萬能引用

模板中的&&不代表右值引用，而是萬能引用，其既能接收左值又能接收右值。比如：

template<class T>
void PerfectForward(T&& t)
{
	//...
}

右值引用和萬能引用的區(qū)別就是，右值引用需要是確定的類型，而萬能引用是根據(jù)傳入實參的類型進行推導(dǎo)，如果傳入的實參是一個左值，那么這里的形參t就是左值引用，如果傳入的實參是一個右值，那么這里的形參t就是右值引用。

下面重載了四個Func函數(shù)，這四個Func函數(shù)的參數(shù)類型分別是左值引用、const左值引用、右值引用和const右值引用。在主函數(shù)中調(diào)用PerfectForward函數(shù)時分別傳入左值、右值、const左值和const右值，在PerfectForward函數(shù)中再調(diào)用Func函數(shù)。如下：

void Func(int& x)
{
	cout << "左值引用" << endl;
}
void Func(const int& x)
{
	cout << "const 左值引用" << endl;
}
void Func(int&& x)
{
	cout << "右值引用" << endl;
}
void Func(const int&& x)
{
	cout << "const 右值引用" << endl;
}
template<class T>
void PerfectForward(T&& t)
{
	Func(t);
}
int main()
{
	int a = 10;
	PerfectForward(a);       //左值
	PerfectForward(move(a)); //右值

	const int b = 20;
	PerfectForward(b);       //const 左值
	PerfectForward(move(b)); //const 右值

	return 0;
}

由于PerfectForward函數(shù)的參數(shù)類型是萬能引用，因此既可以接收左值也可以接收右值，而我們在PerfectForward函數(shù)中調(diào)用Func函數(shù)，就是希望調(diào)用PerfectForward函數(shù)時傳入左值、右值、const左值、const右值，能夠匹配到對應(yīng)版本的Func函數(shù)。

但實際調(diào)用PerfectForward函數(shù)時傳入左值和右值，最終都匹配到了左值引用版本的Func函數(shù)，調(diào)用PerfectForward函數(shù)時傳入const左值和const右值，最終都匹配到了const左值引用版本的Func函數(shù)。
根本原因就是，右值被引用后會導(dǎo)致右值被存儲到特定位置，這時這個右值可以被取到地址，并且可以被修改，所以在PerfectForward函數(shù)中調(diào)用Func函數(shù)時會將t識別成左值。

也就是說，右值經(jīng)過一次參數(shù)傳遞后其屬性會退化成左值，如果想要在這個過程中保持右值的屬性，就需要用到完美轉(zhuǎn)發(fā)。

完美轉(zhuǎn)發(fā)保持值的屬性

要想在參數(shù)傳遞過程中保持其原有的屬性，需要在傳參時調(diào)用forward函數(shù)。比如：

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

經(jīng)過完美轉(zhuǎn)發(fā)后，調(diào)用PerfectForward函數(shù)時傳入的是右值就會匹配到右值引用版本的Func函數(shù)，傳入的是const右值就會匹配到const右值引用版本的Func函數(shù)，這就是完美轉(zhuǎn)發(fā)的價值。

完美轉(zhuǎn)發(fā)的使用場景

下面模擬實現(xiàn)了一個簡化版的list類，類當中分別提供了左值引用版本和右值引用版本的push_back和insert函數(shù)。

代碼如下：

namespace cl
{
	template<class T>
	struct ListNode
	{
		T _data;
		ListNode* _next = nullptr;
		ListNode* _prev = nullptr;
	};
	template<class T>
	class list
	{
		typedef ListNode<T> node;
	public:
		//構(gòu)造函數(shù)
		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)); //完美轉(zhuǎn)發(fā)
		}
		//左值引用版本的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); //完美轉(zhuǎn)發(fā)

			prev->_next = newnode;
			newnode->_prev = prev;
			newnode->_next = pos;
			pos->_prev = newnode;
		}
	private:
		node* _head; //指向鏈表頭結(jié)點的指針
	};
}

下面定義一個list對象，list容器中存儲的就是之前模擬實現(xiàn)的string類，這里分別傳入左值和右值調(diào)用不同版本的push_back。比如：

int main()
{
	cl::list<cl::string> lt;
	cl::string s("1111"); 
	lt.push_back(s);      //調(diào)用左值引用版本的push_back

	lt.push_back("2222"); //調(diào)用右值引用版本的push_back
	return 0;
}

調(diào)用左值引用版本的push_back函數(shù)插入元素時，會調(diào)用string原有的operator=函數(shù)進行深拷貝，而調(diào)用右值引用版本的push_back函數(shù)插入元素時，只會調(diào)用string的移動賦值進行資源的移動。

因為實現(xiàn)push_back函數(shù)時復(fù)用了insert函數(shù)的代碼，對于左值引用版本的push_back函數(shù)，在調(diào)用insert函數(shù)時只能調(diào)用左值引用版本的insert函數(shù)，而在insert函數(shù)中插入元素時會先new一個結(jié)點，然后將對應(yīng)的左值賦值給該結(jié)點，因此會調(diào)用string原有的operator=函數(shù)進行深拷貝。
而對于右值引用版本的push_back函數(shù)，在調(diào)用insert函數(shù)時就可以調(diào)用右值引用版本的insert函數(shù)，在右值引用版本的insert函數(shù)中也會先new一個結(jié)點，然后將對應(yīng)的右值賦值給該結(jié)點，因此這里就和調(diào)用string的移動賦值函數(shù)進行資源的移動。
這個場景中就需要用到完美轉(zhuǎn)發(fā)，否則右值引用版本的push_back接收到右值后，該右值的右值屬性就退化了，此時在右值引用版本的push_back函數(shù)中調(diào)用insert函數(shù)，也會匹配到左值引用版本的insert函數(shù)，最終調(diào)用的還是原有的operator=函數(shù)進行深拷貝。
此外，除了在右值引用版本的push_back函數(shù)中調(diào)用insert函數(shù)時，需要用完美轉(zhuǎn)發(fā)保持右值原有的屬性之外，在右值引用版本的insert函數(shù)中用右值給新結(jié)點賦值時也需要用到完美轉(zhuǎn)發(fā)，否則在賦值時也會將其識別為左值，導(dǎo)致最終調(diào)用的還是原有的operator=函數(shù)。

也就是說，只要想保持右值的屬性，在每次右值傳參時都需要進行完美轉(zhuǎn)發(fā)，實際STL庫中也是通過完美轉(zhuǎn)發(fā)來保持右值屬性的。

注意： 代碼中push_back和insert函數(shù)的參數(shù)T&&是右值引用，而不是萬能引用，因為在list對象創(chuàng)建時這個類就被實例化了，后續(xù)調(diào)用push_back和insert函數(shù)時，參數(shù)T&&中的T已經(jīng)是一個確定的類型了，而不是在調(diào)用push_back和insert函數(shù)時才進行類型推導(dǎo)的。

與STL中的list的區(qū)別

如果將剛才測試代碼中的list換成STL當中的list。

調(diào)用左值引用版本的push_back插入結(jié)點，在構(gòu)造結(jié)點時會調(diào)用string的拷貝構(gòu)造函數(shù)。
調(diào)用右值引用版本的push_back插入結(jié)點，在構(gòu)造結(jié)點時會調(diào)用string的移動構(gòu)造函數(shù)。

而用我們模擬實現(xiàn)的list時，調(diào)用的卻不是string的拷貝構(gòu)造和移動構(gòu)造，而對應(yīng)是string原有的operator=和移動賦值。

原因是因為我們模擬實現(xiàn)的list容器，是通過new操作符為新結(jié)點申請內(nèi)存空間的，在申請內(nèi)存后會自動調(diào)用構(gòu)造函數(shù)對進行其進行初始化，因此在后續(xù)用左值或右值對其進行賦值時，就會調(diào)用對應(yīng)的operator=或移動賦值進行深拷貝或資源的轉(zhuǎn)移。

而STL庫中的容器都是通過空間配置器獲取內(nèi)存的，因此在申請到內(nèi)存后不會調(diào)用構(gòu)造函數(shù)對其進行初始化，而是后續(xù)用左值或右值對其進行拷貝構(gòu)造，因此最終調(diào)用的就是拷貝構(gòu)造或移動構(gòu)造。

如果想要得到與STL相同的實驗結(jié)果，可以使用malloc函數(shù)申請內(nèi)存，這時就不會自動調(diào)用構(gòu)造函數(shù)進行初始化，然后在用定位new的方式用左值或右值對申請到的內(nèi)存空間進行構(gòu)造，這時調(diào)用的對應(yīng)就是拷貝構(gòu)造或移動構(gòu)造。