C++11右值引用和移動(dòng)語(yǔ)義的實(shí)例解析

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

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

基本概念

左值 vs 右值

什么是左值？

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

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

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

什么是右值？

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

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

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

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

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

右值本質(zhì)就是一個(gè)臨時(shí)變量或常量值，比如代碼中的10就是常量值，表達(dá)式x+y和函數(shù)fmin的返回值就是臨時(shí)變量，這些都叫做右值。
這些臨時(shí)變量和常量值并沒有被實(shí)際存儲(chǔ)起來，這也就是為什么右值不能被取地址的原因，因?yàn)橹挥斜淮鎯?chǔ)起來后才有地址。
但需要注意的是，這里說函數(shù)的返回值是右值，指的是傳值返回的函數(shù)，因?yàn)閭髦捣祷氐暮瘮?shù)在返回對(duì)象時(shí)返回的是對(duì)象的拷貝，這個(gè)拷貝出來的對(duì)象就是一個(gè)臨時(shí)變量。

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

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

這里的[]運(yùn)算符重載函數(shù)返回的是一個(gè)字符的引用，因?yàn)樗枰С滞獠繉?duì)該位置的字符進(jìn)行修改，所以必須采用左值引用返回。之所以說這里返回的是一個(gè)左值，是因?yàn)檫@個(gè)返回的字符是被存儲(chǔ)起來了的，是存儲(chǔ)在string對(duì)象的_str對(duì)象當(dāng)中的，因此這個(gè)字符是可以被取到地址的。

左值引用 vs 右值引用

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

左值引用

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

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

	//以下幾個(gè)是對(duì)上面左值的左值引用
	int*& rp = p;
	int& rb = b;
	const int& rc = c;
	int& pvalue = *p;
	return 0;
}

右值引用

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

int main()
{
	double x = 1.1, y = 2.2;
	
	//以下幾個(gè)都是常見的右值
	10;
	x + y;
	fmin(x, y);

	//以下幾個(gè)都是對(duì)右值的右值引用
	int&& rr1 = 10;
	double&& rr2 = x + y;
	double rr3 = fmin(x, y);
	return 0;
}

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

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

	rr1 = 20;
	rr2 = 5.5; //報(bào)錯(cuò)
	return 0;
}

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

左值引用不能引用右值，因?yàn)檫@涉及權(quán)限放大的問題，右值是不能被修改的，而左值引用是可以修改。
但是const左值引用可以引用右值，因?yàn)閏onst左值引用能夠保證被引用的數(shù)據(jù)不會(huì)被修改。

因此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標(biāo)準(zhǔn)提供的一個(gè)函數(shù)，被move后的左值能夠賦值給右值引用。比如：

int main()
{
	int a = 10;

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

右值引用使用場(chǎng)景和意義

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

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

代碼如下：

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

			string tmp(s); //用s拷貝構(gòu)造出對(duì)象tmp
			swap(tmp); //交換這兩個(gè)對(duì)象
			return *this; //返回左值（支持連續(xù)賦值）
		}
		//析構(gòu)函數(shù)
		~string()
		{
			delete[] _str;  //釋放_(tái)str指向的空間
			_str = nullptr; //及時(shí)置空，防止非法訪問
			_size = 0;      //大小置0
			_capacity = 0;  //容量置0
		}
		//[]運(yùn)算符重載
		char& operator[](size_t i)
		{
			assert(i < _size); //檢測(cè)下標(biāo)的合法性
			return _str[i]; //返回對(duì)應(yīng)字符
		}
		//改變?nèi)萘?，大小不?
		void reserve(size_t n)
		{
			if (n > _capacity) //當(dāng)n大于對(duì)象當(dāng)前容量時(shí)才需執(zhí)行操作
			{
				char* tmp = new char[n + 1]; //多開一個(gè)空間用于存放'\0'
				strncpy(tmp, _str, _size + 1); //將對(duì)象原本的C字符串拷貝過來（包括'\0'）
				delete[] _str; //釋放對(duì)象原本的空間
				_str = tmp; //將新開辟的空間交給_str
				_capacity = n; //容量跟著改變
			}
		}
		//尾插字符
		void push_back(char ch)
		{
			if (_size == _capacity) //判斷是否需要增容
			{
				reserve(_capacity == 0 ? 4 : _capacity * 2); //將容量擴(kuò)大為原來的兩倍
			}
			_str[_size] = ch; //將字符尾插到字符串
			_str[_size + 1] = '\0'; //字符串后面放上'\0'
			_size++; //字符串的大小加一
		}
		//+=運(yùn)算符重載
		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;
	};
}

