一篇文章弄懂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;