清楚什么是左值、右值以及变量的引用：

左值和右值的概念想必大家都听说过，就比如编译器有时候会调皮地说："left operand must be l-value"（左操作数必须为左值）。当废话将，就是等号左边是左值，等号右边是右值。

左值含义：

形如x = 1，x = y，这里的x就是左值，表示一个地址，这块地址存放了右值所代表的内容，对于x = 1来说，右值是1；对于x = y来说，右值是y所在内存单元存储的内容。而如果我们令1 = 2，编译器会报错，因为常量做了左值，而常量是不可被修改，同样不能被赋值的。

引用：

引用（&）实际上就是给当前某个变量取了个别名，对这个名字进行操作等价于对这个名字代表的那个变量做相同的操作。声明方法：类型名 &变量名 = 所要代表的变量。如：

/**
    输出：
    2 2
    1 1
*/
int a = 2;
int &ra = a;
cout << a << " " << ra << endl;
ra = 1;
cout << a << " " << ra << endl;

我们知道在函数内部对参数进行修改往往得不到想要的结果，因为在函数体内对局部变量的操作是不会影响外部变量的，这是因为二者所在的内存单元，也就是地址根本就不同。但是如果使用引用来修饰参数，那么我们可以实现函数内外同步对变量进行修改：

/**
    结果：
    0 0 1
*/
void test_1(int val) {
	val = 1; //局部变量的修改
}

void test_2(int &val) {
	val = 1; //对引用的修改
}

int main() {
	int v = 0;
	cout << v << " "; //原值输出0
	test_1(v);
	cout << v << " "; //对局部变量的修改无法改变外部变量，输出0
	test_2(v);
	cout << v << " "; //对引用的修改，原内存单元已被修改，输出1
	return 0;
}

?交换函数就是一个很好的例子，这个过程也可以用指针来实现，原理也是对外部变量所指地址的内存单元进行修改。

C++11引入的右值引用：

? ? ? ? 有没有发现，刚才说的（&）只是针对左值而言，这个引用能让不同名字的变量共享一个内存单元。观察如下代码：

int a = 1;   //正确
int &ra = a; //正确，ra是a的引用
int &b = 1;  //错误，编译提示非常量引用的初始值必须为左值，而1是常量只能作右值

int a = 1;
const int &b = a; //常量左值引用既可以操作左值
const int &c = 1;   //常量左值引用既可以操作右值
 
//右值引用，由C++11标准引入，符号为&&（无空格）
int &&a = 1; //声明一个右值引用
a = 10;      //右值可以修改

const int&& a = 10; //常值的右值引用也是支持的

? 表格方便理解与记忆左右常值的引用关系：

折叠规则：

给出引用类型的内在转换关系：

? ? ? ? T& + & <=> T& ;

? ? ? ? T&& + & <=> T& ;

? ? ? ? T& + && <=> T& ;

? ? ? ? T&& + && <=> T&& ;

std::move：

  template<typename _Tp>
    inline typename std::remove_reference<_Tp>::type&&
    move(_Tp&& __t)
    { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

?源码很抽象，简单说一下，给大家两个结论：

只要我们传递一个基本类型是A④的左值，那么，传递后，T的类型就是A&，形参在函数体中的类型就是A&。
只要我们传递一个基本类型是A的右值，那么，传递后，T的类型就是A，形参在函数体中的类型就是A&&。

?那么，加入我们有如下调用：

struct A{};
int main()
{
    A a;
    move(a);
}

那么，对应到模板中，_Tp类型为int&，_Tp&&类型利用折叠规则为int&，__t也就是实参a的类型为int&，remove_reference<_Tp>后变为int（remove_reference是引用移除，简介我再下一个代码块简单展示），所以 typename std::remove_reference<_Tp>::type&&的类型就为int&&，作为返回值返回，到这如果远离不太懂的可以看一看函数模板参数推到规则，由于篇幅我就不赘述了。

int a[] = { 1,2 };
decltype(*a) b = a[0]; //b的类型为int&
b = 2;
cout << a[0] << " " << a[1] << endl;
//cout << typeid(decltype(*a)).name();
remove_reference<decltype(*a)>::type c = a[0]; //c的类型为int
c = 3;
cout << a[0] << " " << a[1] << endl;

实际上到这，move的功能也就清晰了——它要把一个变量转换成右值引用。

拿std::remove函数来讲，它里面就用到了move函数，大家应该都知道remove并不是真正的删除，而是把符合元素的条件前移，而在移动的过程中，我们可以拷贝一份内容放到前面的位置，但是这就不高效了，STL中选择用move直接把当前位置的右值引用拿过来放到前面去，就是用的这个move，所以我们可以说move是为性能而生的。

函数返回值优化：

如果一个函数有返回值，它在返回值的时候要进行一次返回对象的拷贝构造函数。如果这个对象很小，很快就拷贝完了；但是如果这个对象很大，每次返回时候都要调用一次拷贝构造函数，就很浪费时间了。因此，g++内置了返回值优化，内容是删除删除保持函数返回值的临时对象。这可能会省略多次复制构造函数。

这样一来，返回的效率变高了。

如果我们用上面说的move，直接返回右值引用呢？它和编译器的返回值优化有没有区别呢？实际上是有的。此处可以参考如下链接：一段小代码秒懂C++右值引用和RVO(返回值优化)的误区。

编译器默认使用返回值优化，所以我们不必多此一举。不过基本的利用方式我们可以了解一下：

//常量可以作右值，正确，相当于int&& a = move(1);
int&& test()
{
	int a = 1;
	return move(1);
}
//非常量的右值只能赋值给左值，所以错误，但编译通过
vector<int>&& test1() {
	vector<int> a = { 1 };
	return move(a);
}
//正确
vector<int> test1() {
	vector<int> a = { 1 };
	return move(a);
}