左值引用的使用場(chǎng)景

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

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

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

因?yàn)槲覀兡M實(shí)現(xiàn)是string類的拷貝構(gòu)造函數(shù)當(dāng)中打印了提示語(yǔ)句，因此運(yùn)行代碼后通過程序運(yùn)行結(jié)果就知道，值傳參時(shí)調(diào)用了string的拷貝構(gòu)造函數(shù)。

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

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

左值引用的短板

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

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

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

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

代碼如下：

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

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

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

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

右值引用和移動(dòng)語(yǔ)義

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

移動(dòng)構(gòu)造

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

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

代碼如下：

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

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

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

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

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

說明一下：

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

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

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

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

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

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

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

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

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

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

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

移動(dòng)賦值

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

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

代碼如下：

namespace cl
{
	class string
	{
	public:
		//移動(dòng)賦值
		string& operator=(string&& s)
		{
			cout << "string& operator=(string&& s) -- 移動(dòng)賦值" << endl;
			swap(s);
			return *this;
		}
	private:
		char* _str;
		size_t _size;
		size_t _capacity;
	};
}

移動(dòng)賦值和原有operator=函數(shù)的區(qū)別：

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

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

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

	return 0;
}

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

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

STL中的容器

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

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

這是string類增加的移動(dòng)賦值：

右值引用引用左值

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

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

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

右值引用的其他使用場(chǎng)景

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

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

以list容器的push_back接口為例：

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

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

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的移動(dòng)構(gòu)造
	lt.push_back(cl::string("3333")); //調(diào)用string的移動(dòng)構(gòu)造
	lt.push_back(std::move(s));       //調(diào)用string的移動(dòng)構(gòu)造
	return 0;
}

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

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

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

萬(wàn)能引用

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

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

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

下面重載了四個(gè)Func函數(shù)，這四個(gè)Func函數(shù)的參數(shù)類型分別是左值引用、const左值引用、右值引用和const右值引用。在主函數(shù)中調(diào)用PerfectForward函數(shù)時(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ù)類型是萬(wàn)能引用，因此既可以接收左值也可以接收右值，而我們?cè)赑erfectForward函數(shù)中調(diào)用Func函數(shù)，就是希望調(diào)用PerfectForward函數(shù)時(shí)傳入左值、右值、const左值、const右值，能夠匹配到對(duì)應(yīng)版本的Func函數(shù)。

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

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

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

要想在參數(shù)傳遞過程中保持其原有的屬性，需要在傳參時(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ù)時(shí)傳入的是右值就會(huì)匹配到右值引用版本的Func函數(shù)，傳入的是const右值就會(huì)匹配到const右值引用版本的Func函數(shù)，這就是完美轉(zhuǎn)發(fā)的價(jià)值。

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

下面模擬實(shí)現(xiàn)了一個(gè)簡(jiǎn)化版的list類，類當(dāng)中分別提供了左值引用版本和右值引用版本的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é)點(diǎn)的指針
	};
}

下面定義一個(gè)list對(duì)象，list容器中存儲(chǔ)的就是之前模擬實(shí)現(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ù)插入元素時(shí)，會(huì)調(diào)用string原有的operator=函數(shù)進(jìn)行深拷貝，而調(diào)用右值引用版本的push_back函數(shù)插入元素時(shí)，只會(huì)調(diào)用string的移動(dòng)賦值進(jìn)行資源的移動(dòng)。

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

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

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

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

如果將剛才測(cè)試代碼中的list換成STL當(dāng)中的list。

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

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

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

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

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