基本概念

左值 vs 右值

什么是左值？

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

• 左值可以被取地址，也可以被修改（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;
}

什么是右值？

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

• 右值不能被取地址，也不能被修改。
• 右值可以出現(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;
}

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

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

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

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

左值引用 vs 右值引用

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

左值引用

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

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

需要注意的是，右值是不能取地址的，但是給右值取別名后，會導致右值被存儲到特定位置，這時這個右值可以被取到地址，并且可以被修改，如果不想讓被引用的右值被修改，可以用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;
}

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

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

因此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函數是C++11標準提供的一個函數，被move后的左值能夠賦值給右值引用。比如：

int main()
{
	int a = 10;

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

右值引用使用場景和意義

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

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

代碼如下：

namespace cl
{
	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); //交換兩個對象的容量
		}
		//拷貝構造函數（現(xiàn)代寫法）
		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); //交換這兩個對象
		}
		//賦值運算符重載（現(xiàn)代寫法）
		string& operator=(const string& s)
		{
			cout << "string& operator=(const string& s) -- 深拷貝" << endl;

			string tmp(s); //用s拷貝構造出對象tmp
			swap(tmp); //交換這兩個對象
			return *this; //返回左值（支持連續(xù)賦值）
		}
		//析構函數
		~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大于對象當前容量時才需執(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;
	};
}

左值引用的使用場景

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

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

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類的拷貝構造函數當中打印了提示語句，因此運行代碼后通過程序運行結果就知道，值傳參時調用了string的拷貝構造函數。

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

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

左值引用的短板

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

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

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

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

代碼如下：

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

此時調用to_string函數返回時，就一定會調用string的拷貝構造函數。比如：

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

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

右值引用和移動語義

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

移動構造

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

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

代碼如下：

namespace cl
{
	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;
	};
}

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

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

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

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

說明一下：

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

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

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

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

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

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

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

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

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

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

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

移動賦值

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

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

代碼如下：

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=函數的區(qū)別：

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

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

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

	return 0;
}

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

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

STL中的容器

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

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

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

右值引用引用左值

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

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

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后的左值。

右值引用的其他使用場景

右值引用版本的插入函數

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

以list容器的push_back接口為例：

右值引用版本插入函數的意義

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

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

	lt.push_back(s); //調用string的拷貝構造

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

list容器的push_back函數需要先構造一個結點，然后將該結點插入到底層的雙鏈表當中。

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

完美轉發(fā)

萬能引用

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

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

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

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

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函數的參數類型是萬能引用，因此既可以接收左值也可以接收右值，而我們在PerfectForward函數中調用Func函數，就是希望調用PerfectForward函數時傳入左值、右值、const左值、const右值，能夠匹配到對應版本的Func函數。

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

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

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

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

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

經過完美轉發(fā)后，調用PerfectForward函數時傳入的是右值就會匹配到右值引用版本的Func函數，傳入的是const右值就會匹配到const右值引用版本的Func函數，這就是完美轉發(fā)的價值。

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

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

代碼如下：

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:
		//構造函數
		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)); //完美轉發(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); //完美轉發(fā)

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

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

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

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

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

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

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

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

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

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

• 調用左值引用版本的push_back插入結點，在構造結點時會調用string的拷貝構造函數。
• 調用右值引用版本的push_back插入結點，在構造結點時會調用string的移動構造函數。

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

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

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

如果想要得到與STL相同的實驗結果，可以使用malloc函數申請內存，這時就不會自動調用構造函數進行初始化，然后在用定位new的方式用左值或右值對申請到的內存空間進行構造，這時調用的對應就是拷貝構造或移動構造。

總結 

到此這篇關于C++11右值引用和移動語義的文章就介紹到這了,更多相關C++11右值引用和移動語義內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！