1.什么是右值

右值引用是C++11的概念，与之对应的是左值引用。

当一个对象被用作右值的时候，用的是对象的值(内容)；当对象被用作左值的时候，用的是对象的身份(在内存当中的位置)。

以上的概念是摘录自《C++ primer》。

但是这样的概念并不足以理解。用一句简单的话描述左值和右值：左值都是可以被取地址的；右值都是不可以被取地址的。

根据结论可以快速判断出哪些是左值、哪些是右值：

int func() { return 100; }
int main()
{
	int x = 3;// 可以取地址，左值
	string s("hello");// 可以取地址、左值
	string("world");// 不可取地址、右值
	12;// 不可取地址、右值
	func();// 返回值不可取地址，右值
	return 0;
}

2.移动构造和移动赋值

左值引用只能引用左值，右值引用只能右值、const左值引用可以引用左值也可以引用右值。

单纯的右值引用没有意义。

右值引用的使用场景在于移动构造和移动赋值。

移动构造对应拷贝构造、移动赋值对应赋值运算符重载。

上面的概念是有问题的、不准确的。把他们放在一起的原因是要讨论"移动"和"拷贝"的区别。"移动"区别于"拷贝"，"移动"是不会发生拷贝的，它更像是一种"窃取"、"转移"。

也就是说，把右值的内容"转移"到其他地方去，从而减少不必要的拷贝。写一份伪代码和画一幅图来理解移"移动"：

class String
{
    char *_str;
};

int main()
{
    String s1(String("hello"));
}

如上图，s1对象在调用构造的时候不会调用拷贝构造(如果实现了移动构造)，s1当中的_str成员不会指向new出来的空间，而是指向匿名对象当中_str所指向的空间。

那么从上图看来会有一个潜在的问题，那就是有两个指针指向同一块空间，会有重复析构的风险。所以在编写移动构造的时候，要使资源被移动的对象能够正确析构(在这个例子中让_str指向空就行了)。

这里给出一段String类的移动构造吧：

String(String&& s)
{
	swap(s);
	s._str = nullptr;
	s._size = s._capacity = 0;
	cout << "String:移动构造" << endl;
}

void swap(String& s)
{
	std::swap(_str, s._str);
	std::swap(_size, s._size);
	std::swap(_capacity, s._capacity);    
}

对于移动赋值来说也是一样的道理，都是对右值进行资源转移。这里给出String类的赋值运算符重载代码实现：

String &operator=(String s)
{
	swap(s);
	cout << "String:移动赋值" << endl;
	return *this;
}

这个写法是C++的现代写法，形参是一个对象并不是引用，所以在传参的时候会调用拷贝构造或者是移动构造(如果实参是右值的话)，然后在移动赋值内部进行资源转移。

3.左值"转化"为右值

C++11提供了一个可以将左值"转化"为右值的接口，即std::move()。

实际上"转化"的说法是不对的，因为std::move()的返回值是一个实参的一个右值引用。

int main()
{
    String s1("hello");
    String s2("world");
    String s2 = std::move(s1);
}

在上面的代码当中，s2的赋值操作不会调用赋值重载，而是调用移动赋值。注意std::move()并不是将左值真实的转化为右值，而是返回左值的右值引用。

使用std::move()需要注意一件事情，就拿上面的代码来说，s1赋值给s2，移动赋值之后s1的指向不再指向"hello"，而是指向"world"或者置空。

也就是说使用std::move()并且移动赋值给其他对象的对象，移动赋值结束之后最好不要使用它。

4.左值or右值？

有一个匪夷所思但是真实存在的一个问题，看下面的代码：

String(String&& s)
{
	swap(s);
	s._str = nullptr;
	s._size = s._capacity = 0;
	cout << "String:移动构造" << endl;
}

能够调用移动构造一定是实参是一个右值，那么拿匿名对象为例，它本身没有名字，也就无法直接使用它。但是它移动构造是一个右值引用，既然是引用那么它就是一个对象的别名。

所以得出一个结论，即右值传递给右值引用为参数的函数后，在该函数内部作为左值使用。

但是如果在这个函数内部就是想把它当做右值并且传递给其他函数来使用的话该怎么办？

5.完美转发

在C++11之前就有了万能引用的概念，C++11之后，万能引用的概念更加贴切了。

万能引用既可以引用左值、也可以引用右值。

它的写法就是一个模板类型的右值引用：

template <class T>
void func(T &&t)// 即可以引用左值、也可引用右值
{
	cout << t << endl;
}

