透徹理解C++11新特性：右值引用、std::move、std::forward

目錄

• 淺拷貝、深拷貝
• 左值、右值
• 右值引用類型
• 強轉右值 std::move
• 從新審視右值引用
  • 右值引用類型和右值的關係
  • 函數參數傳遞
  • 函數返還值傳遞
• 萬能引用
• 引用摺疊
• 完美轉發 std::forward

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++引入了左值（lvalue）、右值（rvalue）的概念。

• 左值：表達式結束後依然存在的持久對象。
• 右值：表達式結束後就再也不存在的臨時對象。

之因此取名左值右值，是由於在等式左邊的值每每是持久存在的左值類型，在等式右邊的表達式值每每是臨時對象。

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;
}

雖然從優雅的實現深、淺拷貝這個目的開始出發，C++11的移動語義能夠不止用於淺拷貝，得益於它，咱們還能夠作利用右值轉移全部權的特性，在右值所佔有的空間臨時存放一些東西。

強轉右值 std::move

---

除了上面說的臨時值，有些左值其實也很適合轉移全部權：

void func(){
    Vector result;
    //...DoSomehing with ans
    if(xxx){ans = result;}  //如今我但願把結果提取到外部的變量a上。
    return;
}

能夠看到result賦值給ans後就再也不被使用，咱們指望它調用的是移動賦值構造函數。
可是result是一個有變量名的左值類型，所以ans = result 調用的是賦值構造函數而非移動賦值構造函數。

爲了將某些左值當成右值使用，C++11 提供了 std::move 函數以用於將某些左值轉成右值，以匹配右值引用類型。

這也是移動語義的由來：不管是臨時值仍是被強轉的左值，只要遵照轉移全部權的保證，均可以使用移動語義。

void func(){
    Vector result;
    //...DoSomehing with ans
    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&& 類型，但卻由於有變量名（便可持久存在），被編譯器認爲是左值。

//即便函數返還值是臨時值，但返還類型是左值引用類型，所以被認爲是持久存在的左值。
Vector& func1();
//函數返還值爲右值引用類型=>是短暫存在的右值。
Vector&& func2();
//函數返還值爲正常類型=>是短暫存在的右值。
Vector func3();

結論：右值引用類型只是用於匹配右值，而並不是表示一個右值。所以，儘可能不要聲明右值引用類型的變量，而只在函數形參使用它以匹配右值。

實際上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）。

那咱們在寫通常函數形參的時候，有必要每一個函數都提供關於&&形參的重載版本嗎？

回答：通常來講是不必的。對象的移動構造（賦值）函數開銷不大時，咱們能夠只提供非引用類型和左值引用類型（避免Copy Construct）的重載版本，而沒必要編寫右值引用類型的重載版本。

函數返還值傳遞

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的實現）。

結論：咱們應該把編寫右值引用類型相關的任務放在對象的構造、賦值函數上，而非通常函數。從源頭上出發，你就會發如今編寫其它代碼時就會天然而然享受到了移動構造、移動賦值的優化效果。

萬能引用

---

接下來的內容都是屬於模板的部分了：萬能引用、引用摺疊、完美轉發。這部分更加難以理解，不編寫模板代碼的話能夠繞道了。

萬能引用（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::forward<T>()的實現主要就一句return static_cast<T&&>(形參)，實際上也是利用了摺疊規則。從而接受右值引用類型時，將右值引用類型的值返還（返還值爲右值）。接受左值引用類型時，將左值引用類型的值返還（返還值爲左值）。

而std::move<T>()的實現還須要先移除形參的全部引用性質獲得無引用性質的類型（假設爲T2），而後再return static_cast<T2&&>(形參)，從而保證不會發生引用摺疊，而是直接做爲右值引用類型的值返還（返還值爲右值）。