C++11出現的右值相關語法可謂是很多C++程序員難以理解的新特性，不少人知其然而不知其所以然，面試被問到時大概就只知道可以減少開銷，但是為什么減少開銷、減少了多少開銷、什么時候用...這些問題也不一定知道，於是我寫下了這篇夾帶自己理解的博文，希望它對你有所幫助。
淺拷貝、深拷貝
在介紹右值引用等概念之前，可以先來認識下淺拷貝（shallow copy）和深拷貝（deep copy）。
這里舉個例子：
class Vector{
int num;
int* a;
public:
void ShallowCopy(Vector& v);
void DeepCopy(Vector& v);
};
- 淺拷貝：按位拷貝對象，創建的新對象有着原始對象屬性值的一份精確拷貝（但不包括指針指向的內存）。
//淺拷貝
void Vector::ShallowCopy(Vector& v){
this.num = v.num;
this.a = v.a;
}
- 深拷貝：拷貝所有的屬性（包括屬性指向的動態分配的內存）。換句話說，當對象和它所引用的對象一起拷貝時即發生深拷貝。
//深拷貝
void Vector::DeepCopy(Vector& v){
this.num = v.num;
this.a = new int[num];
for(int i=0;i<num;++i){a[i]=v.a[i]}
}
可以看到，深拷貝的開銷往往比淺拷貝大（除非沒有指向動態分配內存的屬性），所以我們就傾向盡可能使用淺拷貝。
但是淺拷貝的有一個問題：當有指向動態分配內存的屬性時，會造成多個對象共用這塊動態分配內存，從而可能導致沖突。一個可行的辦法是：每次做淺拷貝后，必須保證原始對象不再訪問這塊內存（即轉移所有權給新對象），這樣就保證這塊內存永遠只被一個對象使用。
那有什么對象在被拷貝后可以保證不再訪問這塊內存呢？相信大家心里都有答案：臨時對象。
左值、右值
C++在C++98時便遵循C模型，引入了左值、右值的概念。
- 左值（lvalue） ：表達式結束后依然存在的持久對象。
- 右值（rvalue） ：表達式結束后就不再存在的臨時對象。
之所以取名左值右值，是因為在等式左邊的值往往是持久存在的左值類型，在等式右邊的表達式值往往是臨時對象。
a = 152;
a = ++b;
a = b+c*2;
a = func();
字面量（字符字面量除外）、臨時的表達式值、臨時的函數返還值這些短暫存在的值都是右值。更直觀的理解是：有變量名的對象都是左值，沒有變量名的都是右值。（因為有無變量名意味着這個對象是否在下一行代碼時依然存在）
值得注意的是，字符字面量是唯一不可算入右值的字面量，因為它實際存儲在靜態內存區，是持久存在的。
右值引用類型
有了左值、右值的概念，我們就很清楚認識到右值都是些短暫存在的臨時對象。
於是，C++11 為了匹配這些左右值，引入了右值引用類型 && 。
右值引用類型負責匹配右值，左值引用則負責匹配左值。
因此剛剛的淺拷貝、深拷貝例子，我們可以無需顯式調用淺拷貝或深拷貝函數，而是調用重載函數：
//左值引用形參=>匹配左值
void Vector::Copy(Vector& v){
this.num = v.num;
this.a = new int[num];
for(int i=0;i<num;++i){a[i]=v.a[i]}
}
//右值引用形參=>匹配右值
void Vector::Copy(Vector&& temp){
this.num = temp.num;
this.a = temp.a;
}
當然，最標准還是編寫成各種構造函數（拷貝構造、移動構造、賦值構造、移動賦值構造）：
移動的意思是轉移所有權。由於右值都是臨時的值（右值其實也不一定是臨時值，后文會說到），臨時值釋放后也就不再持有屬性的所有權，因此這相當於轉移資源所有權的行為。
//拷貝構造函數：這意味着深拷貝
Vector::Vector(Vector& v){
this.num = v.num;
this.a = new int[num];
for(int i=0;i<num;++i){a[i]=v.a[i]}
}
//移動構造函數：這意味着淺拷貝
Vector::Vector(Vector&& temp){
this.num = temp.num;
this.a = temp.a;
temp.a = nullptr; //實際上Vector一般都會在析構函數來釋放指向的內存，所以需賦值空地址避免釋放
}
雖然從優雅的實現深、淺拷貝這個目的開始出發，C++11的移動語義可以不止用於淺拷貝。得益於轉移所有權的特性，我們還可以做其它事情，例如在右值所占有的空間臨時存放一些東西。
強轉右值 std::move
除了上面說的臨時值，有些左值其實也很適合轉移所有權：
void func(){
Vector result;
//...DoSomehing with result
if(xxx){ans = result;} //現在我希望把結果提取到外部的變量a上。
return;
}
可以看到result賦值給ans后就不再被使用，我們期望它調用的是移動賦值構造函數。
但是result是一個有變量名的左值類型，因此ans = result 調用的是賦值構造函數而非移動賦值構造函數。
為了將某些左值當成右值使用，C++11 提供了 std::move 函數以用於將某些左值轉成右值，以匹配右值引用類型。
void func(){
Vector result;
//...DoSomehing with result
if(xxx){ans = std::move(result);} //調用的是移動賦值構造函數
return;
}
重新審視右值、右值引用
右值引用類型和右值的關系
有了上面的知識后，我們來重新審視一下右值引用類型。
先看看如下代碼：
void test(Vector& o) {std::cout << "為左值。" << std::endl;}
void test(Vector&& temp) {std::cout << "為右值。" << std::endl;}
int main(){
Vector a;
Vector&& b = Vector();
//請分別回答：a、std::move(a)、b 分別是左值還是右值？
test(a);
test(std::move(a));
test(b);
}
答：a是左值，std::move(a)是右值，但b卻是左值。
在這里b雖然是 Vector&& 類型，但卻因為有變量名（即可持久存在），被編譯器認為是左值。
結論：右值引用類型只是用於匹配右值，而並非表示一個右值。因此，盡量不要聲明右值引用類型的變量，而只在函數形參使用它以匹配右值。
左值、右值、純右值、將亡值
前面對移動語義的認識我們都是基於C++98時左值、右值概念，而C++11對左值、右值類別被重新進行了定義，因此現在我們重新認識一下新的類別。
C++11使用下面兩種獨立的性質來區別類別：
- 擁有身份：指代某個非臨時對象。
- 可被移動：可被右值引用類型匹配。
每個C++表達式只屬於三種基本值類別中的一種：左值 (lvalue)、純右值 (prvalue)、將亡值 (xvalue)
- 擁有身份且不可被移動的表達式被稱作 左值 (lvalue) 表達式，指持久存在的對象或類型為左值引用類型的返還值。
- 擁有身份且可被移動的表達式被稱作 將亡值 (xvalue) 表達式，一般是指類型為右值引用類型的返還值。
- 不擁有身份且可被移動的表達式被稱作 純右值 (prvalue) 表達式，也就是指純粹的臨時值（即使指代的對象是持久存在的）。
- 不擁有身份且不可被移動的表達式無法使用。
如此分類是因為移動語義的出現，需要對類別重新規范說明。例如不能簡單定義說右值就是臨時值（因為也可能是std::move過的對象，該代指對象並不一定是臨時值）。
Vector& func1();
Vector&& func2();
Vector func3();
int main(){
Vector a;
a; //左值表達式
func1(); //左值表達式，返還值是臨時的，返還類型是左值引用，因此被認為不可移動。
func2(); //將亡值表達式，返還值是臨時的，返還類型是右值引用，因此指代的對象即使非臨時也會被認為可移動。
func3(); //純右值表達式，返還值為臨時值。
std::move(a)； //將亡值表達式，std::move本質也是個函數，同上。
Vector(); //純右值表達式
}
而現在我們可以歸納為：
- 左值（lvalue） 指持久存在（有變量名）的對象或返還值類型為左值引用的返還值，是不可移動的。
- 右值（rvalue） 包含了 將亡值、純右值，是可移動（可被右值引用類型匹配）的值。
實際上C++ std::move函數的實現原理就是的強轉成右值引用類型並返還之，因此該返還值會被判斷為將亡值，更寬泛的說是被判定為右值。
函數參數傳遞
void func1(Vector v) {return;}
void func2(Vector && v) {return;}
int main() {
Vector a;
Vector &b = a;
Vector c;
Vector d;
//請回答：不開優化的版本下，調用以下函數分別有多少Copy Consturct、Move Construct的開銷？
func1(a);
func1(b);
func1(std::move(c));
func2(std::move(d));
}
實際上在不開優化的版本下，如果實參為右值，調用func1的開銷只比func2多了一次移動構造函數和析構函數。
實參傳遞給形參，即形參會根據實參來構造。其結果是調用了移動構造函數；函數結束時則釋放形參。
倘若說對象的移動構造函數開銷較低（例如內部僅一個指針屬性），那么使用無引用類型的形參函數是更優雅的選擇，而且還能接受左值引用類型或無引用的實參（盡管這兩種實參都會導致一次Copy Consturct）。可以說，這種情況下，只提供非引用類型的版本，也是可以接受的。
那我們在寫一般函數形參的時候，若參數有支持移動構造（或移動賦值）的類型，是否有必要每個函數都提供關於&&形參的重載版本嗎？
回答：從極致的優化角度來看是有必要的，應該提供右值引用類型的重載版本，更准確說應該同時提供左值引用（匹配左值）和右值引用（匹配右值）兩種重載版本。
這里糾正了以前的說法。
函數返還值傳遞
Vector func1() {
Vector a;
return a;
}
Vector func2() {
Vector a;
return std::move(a);
}
Vector&& func3() {
Vector a;
return std::move(a);
}
int main() {
//請回答：不開優化的版本下，執行以下3行代碼分別有多少Copy Consturct、Move Construct的開銷？
Vector test1 = func1();
Vector test2 = func2();
Vector test3 = func3();
}
同樣的道理，執行這3行代碼實際上都沒有任何Copy Construct的開銷（這其中也有NRV技術的功勞），都是只有一次Move Construct的開銷。
此外一提，func3是危險的。因為局部變量釋放后，函數返還值仍持有它的右值引用。
因此，這里也不建議函數返還右值引用類型，同前面傳遞參數類似的，移動構造開銷不大的時候，直接返還非引用類型就足夠了（在某些特殊場合有特別作用，准確來說一般用於表示返還成一個右值，如std::move的實現）。
結論：
1. 我們應該首先把編寫右值引用類型相關的任務重點放在對象的構造、賦值函數上。從源頭上出發，在編寫其它代碼時會自然而然享受到了移動構造、移動賦值的優化效果。
2. 形參：從優化的角度上看，若參數有支持移動構造（或移動賦值）的類型，應提供左值引用和右值引用的重載版本。移動開銷很低時，只提供一個非引用類型的版本也是可以接受的。
3. 返還值：不要且沒必要編寫返還右值引用類型的函數，除非有特殊用途。
萬能引用
接下來的內容都是屬於模板的部分了：萬能引用、引用折疊、完美轉發。這部分更加難以理解，不編寫模板代碼的話可以繞道了。
萬能引用（Universal Reference）：
- 發生類型推導（例如模板、auto）的時候，使用T&&類型表示為萬能引用，否則表示右值引用。
- 萬能引用類型的形參既能匹配任意引用類型的左值、右值。
也就是說編寫模板函數時，只提供萬能引用形參一個版本就可以匹配左值、右值，不必編寫多個重載版本。
template<class T>
void func(T&& t){
return;
}
int main() {
Vector a,b;
func(a); //OK
func(std::move(b)); //OK
}
此外需要注意的是，使用萬能引用參數的函數是最貪婪的函數，容易讓需要隱式轉換的實參匹配到不希望的轉發引用函數。例如下面代碼：
template<class T>
void f(T&& value);
void f(int a);
//當調用f(long類型的參數)或者f(short類型的參數)，則不會匹配int版本而是匹配到萬能引用的版本
引用折疊
使用萬能引用遇到的第一個問題是推導類型會出現不正確的引用類型：例如當模板參數T為Vector&或Vector&&，模板函數形參為T&&時，展開后變成Vector& &&或者Vector&& &&。
template<class T>
void func(T&& t){
return;
}
int main(){
func(Vector()); //模板參數T被推導為Vector&&
}
但顯然C++中是不允許對引用再進行引用的，於是為了讓模板參數正確傳遞引用性質，C++定義了一套用於推導類型的引用折疊（Reference Collapse）規則：
所有的折疊引用最終都代表一個引用，要么是左值引用，要么是右值引用。
| 引用折疊 | & | && |
|---|---|---|
| & | & | & |
| && | & | && |
Example1：
func(Vector());
模板函數func的T被推導為Vector&&，形參object為T&&即展開后為Vector&& &&。由於折疊規則的存在，形參object最終被折疊推導為Vector&&類型。
Example2：
func(a);
模板函數func的T在這里被推導為Vector&，形參object為T&&即展開后為Vector& &&。由於折疊規則的存在，形參object最終被推導為Vector&類型。
完美轉發 std::forward<T>
當我們使用了萬能引用時，即使可以同時匹配左值、右值，但需要轉發參數給其他函數時，會丟失引用性質（形參是個左值，從而無法判斷到底匹配的是個左值還是右值）。
//當然我們也可以寫成如下重載代碼，但是這已經違背了使用萬能引用的初衷（僅編寫一個模板函數就可以匹配左值、右值）
template<class T>
void func(T& t){
doSomething(t);
}
template<class T>
void func(T&& t){
doSomething(std::move(t));
}
完美轉發（Perfect Forwarding）：C++11提供了完美轉發函數 std:forward<T> 。它可以在模板函數內給另一個函數傳遞參數時，將參數類型保持原本狀態傳入（如果形參推導出是右值引用則作為右值傳入，如果是左值引用則作為左值傳入）。
於是現在我們可以這樣做了:
template<class T>
void func(T&& object){
doSomething(std::forward<T>(object));
}
不借助std::forward<T>間接傳入參數的話，無論object是左值引用類型，還是右值引用類型，都會被視為左值。
而std::move<T>()的實現還需要先移除形參的所有引用性質得到無引用性質的類型（假設為T2），然后再return static_cast<T2&&>(形參)，從而保證不會發生引用折疊，而是直接作為右值引用類型的值返還（返還值為右值）。