一篇文章弄懂C++左值引用和右值引用

const int MAX_LEN = 10; // MAX_LEN是左值
MAX_LEN = 5;            // 錯誤：試圖向const對象賦值。 左值不能位於賦值語句的左側。

int a = 1;    // a是左值（在內存中的位置）， 1是右值（內容），不能給1賦值
int y = a;    // 用左值代替右值，把內容賦值給y。a依然是左值，可以取地址。但是在該表達式中，左值代替右值使用，所以賦值語句右邊也可以說是右值，隻不過是a的內容。

int a = 1;    
int &b = a;			// 正確
int &c = 10;		// 錯誤：10是右值。
const int &d = 10;  // 正確 

int a = 1;
int &b = a;   			// 正確：左值引用，a是左值
int &&c = a;  			// 錯誤：右值引用，不能綁定到一個左值上
int &d = a*3; 			// 錯誤：左值引用，a*3是右值
const int &e = a*3; 	// 正確：左值引用，const引用可以綁定到一個右值上
int &&f = a*3;     		// 正確：右值引用，a*3是右值
int &&g = 10;			// 正確：右值引用，10是右值

int &&a = 10;   // 正確：10是右值
int &&b = a; 	// 錯誤：即使a是右值引用，但a依然是左值，a不是臨時對象

#include <utility>
int a = 1;
int &&c = a;  			// 錯誤：右值引用，不能綁定到一個左值上
int &&h = std::move(a); // 正確：使用std::move()把a當成右值處理。

// xtr1common文件
	// STRUCT TEMPLATE remove_reference
template<class _Ty>
	struct remove_reference
	{	// remove reference
	using type = _Ty;
	};

// xtr1common文件
template<class _Ty>
	using remove_reference_t = typename remove_reference<_Ty>::type;

// type_traits文件
		// FUNCTION TEMPLATE move
template<class _Ty>
	_NODISCARD constexpr remove_reference_t<_Ty>&&
		move(_Ty&& _Arg) noexcept
	{	// forward _Arg as movable
	return (static_cast<remove_reference_t<_Ty>&&>(_Arg));
	}

int v = 5;									// 正確：v是左值
int &&r_ref = 8;							// 正確：re_ref引用右值
int &&r_ref_move = std::move(v); 			// 正確：r_ref_move=5, v是左值，std::move做瞭一次類型轉換。_Ty& &&會被折疊成_Ty&。（賦值之後，v的值是不確定的，這個受移動賦值運算符裡的內容影響）
int &&r_ref_move2 = std::move(r_ref_move);	// 正確：r_ref_move2=5, r_ref_move是左值，std::move做瞭一次類型轉換
int &&r_ref_move3 = std::move("hello");		// 正確：可以給一個std::move傳遞一個右值
v = 9;										// 正確：v、r_ref_move、r_ref_move2=9
r_ref_move = 10;							// 正確：v、r_ref_move、r_ref_move2=10
r_ref_move2 = 11;							// 正確：v、r_ref_move、r_ref_move2=11

// 不考慮規范，僅僅是一個例子class MyClass{	// 移動構造函數    // noexcept不拋出異常	MyClass(MyClass &&c) noexcept;	// ...private:	std::string *p;};// 接管c中的內存，不分配任何新內存（與拷貝構造函數不同）MyClass::MyClass(MyClass &&c) noexcept	: p(c.p){	// 對c運行析構函數是安全的（確保原對象進入可析構的狀態）	c.p = nullptr;}

// 不考慮規范，僅僅是一個例子class MyClass{	// 移動賦值運算符	MyClass& operator=(MyClass &&c) noexcept;	// ...private:	std::string *p;};MyClass& MyClass::operator=(MyClass &&c) noexcept{      // 檢查自賦值：不能在使用右側運算對象的資源之前舊釋放左側運算對象的資源（可能是相同的資源）	if (this != &c) {        free();  //釋放已有元素		p = c.p;		c.p = nullptr;	}    return *this;}

// 一種比較常規的寫法template<class T>void swap(T&a, T&b){	T tmp{a};	a = b;	b = tmp;}// 當遇到string、vector這類類型的交換，第一種方法的拷貝將會造成很大的花費，所以出現下面的一種寫法：template<class T>void swap(T&a, T&b){	T tmp{static_cast<T&&>(a)};	a = static_cast<T&&>(b);	b = static_cast<T&&>(tmp);}// 由於move函數的本質是static_cast<T&&>，所以對上面的函數還可以優化一下寫法template<class T>void swap(T&a, T&b){	T tmp{std::move(a)};	a = std::move(b);	b = std::move(tmp);}

X foo(){    X x;    ...    return x;}

X&& foo(){    X x;    ...    return std::move(x);}

// 對於返回一個對象的函數進行優化。// Rational為分數類，numerator是分子，denominator是分母。// plan 1：返回指針，但是寫法很難看（Rational c = *(a*b)），而且可能會導致資源泄露（忘記刪除函數返回的指針）。const Rational* operator*(const Rational& lhs, const Rational& rhs);// plan 2：必須付出一個構造函數調用的代價，且可能會導致資源泄露const Rational& operator*(const Rational& lhs, const Rational& rhs){    Rational* result = new Rational(lhs.numerator() * rhs.numerator(), 									lhs.denominator() * rhs.denominator())    return *result;}// plan 3：返回引用，在函數退出前，result已經被銷毀。所以，引用指向一個不再存活的對象，會很危險且不正確。const Rational& operator*(const Rational& lhs, const Rational& rhs){    Rational result(lhs.numerator() * rhs.numerator(), 					lhs.denominator() * rhs.denominator())    return result;  // 局部非靜態對象}// 所以，如果函數一定得以值方式返回對象，是無法消除的。所以隻能盡可能地降低對象返回的成本，而不是想盡辦法消除對象本身。// plan 4：有效率且正確的方法。雖然我們構造瞭臨時對象，但是C++允許編譯器將臨時對象優化，使它們不存在。編譯器優化後，調用operator*時沒有任何臨時對象被調用出來。隻需要一個constructor（用以產生c的代價）。const Rational operator*(const Rational& lhs, const Rational& rhs){	return Rational(lhs.numerator() * rhs.numerator(), 					lhs.denominator() * rhs.denominator())}// plan 5：最有效率的做法。使用inline消除調用operator*的函數開銷。inline const Rational operator*(const Rational& lhs, const Rational& rhs){	return Rational(lhs.numerator() * rhs.numerator(), 					lhs.denominator() * rhs.denominator())}Rational a = 10;Rational b(1,2);Rational c = a*b;