C++11 引入的新特性中，除了併發記憶體模型和相關設施，這些高帥富之外，最引人入勝且接地氣的特性就要屬『右值引用』了（rvalue reference）。加入右值引用的動機在於效率：減少不必要的資源拷貝。考慮下面的程式：

std::vector<string> v;
v.push_back("string");

　　向 vector 中新增一個元素，這個動作需要先後呼叫 string::string(const char*), string::string(const string&), string::~string() 三個函式，涉及兩次記憶體拷貝：第一次使用字面常量 “string” 構造出一個臨時物件，第二次使用該臨時物件構造出 vector 中的一個新元素，『最後臨時物件會發生析構』。

移動語義

　　上面程式操作的問題癥結在於，臨時物件的構造和析構帶來了不必要的資源拷貝。如果有一種機制，可以在語法層面識別出臨時物件，在使用臨時物件構造新物件（拷貝構造）的時候，將臨時物件所持有的資源『轉移』到新的物件中，就能消除這種不必要的拷貝。這種語法機制就是『右值引用』，相對地，傳統的引用被稱為『左值引用』。左值引用使用 ‘&’ 標識（比如 string&），右值引用使用 ‘&&’ 標識（比如 string&&）。順帶提一下什麼是左值（lvalue）什麼是（rvalue）：可以取地址的具名物件是左值；無法取值的物件是右值，包括匿名的臨時物件和所有字面值（literal value）。
　　有了右值的語法支援，為了實現移動語義，需要相應類以右值為引數過載傳統的拷貝建構函式和賦值操作符，畢竟哪些資源可以移動、哪些只能拷貝只有類的實現者才知道。對於移動語義的拷貝『構造』，一般流程是將源物件的資源繫結到目的物件，然後解除源物件對資源的繫結；對於賦值操作，一般流程是，首先銷燬目的物件所持有的資源，然後改變資源的繫結。另外，當然，與傳統的構造和賦值相似，還要考慮到構造的異常安全和自賦值情況。作為演示：

classString{public:String(constString&rhs){...}String(String&&rhs){
        s_ = rhs.s_;
        rhs.s_ = NULL;}String&operator=(constString&rhs){...}String&operator=(String&&rhs){if(this!=&rhs){delete[] s_;
            s_ = rhs.s_;
            rhs.s_ = NULL;}return
 
*this;}private:char*s_;};

　　值得注意的是，一個繫結到右值的右值引用是『左值』，因為它是有名字的。考慮：

class B {public:
    B(const B&){}
    B(B&&){}};class D :public B {
    D(const D &rhs): B(rhs){}
    D(D &&rhs): B(rhs){}};
D getD();
D d(getD());

　　上面程式中，B::B(B&&) 不會被呼叫。為此，C++11 中引入 std::move(T&& t) 模板函式，它 t 轉換為右值：

class D :public B {
    D(D &&rhs): B(std::move(rhs)){}};

　　std::move 的一種可能的實現：

template<typename T>typename remove_reference<T>::type&&
move(T &&t){returnstatic_cast<remove_reference<T>::type&&>(t);}

繫結規則

　　引入右值引用後，『引用』到『值』的繫結規則也得到擴充：

1. 左值引用可以繫結到左值: int x; int &xr = x;
2. 非常量左值引用不可以繫結到右值: int &r = 0;
3. 常量左值引用可以繫結到左值和右值：int x; const int &cxr = x; const int &cr = 0;
4. 右值引用可以繫結到右值：int &&r = 0;
5. 右值引用不可以繫結到左值：int x; int &&xr = x;
6. 常量右值引用沒有現實意義（畢竟右值引用的初衷在於移動語義，而移動就意味著『修改』）。

　　其中，第五條規則『不適用於』函式模板的形參，例如下面的函式可以接受任意型別的引數，既可以是右值也可以是左值，還可以是常量或者非常量：

template<typename T>void foo(T &&t);int x;constint xx;
foo(x);//~ OK
foo(xx);//~ OK
foo(10);//~ OK

　　T&& 形參可以接受左值，是 C++11 針對這種特殊情況做的規則修訂，目的是為了實現『完美轉發』（perfect forwarding）。

完美轉發

　　C++11 之前，一直存在著引數『轉發』的問題，即不能方便地實現完美轉發。轉發的目的在於傳遞『引用引數』的附加屬性，比如 cv 屬性（const/volatile）和左右值屬性。為了刻畫這個問題，我們以左右值屬性的傳遞為例（cv 屬性也存在相似的問題），參考下面的類定義：

class X
{public:
    X(const std::string&s,const std::vector<int>&v): s_(s), v_(v){}private:
    std::string s_;
    std::vector<int> v_;};

　　為了支援移動語義，就需要過載建構函式，由於建構函式有兩個引數，還需要考慮到右值引用和左值引用的組合形式：

class X
{public:
    X(const std::string&s,const std::vector<int>&v): s_(s), v_(v){}
    X(std::string&&s,const std::vector<int>&v): s_(std::move(s)), v_(v){}
    X(const std::string&s, std::vector<int>&&v): s_(s), v_(std::move(v)){}
    X(std::string&&s, std::vector<int>&&v): s_(std::move(s)), v_(std::move(v)){}private:
    std::string s_;
    std::vector<int> v_;};

　　如果建構函式有 n 個引數，就需要 2^n 個過載！
　　C++11 中，通過基於右值引用的函式模板解決了這個問題，本質上是通過對實參型別的推演，按照實際情況，由編譯器完成自動的『過載』。

class X
{public:template<typename T1,typename T2>
    X(T1 &&s, T2 &&v): s_(std::forward<T1>(s)), v_(std::forward<T2>(v)){}private:
    std::string s_;
    std::vector<int> v_;};

　　在介紹這種轉發之前，先需要知道右值引用形參的函式模板的實參推演規則，即引用摺疊（reference collapsing）。BTW. C++11 之前，不允許繫結到引用的引用型別（reference to reference）。
　　設 T 為模板的型別引數，A 為實參的基本型別，則有：

　　可以看到，當函式的形參宣告為 T&& 時，當且僅當實參為右值或者右值引用，摺疊後的的實參型別才是右值引用，否則為左值引用。通過這個摺疊規則，就可以實現左右值引用屬性的轉發。std::forward 就可以簡單地實現為：

template<typename T>
T&& forward(T &&t){returnstatic_cast<T&&>(t);}

總結

　　C++11 中引入很多特性，大多讓人眼前一亮：靠，這就是我一直想要的啊！很多特性瀏覽一遍就清晰了，但右值引用相關的，尤其是完美轉發相對來說比較繞，難以理順。右值引用有兩個應用，最基本的動機是移動語義，同時又給完美轉發的支援帶來契機。