左值引用和右值引用

回顾引用

我们之前就了解到了左值引用，首先我们要了解引用在编译器底层其实就是指针。具体来说，当声明引用时，编译器会在底层生成一个指针来表示引用，但在代码编写和使用时，我们可以像使用变量类似取别名的方式一样来操作引用，而不需要显式地使用指针符号。这使得引用更为方便，且看起来更直观，同时也能保证所获得的引用总是有效的。那什么是左值，什么又是右值呢？？

 

什么是左值与右值

左值是表示数据的表达式(如变量名或解引用的指针)，也可能在赋值符号右边，具有地址的、可寻址的表达式才是左值。（typename & ）

右值是一个表达式，如：字面常量、表达式返回值，函数返回值等等，且右值不能出现在赋值符号左边，不能进行取地址才是右值。（typename &&）

 

 右值、左值引用的使用

//左值引用右值
int main()
{
	double x = 1.1, y = 2.2;
	double& r1 = x;
	//double& r2 = x + y;//此时的x1+x2是右值，必须加const修饰才能引用
	const double& r2 = x + y;

	return 0;
}

1. 左值引用只能引用左值，不能引用右值。
2. 但是const左值引用既可引用左值，也可引用右值。

---

 

//右值引用左值
int main()
{
	double x = 1.1, y = 2.2;
	double&& rr1 = x+y;
	//double&& r2 = x;//此时的x1是左值，所以要将属性转换再引用
	double&& r2 = move(x);

	return 0;
}

1. 右值引用只能右值，不能引用左值。
2. 但是右值引用可以move以后的左值。（此时改变的其实是返回值属性）

---

移动构造和移动赋值

引用的好处就是不需要进行拷贝，所以对于自定义类型而言，引用的好处就显得更为重要。那么右值引用的好处也是同样......

下面就简单的以my_string的构造相关函数进行举例：

class my_string
{
public:
	//构造函数
	my_string(const char* tmp="")
		:_size(strlen(tmp))
		, _capacity(_size)
	{
		_s = new char[_capacity + 1];//还有一个\0
		strcpy(_s, tmp);
	}
	// 拷贝构造
	my_string(const my_string& s)
		:_s(nullptr)
	{
		cout << "my_string(const my_string& s) -- 深拷贝" << endl;
	}
	// 赋值重载
	my_string& operator=(const my_string& s)
	{
		cout << "my_string& operator=(my_string s) -- 深拷贝" << endl;
	}

private:
	char* _s;
	size_t _size;
	size_t _capacity;
};

以to_string函数举例深拷贝的消耗： 

my_string to_string(int num)
{
	my_string ret;
	//.........
    //对ret操作
	return ret;//ret返回值会拷贝构造临时对象
}
int main()
{
	my_string s;
	s = to_string(1234);//调用赋值重载

}

其实经过分析我们知道，to_string函数内部创建了一个对象，所以在函数调用结束的时候就会释放该ret对象的空间，所以当我们返回的时候实质上是将ret存进一个临时对象中作为返回值，所以此时会发生第一次的深拷贝，最后返回值再赋值给s对象，所以又发生了一次深拷贝。此时就相当于一共复制拷贝了两份空间，再算上原来的就有三份空间，所以此时如果该空间不是存的to_string，而是存的是其他的大量数据的话，那么此时的消耗是极其大的。

此时其实我们要了解C++11中将右值分为两类：1.纯右值（内置类型的右值）2.将亡值（自定义类型的右值） 

而此时我们的ret出了作用域就销毁，而且还会创建临时对象，所以我们的ret其实会被视作将亡值，所以此时就可以看作是一个右值（编译器进行的特殊处理），所以我们就可以不用再调用拷贝构造来创建临时对象了呀，反正该对象也要销毁，何不直接将临时对象指向该将亡值呢。同理再进行赋值的时候同样也可以啊（函数返回值就是典型的右值，临时对象）

 所以就引出了移动构造和移动拷贝：

    void swap(my_string& s)
	{
		std::swap(_s, s._s);
		std::swap(_size, s._size);
		std::swap(_capacity, s._capacity);
	}
	// 移动构造
	my_string(my_string&& s)//此时编译器会选择更匹配的而不是const my_string&
		:_s(nullptr)
		, _size(0)
		, _capacity(0)
	{
		swap(s);
	}
	// 移动赋值
	my_string& operator=(my_string&& s)
	{
		swap(s);
		return *this;
	}

但是我们要注意的点就是，当我们实现了移动拷贝和移动赋值以后，那么我们将对象move修饰之后进行拷贝和赋值以后，会进行swap进行资源的转移，所以会将该move对象的资源交换，所以在进行移动拷贝之后，该move对象的资源交换后就没了，而调用移动赋值之后，move对象的资源就是交换了。

所以最好不要随意地对一个左值进行move修饰，可能会有意想不到的结果发生。 

---

其实C++11之后，对于容器的push函数都增加了移动构造的形式，这种尤其是对那些需要进行深拷贝的对象而言会方便很多。此时就不需要再拷贝一份，直接将资源交换即可完成拷贝工作。

 右值引用后的属性

  右值被右值引用之后的属性是左值所以就可以被修改：

int main()
{
    double x = 1.1, y = 2.2;
    int&& rr1 = 10;
    const double&& rr2 = x + y;
    rr1 = 20;//右值引用后可以修改
    rr2 = 5.5; // 报错

    return 0;
}

实例： 

 就该移动构造而言，s对象就是右值引用的过后的，再调用swap函数，此时在string&& s接受参数的时候其实s对象的属性就变成了左值，即可被修改，所以传给swap函数时用string& s接受就没问题，但是两个过程中自始至终依旧是一个对象，没有创建额外的对象。

 

就拿这上述string的push_back函数来说，我们知道C++11之后，容器的push_back函数都重载了一份右值插入。所以对于以上的函数来说就显得很麻烦了，因为我们知道右值引用接收右值以后，数据的属性就会变成左值，因此对于这种函数嵌套调用的情况就会显得十分繁琐，需要将每次参数都move一下才可以实现接下来的右值引用接收。但是我们move之后就相当于是写固定了，所以相较于每一次的move对象，我们用完美转发会更好。

 

完美转发 

void Fun(int &x){ cout << "左值引用" << endl; }
void Fun(const int &x){ cout << "const 左值引用" << endl; }
void Fun(int &&x){ cout << "右值引用" << endl; }
void Fun(const int &&x){ cout << "const 右值引用" << endl; }

// 模板中的&&不代表右值引用，而是万能引用，其既能接收左值又能接收右值。
// 模板的万能引用只是提供了能够接收同时接收左值引用和右值引用的能力，
// 但是引用类型的唯一作用就是限制了接收的类型，后续使用中都退化成了左值，
// 我们希望能够在传递过程中保持它的左值或者右值的属性, 就需要用到完美转发
template<typename T>
void PerfectForward(T&& t)//万能引用
{
    Fun(t);//调用fun函数时并不清楚t对象的类型
}

std::forward 完美转发在传参的过程中保留对象原生类型属性

func( forward<T>(t) )//完美转发，保持原有属性

---

 新的类功能

其实我们的移动构造和移动赋值函数也会默认生成，但是条件是：类中没有实现析构函数 、拷贝构造、拷贝赋值重载（就是都没有实现才满足条件）对于默认生成的移动构造函数，对于内置类
型成员会执行逐成员按字节拷贝，自定义类型成员，则需要看这个成员是否实现移动构造，如果实现了就调用移动构造，没有实现就调用拷贝构造。
 

强制生成默认函数的关键字default
禁止生成默认函数的关键字delete