int main()
{
	func(15);// 传递右值
	string s1("nice");
	func(s1);// 传递左值
	return 0;
}

但是刚才说过，右值传递并且进入到func函数之后，它就变成了左值，那么如果在func函数内部又调用了一个函数，但是该函数的参数部分只接收右值引用，该怎么办？

void Print(int&& t)
{
	cout << t << endl;
}
template <class T>
void func(T &&t)// 即可以引用左值、也可引用右值
{
	Print(t);
}

如果像上面这么写就会喜提报错：

所以C++11提供了一个方法，即std::forword<T>()方法。它的作用就是实现完美转发，功能就是保持函数模板参数的原有属性(片面理解，这里涉及到引用折叠，稍后解释)。

将上面的代码进行整改：

void Print(int&& t)
{
	cout << t << endl;
}
template <class T>
void func(T &&t)// 即可以引用左值、也可引用右值
{
	Print(std::forward<T>(t));
}

int main()
{
	func(15);// 传递右值
	return 0;
}

那么完美转发的应用场景是什么呢？这里给出一个场景：构造转发，即将构造函数设计成函数模板，使用完美转发将参数保持原样属性传递给其他对象的构造函数。

给出一段代码实现：

template <class Tname,class Tage,class Tsex>
User(Tname &&name, Tage &&age, Tsex &&sex)
	:_name(std::forward<Tname>(name)),
	_age(std::forward<Tage>(age)),
	_sex(std::forward<Tsex>(sex))
{}

如上展示了一个User类的构造函数，暂且不需要关心_name、_age、_sex的具体类型。

反正在这个构造函数当中，name、age、sex所指向的对象都保持原有属性传递给了_name、_age和_sex的构造函数(如果指向的对象是右值的话，那么就是保持右值传递给移动构造)。

所以说，完美转发也可以解决不必要的拷贝问题。

6.引用折叠

引用总共就两种类型嘛，左值引用和右值引用。

注意看上面写的完美转发的函数模板，参数是"模板参数类型的右值引用"。那么模板参数类型无非就三种，非引用类型、左值引用、右值引用，所以引用折叠就是模板参数类型和后面所跟的&&结合起来：

template<calss T>
&&    // T不是引用类型
& &&    // T是左值引用
&& &&    // T是右值引用

在上面的伪代码中，可以得知：只有模板为左值引用的时候才会折叠成左值引用，其他的都是右值引用。

即，折叠后为"&&"，右值引用；折叠后为"& &&"，左值引用；折叠后为"&& &&"，右值引用。

但是引用折叠是不能在代码当中体现的，它只能在一些间接转换的场景当中存在。例如：

int main()
{
	int x = 3;
	int& && rx = x;// 虽然这引用折叠最后会成为左值引用，但是不能在代码体现出来
	return 0;
}

上面的代码是会报错的。

所以可以得出几个结论：

如果传递的是右值，那么模板参数类型就为&&，最后折叠，函数模板的参数就为&&
如果传递的是左值，那么模板参数类型必须为&，最后折叠，函数模板的参数就为& &&，是一个左值引用。传递左值并且模板参数类型如果不是引用类型的话，那么折叠之后就是&&了，这是不对的

7.forward的原理

看一个例子：

template <class T>
void func(T &&t)// 即可以引用左值、也可引用右值
{
	Print(std::forward<T>(t));
}

再看一下forward的原型：

这里就很容易猜出forward的大概原理了。

拿上面的代码来说，如果传递给func的实参是右值，那么T的类型的就是&&，和后面的&&折叠，最终是一个右值引用，那么func的完整写法就该是这样的：

template <class T>
void func(int&& &&t)// 假设实参是int类型
{
	Print(std::forward<T>(t));
}

但是要注意这样的写法是错误的，只是做一个演示。

虽然知道了t是一个右值引用，但是刚才说过，在函数内部只能当成左值来使用，所以在调用forward<T>的时候，匹配的是第一个重载函数。

在forward<T>方法内部，会进行一个类型转换：

template<typename T>
T&& forward(T &param)// forward的实现原理
{
	return static_cast<T&&>(param);
}

因为在调用forward的时候，即func的模板参数类型T为&&，所以forward的模板参数类型T也为&&。forward内部进行一个强制类型转换，param原本是个左值引用嘛，然后强转成&& &&类型，所以forward的返回值就是一个右值引用。这样就实现了forward保持参数原有属性的功能。

同样的，如果传递给func的实参就是一个左值，那么func、forward的模板参数类型T为&，所以在forward内部当中，所以param就强转成了& &&类型，是一个左值引用。