1、右值引用引入的背景
临时对象的产生和拷贝所带来的效率折损，一直是C++所为人诟病的问题。但是C++标准允许编译器对于临时对象的产生具有完全的*度，从而发展出了Copy Elision、RVO（包括NRVO）等编译器优化技术，它们可以防止某些情况下临时对象产生和拷贝。下面简单地介绍一下Copy Elision、RVO，对此不感兴趣的可以直接跳过：
（1） Copy Elision
Copy Elision技术是为了防止某些不必要的临时对象产生和拷贝，例如：
struct A { A(int) {} A(const A &) {} }; A a = 42;
理论上讲，上述A a = 42;语句将分三步操作：第一步由42构造一个A类型的临时对象，第二步以临时对象为参数拷贝构造a，第三步析构临时对象。如果A是一个很大的类，那么它的临时对象的构造和析构将造成很大的内存开销。我们只需要一个对象a，为什么不直接以42为参数直接构造a呢？Copy Elision技术正是做了这一优化。
【说明】：你可以在A的拷贝构造函数中加一打印语句，看有没有调用，如果没有被调用，那么恭喜你，你的编译器支持Copy Elision。但是需要说明的是：A的拷贝构造函数虽然没有被调用，但是它的实现不能没有访问权限，不信你将它放在private权限里试试，编译器肯定会报错。
（2） 返回值优化（RVO，Return Value Optimization）
返回值优化技术也是为了防止某些不必要的临时对象产生和拷贝，例如：
struct A { A(int) {} A(const A &) {} }; A get() {return A(1);} A a = get();
理论上讲，上述A a = get();语句将分别执行：首先get()函数中创建临时对象（假设为tmp1）,然后以tmp1为参数拷贝构造返回值（假设为tmp2），最后再以tmp2为参数拷贝构造a，其中还伴随着tmp1和tmp2的析构。如果A是一个很大的类，那么它的临时对象的构造和析构将造成很大的内存开销。返回值优化技术正是用来解决此问题的，它可以避免tmp1和tmp2两个临时对象的产生和拷贝。
【说明】： a）你可以在A的拷贝构造函数中加一打印语句，看有没有调用，如果没有被调用，那么恭喜你，你的编译器支持返回值优化。但是需要说明的是：A的拷贝构造函数虽然没有被调用，但是它的实现不能没有访问权限，不信你将它放在private权限里试试，编译器肯定会报错。
b）除了返回值优化，你可能还听说过一个叫具名返回值优化（Named Return Value Optimization,NRVO）的优化技术，从程序员的角度而言，它其实跟RVO同样的逻辑。只是它的临时对象具有变量名标识，例如修改上述get()函数为：
A get() { A tmp(1); // #1 // do something return tmp; } A a = get(); // #2
想想上述修改后A类型共有几次对象构造？虽然#1处看起来有一次显示地构造，#2处看起来也有一次显示地构造，但如果你的编译器支持NRVO和Copy Elision，你会发现整个A a = get();语句的执行过程，只有一次A对象的构造。如果你在get()函数return语句前打印tmp变量的地址，在A a = get();语句后打印a的地址，你会发现两者地址相同，这就是应用了NRVO技术的结果。
（3） Copy Elision、RVO无法避免的临时对象的产生和拷贝
虽然Copy Elision和NVO（包括NRVO）等技术能避免一些临时对象的产生和拷贝，但某些情况下它们却发挥不了作用，例如：
template <typename T> void swap(T& a, T& b) { T tmp(a); a = b; b = tmp; }
我们只是想交换a和b两个对象所拥有的数据，但却不得不使用一个临时对象tmp备份其中一个对象，如果T类型对象拥有指向（或引用）从堆内存分配的数据，那么深拷贝所带来的内存开销是可以想象的。为此，C++11标准引入了右值引用，使用它可以使临时对象的拷贝具有move语意，从而可以使临时对象的拷贝具有浅拷贝般的效率，这样便可以从一定程度上解决临时对象的深度拷贝所带来的效率折损。
2、C++03标准中的左值与右值
要理解右值引用，首先得区分左值（lvalue）和右值（rvalue）。
C++03标准中将表达式分为左值和右值，并且“非左即右”：
Every expression is either an lvalue or an rvalue.
区分一个表达式是左值还是右值，最简便的方法就是看能不能够对它取地址：如果能，就是左值；否则，就是右值。
【说明】：由于右值引用的引入，C++11标准中对表达式的分类不再是“非左即右”那么简单，不过为了简单地理解，我们暂时只需区分左值右值即可，C++11标准中的分类后面会有描述。
3、右值引用的绑定规则
右值引用（rvalue reference，&&）跟传统意义上的引用（reference，&）很相似，为了更好地区分它们俩，传统意义上的引用又被称为左值引用（lvalue reference）。下面简单地总结了左值引用和右值引用的绑定规则（函数类型对象会有所例外）：
（1）非const左值引用只能绑定到非const左值；
（2）const左值引用可绑定到const左值、非const左值、const右值、非const右值；
（3）非const右值引用只能绑定到非const右值；
（4）const右值引用可绑定到const右值和非const右值。
测试例子如下：
struct A { A(){} }; A lvalue; // 非const左值对象 const A const_lvalue; // const左值对象 A rvalue() {return A();} // 返回一个非const右值对象 const A const_rvalue() {return A();} // 返回一个const右值对象 // 规则一：非const左值引用只能绑定到非const左值 A &lvalue_reference1 = lvalue; // ok A &lvalue_reference2 = const_lvalue; // error A &lvalue_reference3 = rvalue(); // error A &lvalue_reference4 = const_rvalue(); // error // 规则二：const左值引用可绑定到const左值、非const左值、const右值、非const右值 const A &const_lvalue_reference1 = lvalue; // ok const A &const_lvalue_reference2 = const_lvalue; // ok const A &const_lvalue_reference3 = rvalue(); // ok const A &const_lvalue_reference4 = const_rvalue(); // ok // 规则三：非const右值引用只能绑定到非const右值 A &&rvalue_reference1 = lvalue; // error A &&rvalue_reference2 = const_lvalue; // error A &&rvalue_reference3 = rvalue(); // ok A &&rvalue_reference4 = const_rvalue(); // error // 规则四：const右值引用可绑定到const右值和非const右值，不能绑定到左值 const A &&const_rvalue_reference1 = lvalue; // error const A &&const_rvalue_reference2 = const_lvalue; // error const A &&const_rvalue_reference3 = rvalue(); // ok const A &&const_rvalue_reference4 = const_rvalue(); // ok // 规则五：函数类型例外 void fun() {} typedef decltype(fun) FUN; // typedef void FUN(); FUN & lvalue_reference_to_fun = fun; // ok const FUN & const_lvalue_reference_to_fun = fun; // ok FUN && rvalue_reference_to_fun = fun; // ok const FUN && const_rvalue_reference_to_fun = fun; // ok
【说明】：（1） 一些支持右值引用但版本较低的编译器可能会允许右值引用绑定到左值，例如g++4.4.4就允许，但g++4.6.3就不允许了，clang++3.2也不允许，据说VS2010 beta版允许，正式版就不允许了，本人无VS2010环境，没测试过。
（2）右值引用绑定到字面值常量同样符合上述规则，例如：int &&rr = 123;，这里的字面值123虽然被称为常量，可它的类型为int，而不是const int。对此C++03标准文档4.4.1节及其脚注中有如下说明：
If T is a non-class type, the type of the rvalue is the cv-unqualified version of T.
In C++ class rvalues can have cv-qualified types (because they are objects). This differs from ISO C, in which non-lvalues never have cv-qualified types.
因此123是非const右值，int &&rr = 123;语句符合上述规则三。
此，我们已经了解了不少右值引用的知识点了，下面给出了一个完整地利用右值引用实现move语意的例子：
#include <iostream> #include <cstring> #define PRINT(msg) do { std::cout << msg << std::endl; } while(0) template <class _Tp> struct remove_reference {typedef _Tp type;}; template <class _Tp> struct remove_reference<_Tp&> {typedef _Tp type;}; template <class _Tp> struct remove_reference<_Tp&&> {typedef _Tp type;}; template <class _Tp> inline typename remove_reference<_Tp>::type&& move(_Tp&& __t) { typedef typename remove_reference<_Tp>::type _Up; return static_cast<_Up&&>(__t); } class A { public: A(const char *pstr) { PRINT("constructor"); m_data = (pstr != 0 ? strcpy(new char[strlen(pstr) + 1], pstr) : 0); } A(const A &a) { PRINT("copy constructor"); m_data = (a.m_data != 0 ? strcpy(new char[strlen(a.m_data) + 1], a.m_data) : 0); } A &operator =(const A &a) { PRINT("copy assigment"); if (this != &a) { delete [] m_data; m_data = (a.m_data != 0 ? strcpy(new char[strlen(a.m_data) + 1], a.m_data) : 0); } return *this; } A(A &&a) : m_data(a.m_data) { PRINT("move constructor"); a.m_data = 0; } A & operator = (A &&a) { PRINT("move assigment"); if (this != &a) { m_data = a.m_data; a.m_data = 0; } return *this; } ~A() { PRINT("destructor"); delete [] m_data; } private: char * m_data; }; void swap(A &a, A &b) { A tmp(move(a)); a = move(b); b = move(tmp); } int main(int argc, char **argv, char **env) { A a("123"), b("456"); swap(a, b); return 0; }
输出结果为：
constructor
constructor
move constructor
move assigment
move assigment
destructor
destructor
destructor