[c++11]我理解的右值引用、移動語義和完美轉發

時間 2019-12-13

標籤 c++11 理解引用移動語義完美轉發欄目 C&C++ 简体版

原文原文鏈接

c++中引入了右值引用和移動語義，能夠避免無謂的複製，提升程序性能。有點難理解，因而花時間整理一下本身的理解。ios

左值、右值

C++中全部的值都必然屬於左值、右值兩者之一。左值是指表達式結束後依然存在的持久化對象，右值是指表達式結束時就再也不存在的臨時對象。全部的具名變量或者對象都是左值，而右值不具名。很可貴到左值和右值的真正定義，可是有一個能夠區分左值和右值的便捷方法：看能不能對錶達式取地址，若是能，則爲左值，不然爲右值。c++

看見書上又將右值分爲將亡值和純右值。純右值就是c++98標準中右值的概念，如非引用返回的函數返回的臨時變量值；一些運算表達式，如1+2產生的臨時變量；不跟對象關聯的字面量值，如2，'c'，true，"hello"；這些值都不可以被取地址。數組

而將亡值則是c++11新增的和右值引用相關的表達式，這樣的表達式一般時將要移動的對象、T&&函數返回值、std::move()函數的返回值等，安全

不懂將亡值和純右值的區別其實不要緊，統一看做右值便可，不影響使用。ide

示例：函數

int i=0;// i是左值， 0是右值

class A {
  public:
    int a;
};
A getTemp()
{
    return A();
}
A a = getTemp();   // a是左值  getTemp()的返回值是右值（臨時變量）

左值引用、右值引用

c++98中的引用很常見了，就是給變量取了個別名，在c++11中，由於增長了右值引用(rvalue reference)的概念，因此c++98中的引用都稱爲了左值引用(lvalue reference)。性能

int a = 10; 
int& refA = a; // refA是a的別名， 修改refA就是修改a, a是左值，左移是左值引用

int& b = 1; //編譯錯誤! 1是右值，不可以使用左值引用

c++11中的右值引用使用的符號是&&，如學習

int&& a = 1; //實質上就是將不具名(匿名)變量取了個別名
int b = 1;
int && c = b; //編譯錯誤！ 不能將一個左值複製給一個右值引用
class A {
  public:
    int a;
};
A getTemp()
{
    return A();
}
A && a = getTemp();   //getTemp()的返回值是右值（臨時變量）

getTemp()返回的右值原本在表達式語句結束後，其生命也就該終結了（由於是臨時變量），而經過右值引用，該右值又重獲新生，其生命期將與右值引用類型變量a的生命期同樣，只要a還活着，該右值臨時變量將會一直存活下去。實際上就是給那個臨時變量取了個名字。測試

注意：這裏a的類型是右值引用類型(int &&)，可是若是從左值和右值的角度區分它，它其實是個左值。由於能夠對它取地址，並且它還有名字，是一個已經命名的右值。優化

因此，左值引用只能綁定左值，右值引用只能綁定右值，若是綁定的不對，編譯就會失敗。可是，常量左值引用倒是個奇葩，它能夠算是一個「萬能」的引用類型，它能夠綁定很是量左值、常量左值、右值，並且在綁定右值的時候，常量左值引用還能夠像右值引用同樣將右值的生命期延長，缺點是，只能讀不能改。

const int & a = 1; //常量左值引用綁定 右值， 不會報錯

class A {
  public:
    int a;
};
A getTemp()
{
    return A();
}
const A & a = getTemp();   //不會報錯 而 A& a 會報錯

事實上，不少狀況下咱們用來常量左值引用的這個功能卻沒有意識到，以下面的例子：

#include <iostream>
using namespace std;

class Copyable {
public:
    Copyable(){}
    Copyable(const Copyable &o) {
        cout << "Copied" << endl;
    }
};
Copyable ReturnRvalue() {
    return Copyable(); //返回一個臨時對象
}
void AcceptVal(Copyable a) {

}
void AcceptRef(const Copyable& a) {

}

int main() {
    cout << "pass by value: " << endl;
    AcceptVal(ReturnRvalue()); // 應該調用兩次拷貝構造函數
    cout << "pass by reference: " << endl;
    AcceptRef(ReturnRvalue()); //應該只調用一次拷貝構造函數
}

當我敲完上面的例子並運行後，發現結果和我想象的徹底不同！指望中AcceptVal(ReturnRvalue())須要調用兩次拷貝構造函數，一次在ReturnRvalue()函數中，構造好了Copyable對象，返回的時候會調用拷貝構造函數生成一個臨時對象，在調用AcceptVal()時，又會將這個對象拷貝給函數的局部變量a，一共調用了兩次拷貝構造函數。而AcceptRef()的不一樣在於形參是常量左值引用，它可以接收一個右值，並且不須要拷貝。

而實際的結果是，無論哪一種方式，一次拷貝構造函數都沒有調用！

這是因爲編譯器默認開啓了返回值優化(RVO/NRVO, RVO, Return Value Optimization 返回值優化，或者NRVO， Named Return Value Optimization)。編譯器很聰明，發如今ReturnRvalue內部生成了一個對象，返回以後還須要生成一個臨時對象調用拷貝構造函數，很麻煩，因此直接優化成了1個對象對象，避免拷貝，而這個臨時變量又被賦值給了函數的形參，仍是不必，因此最後這三個變量都用一個變量替代了，不須要調用拷貝構造函數。

雖然各大廠家的編譯器都已經都有了這個優化，可是這並非c++標準規定的，並且不是全部的返回值都可以被優化，而這篇文章的主要講的右值引用，移動語義能夠解決編譯器沒法解決的問題。

爲了更好的觀察結果，能夠在編譯的時候加上-fno-elide-constructors選項(關閉返回值優化)。

// g++ test.cpp -o test -fno-elide-constructors
pass by value: 
Copied
Copied //能夠看到確實調用了兩次拷貝構造函數
pass by reference: 
Copied

上面這個例子本意是想說明常量左值引用可以綁定一個右值，能夠減小一次拷貝（使用很是量的左值引用會編譯失敗），可是順便講到了編譯器的返回值優化。。編譯器仍是幹了不少事情的，頗有用，但不能過於依賴，由於你也不肯定它何時優化了何時沒優化。

總結一下，其中T是一個具體類型：

左值引用，使用 T&, 只能綁定左值
右值引用，使用 T&&，只能綁定右值
常量左值，使用 const T&, 既能夠綁定左值又能夠綁定右值
已命名的右值引用，編譯器會認爲是個左值
編譯器有返回值優化，但不要過於依賴

移動構造和移動賦值

回顧一下如何用c++實現一個字符串類MyString，MyString內部管理一個C語言的char *數組，這個時候通常都須要實現拷貝構造函數和拷貝賦值函數，由於默認的拷貝是淺拷貝，而指針這種資源不能共享，否則一個析構了，另外一個也就完蛋了。

具體代碼以下：

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

class MyString
{
public:
    static size_t CCtor; //統計調用拷貝構造函數的次數
//    static size_t CCtor; //統計調用拷貝構造函數的次數
public:
    // 構造函數
   MyString(const char* cstr=0){
       if (cstr) {
          m_data = new char[strlen(cstr)+1];
          strcpy(m_data, cstr);
       }
       else {
          m_data = new char[1];
          *m_data = '\0';
       }
   }

   // 拷貝構造函數
   MyString(const MyString& str) {
       CCtor ++;
       m_data = new char[ strlen(str.m_data) + 1 ];
       strcpy(m_data, str.m_data);
   }
   // 拷貝賦值函數 =號重載
   MyString& operator=(const MyString& str){
       if (this == &str) // 避免自我賦值!!
          return *this;

       delete[] m_data;
       m_data = new char[ strlen(str.m_data) + 1 ];
       strcpy(m_data, str.m_data);
       return *this;
   }

   ~MyString() {
       delete[] m_data;
   }

   char* get_c_str() const { return m_data; }
private:
   char* m_data;
};
size_t MyString::CCtor = 0;

int main()
{
    vector<MyString> vecStr;
    vecStr.reserve(1000); //先分配好1000個空間，不這麼作，調用的次數可能遠大於1000
    for(int i=0;i<1000;i++){
        vecStr.push_back(MyString("hello"));
    }
    cout << MyString::CCtor << endl;
}

代碼看起來挺不錯，卻發現執行了1000次拷貝構造函數，若是MyString("hello")構造出來的字符串原本就很長，構造一遍就很耗時了，最後卻還要拷貝一遍，而MyString("hello")只是臨時對象，拷貝完就沒什麼用了，這就形成了沒有意義的資源申請和釋放操做，若是可以直接使用臨時對象已經申請的資源，既能節省資源，又能節省資源申請和釋放的時間。而C++11新增長的移動語義就可以作到這一點。

要實現移動語義就必須增長兩個函數：移動構造函數和移動賦值構造函數。

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

class MyString
{
public:
    static size_t CCtor; //統計調用拷貝構造函數的次數
    static size_t MCtor; //統計調用移動構造函數的次數
    static size_t CAsgn; //統計調用拷貝賦值函數的次數
    static size_t MAsgn; //統計調用移動賦值函數的次數

public:
    // 構造函數
   MyString(const char* cstr=0){
       if (cstr) {
          m_data = new char[strlen(cstr)+1];
          strcpy(m_data, cstr);
       }
       else {
          m_data = new char[1];
          *m_data = '\0';
       }
   }

   // 拷貝構造函數
   MyString(const MyString& str) {
       CCtor ++;
       m_data = new char[ strlen(str.m_data) + 1 ];
       strcpy(m_data, str.m_data);
   }
   // 移動構造函數
   MyString(MyString&& str) noexcept
       :m_data(str.m_data) {
       MCtor ++;
       str.m_data = nullptr; //再也不指向以前的資源了
   }

   // 拷貝賦值函數 =號重載
   MyString& operator=(const MyString& str){
       CAsgn ++;
       if (this == &str) // 避免自我賦值!!
          return *this;

       delete[] m_data;
       m_data = new char[ strlen(str.m_data) + 1 ];
       strcpy(m_data, str.m_data);
       return *this;
   }

   // 移動賦值函數 =號重載
   MyString& operator=(MyString&& str) noexcept{
       MAsgn ++;
       if (this == &str) // 避免自我賦值!!
          return *this;

       delete[] m_data;
       m_data = str.m_data;
       str.m_data = nullptr; //再也不指向以前的資源了
       return *this;
   }

   ~MyString() {
       delete[] m_data;
   }

   char* get_c_str() const { return m_data; }
private:
   char* m_data;
};
size_t MyString::CCtor = 0;
size_t MyString::MCtor = 0;
size_t MyString::CAsgn = 0;
size_t MyString::MAsgn = 0;
int main()
{
    vector<MyString> vecStr;
    vecStr.reserve(1000); //先分配好1000個空間
    for(int i=0;i<1000;i++){
        vecStr.push_back(MyString("hello"));
    }
    cout << "CCtor = " << MyString::CCtor << endl;
    cout << "MCtor = " << MyString::MCtor << endl;
    cout << "CAsgn = " << MyString::CAsgn << endl;
    cout << "MAsgn = " << MyString::MAsgn << endl;
}

/* 結果
CCtor = 0
MCtor = 1000
CAsgn = 0
MAsgn = 0
*/

能夠看到，移動構造函數與拷貝構造函數的區別是，拷貝構造的參數是const MyString& str，是常量左值引用，而移動構造的參數是MyString&& str，是右值引用，而MyString("hello")是個臨時對象，是個右值，優先進入移動構造函數而不是拷貝構造函數。而移動構造函數與拷貝構造不一樣，它並非從新分配一塊新的空間，將要拷貝的對象複製過來，而是"偷"了過來，將本身的指針指向別人的資源，而後將別人的指針修改成nullptr，這一步很重要，若是不將別人的指針修改成空，那麼臨時對象析構的時候就會釋放掉這個資源，"偷"也白偷了。下面這張圖能夠解釋copy和move的區別。

不用奇怪爲何能夠搶別人的資源，臨時對象的資源很差好利用也是浪費，由於生命週期原本就是很短，在你執行完這個表達式以後，它就毀滅了，充分利用資源，才能很高效。

對於一個左值，確定是調用拷貝構造函數了，可是有些左值是局部變量，生命週期也很短，能不能也移動而不是拷貝呢？C++11爲了解決這個問題，提供了std::move()方法來將左值轉換爲右值，從而方便應用移動語義。我以爲它其實就是告訴編譯器，雖然我是一個左值，可是不要對我用拷貝構造函數，而是用移動構造函數吧。。。

int main()
{
    vector<MyString> vecStr;
    vecStr.reserve(1000); //先分配好1000個空間
    for(int i=0;i<1000;i++){
        MyString tmp("hello");
        vecStr.push_back(tmp); //調用的是拷貝構造函數
    }
    cout << "CCtor = " << MyString::CCtor << endl;
    cout << "MCtor = " << MyString::MCtor << endl;
    cout << "CAsgn = " << MyString::CAsgn << endl;
    cout << "MAsgn = " << MyString::MAsgn << endl;

    cout << endl;
    MyString::CCtor = 0;
    MyString::MCtor = 0;
    MyString::CAsgn = 0;
    MyString::MAsgn = 0;
    vector<MyString> vecStr2;
    vecStr2.reserve(1000); //先分配好1000個空間
    for(int i=0;i<1000;i++){
        MyString tmp("hello");
        vecStr2.push_back(std::move(tmp)); //調用的是移動構造函數
    }
    cout << "CCtor = " << MyString::CCtor << endl;
    cout << "MCtor = " << MyString::MCtor << endl;
    cout << "CAsgn = " << MyString::CAsgn << endl;
    cout << "MAsgn = " << MyString::MAsgn << endl;
}

/* 運行結果
CCtor = 1000
MCtor = 0
CAsgn = 0
MAsgn = 0

CCtor = 0
MCtor = 1000
CAsgn = 0
MAsgn = 0
*/

下面再舉幾個例子：

MyString str1("hello"); //調用構造函數
MyString str2("world"); //調用構造函數
MyString str3(str1); //調用拷貝構造函數
MyString str4(std::move(str1)); // 調用移動構造函數、
//    cout << str1.get_c_str() << endl; // 此時str1的內部指針已經失效了！不要使用
//注意：雖然str1中的m_dat已經稱爲了空，可是str1這個對象還活着，知道出了它的做用域纔會析構！而不是move完了馬上析構
MyString str5;
str5 = str2; //調用拷貝賦值函數
MyString str6;
str6 = std::move(str2); // str2的內容也失效了，不要再使用

須要注意一下幾點：

str6 = std::move(str2)，雖然將str2的資源給了str6，可是str2並無馬上析構，只有在str2離開了本身的做用域的時候纔會析構，因此，若是繼續使用str2的m_data變量，可能會發生意想不到的錯誤。
若是咱們沒有提供移動構造函數，只提供了拷貝構造函數，std::move()會失效可是不會發生錯誤，由於編譯器找不到移動構造函數就去尋找拷貝構造函數，也這是拷貝構造函數的參數是const T&常量左值引用的緣由！
c++11中的全部容器都實現了move語義，move只是轉移了資源的控制權，本質上是將左值強制轉化爲右值使用，以用於移動拷貝或賦值，避免對含有資源的對象發生無謂的拷貝。move對於擁有如內存、文件句柄等資源的成員的對象有效，若是是一些基本類型，如int和char[10]數組等，若是使用move，仍會發生拷貝（由於沒有對應的移動構造函數），因此說move對含有資源的對象說更有意義。

universal references(通用引用)

當右值引用和模板結合的時候，就複雜了。T&&並不必定表示右值引用，它多是個左值引用又多是個右值引用。例如：

template<typename T>
void f( T&& param){
    
}
f(10);  //10是右值
int x = 10; //
f(x); //x是左值

若是上面的函數模板表示的是右值引用的話，確定是不能傳遞左值的，可是事實倒是能夠。這裏的&&是一個未定義的引用類型，稱爲universal references，它必須被初始化，它是左值引用仍是右值引用卻決於它的初始化，若是它被一個左值初始化，它就是一個左值引用；若是被一個右值初始化，它就是一個右值引用。

注意：只有當發生自動類型推斷時（如函數模板的類型自動推導，或auto關鍵字），&&纔是一個universal references。

例如：

template<typename T>
void f( T&& param); //這裏T的類型須要推導，因此&&是一個 universal references

template<typename T>
class Test {
  Test(Test&& rhs); //Test是一個特定的類型，不須要類型推導，因此&&表示右值引用  
};

void f(Test&& param); //右值引用

//複雜一點
template<typename T>
void f(std::vector<T>&& param); //在調用這個函數以前，這個vector<T>中的推斷類型
//已經肯定了，因此調用f函數的時候沒有類型推斷了，因此是 右值引用

template<typename T>
void f(const T&& param); //右值引用
// universal references僅僅發生在 T&& 下面，任何一點附加條件都會使之失效

因此最終仍是要看T被推導成什麼類型，若是T被推導成了string，那麼T&&就是string&&，是個右值引用，若是T被推導爲string&，就會發生相似string& &&的狀況，對於這種狀況，c++11增長了引用摺疊的規則，總結以下：

全部的右值引用疊加到右值引用上仍然使一個右值引用。
全部的其餘引用類型之間的疊加都將變成左值引用。

如上面的T& &&其實就被摺疊成了個string &，是一個左值引用。

#include <iostream>
#include <type_traits>
#include <string>
using namespace std;

template<typename T>
void f(T&& param){
    if (std::is_same<string, T>::value)
        std::cout << "string" << std::endl;
    else if (std::is_same<string&, T>::value)
        std::cout << "string&" << std::endl;
    else if (std::is_same<string&&, T>::value)
        std::cout << "string&&" << std::endl;
    else if (std::is_same<int, T>::value)
        std::cout << "int" << std::endl;
    else if (std::is_same<int&, T>::value)
        std::cout << "int&" << std::endl;
    else if (std::is_same<int&&, T>::value)
        std::cout << "int&&" << std::endl;
    else
        std::cout << "unkown" << std::endl;
}

int main()
{
    int x = 1;
    f(1); // 參數是右值 T推導成了int, 因此是int&& param, 右值引用
    f(x); // 參數是左值 T推導成了int&, 因此是int&&& param, 摺疊成 int&,左值引用
    int && a = 2;
    f(a); //雖然a是右值引用，但它仍是一個左值， T推導成了int&
    string str = "hello";
    f(str); //參數是左值 T推導成了string&
    f(string("hello")); //參數是右值， T推導成了string
    f(std::move(str));//參數是右值， T推導成了string
}

因此，概括一下，傳遞左值進去，就是左值引用，傳遞右值進去，就是右值引用。如它的名字，這種類型確實很"通用"，下面要講的完美轉發，就利用了這個特性。

完美轉發

所謂轉發，就是經過一個函數將參數繼續轉交給另外一個函數進行處理，原參數多是右值，多是左值，若是還能繼續保持參數的原有特徵，那麼它就是完美的。

void process(int& i){
    cout << "process(int&):" << i << endl;
}
void process(int&& i){
    cout << "process(int&&):" << i << endl;
}

void myforward(int&& i){
    cout << "myforward(int&&):" << i << endl;
    process(i);
}

int main()
{
    int a = 0;
    process(a); //a被視爲左值 process(int&):0
    process(1); //1被視爲右值 process(int&&):1
    process(move(a)); //強制將a由左值改成右值 process(int&&):0
    myforward(2);  //右值通過forward函數轉交給process函數，卻稱爲了一個左值，
    //緣由是該右值有了名字  因此是 process(int&):2
    myforward(move(a));  // 同上，在轉發的時候右值變成了左值  process(int&):0
    // forward(a) // 錯誤用法，右值引用不接受左值
}

上面的例子就是不完美轉發，而c++中提供了一個std::forward()模板函數解決這個問題。將上面的myforward()函數簡單改寫一下：

void myforward(int&& i){
    cout << "myforward(int&&):" << i << endl;
    process(std::forward<int>(i));
}

myforward(2); // process(int&&):2

上面修改事後仍是不完美轉發，myforward()函數可以將右值轉發過去，可是並不可以轉發左值，解決辦法就是藉助universal references通用引用類型和std::forward()模板函數共同實現完美轉發。例子以下：

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

void RunCode(int &&m) {
    cout << "rvalue ref" << endl;
}
void RunCode(int &m) {
    cout << "lvalue ref" << endl;
}
void RunCode(const int &&m) {
    cout << "const rvalue ref" << endl;
}
void RunCode(const int &m) {
    cout << "const lvalue ref" << endl;
}

// 這裏利用了universal references，若是寫T&,就不支持傳入右值，而寫T&&，既能支持左值，又能支持右值
template<typename T>
void perfectForward(T && t) {
    RunCode(forward<T> (t));
}

template<typename T>
void notPerfectForward(T && t) {
    RunCode(t);
}

int main()
{
    int a = 0;
    int b = 0;
    const int c = 0;
    const int d = 0;

    notPerfectForward(a); // lvalue ref
    notPerfectForward(move(b)); // lvalue ref
    notPerfectForward(c); // const lvalue ref
    notPerfectForward(move(d)); // const lvalue ref

    cout << endl;
    perfectForward(a); // lvalue ref
    perfectForward(move(b)); // rvalue ref
    perfectForward(c); // const lvalue ref
    perfectForward(move(d)); // const rvalue ref
}

上面的代碼測試結果代表，在universal references和std::forward的合做下，可以完美的轉發這4種類型。

emplace_back減小內存拷貝和移動

咱們以前使用vector通常都喜歡用push_back()，由上文可知容易發生無謂的拷貝，解決辦法是爲本身的類增長移動拷貝和賦值函數，但其實還有更簡單的辦法！就是使用emplace_back()替換push_back()，以下面的例子：

#include <iostream>
#include <cstring>
#include <vector>
using namespace std;

class A {
public:
    A(int i){
//        cout << "A()" << endl;
        str = to_string(i);
    }
    ~A(){}
    A(const A& other): str(other.str){
        cout << "A&" << endl;
    }

public:
    string str;
};

int main()
{
    vector<A> vec;
    vec.reserve(10);
    for(int i=0;i<10;i++){
        vec.push_back(A(i)); //調用了10次拷貝構造函數
//        vec.emplace_back(i);  //一次拷貝構造函數都沒有調用過
    }
    for(int i=0;i<10;i++)
        cout << vec[i].str << endl;
}

能夠看到效果是明顯的，雖然沒有測試時間，可是確實能夠減小拷貝。emplace_back()能夠直接經過構造函數的參數構造對象，但前提是要有對應的構造函數。

對於map和set，可使用emplace()。基本上emplace_back()對應push_bakc(), emplce()對應insert()。

移動語義對swap()函數的影響也很大，以前實現swap可能須要三次內存拷貝，而有了移動語義後，就能夠實現高性能的交換函數了。

template <typename T>
void swap(T& a, T& b)
{
    T tmp(std::move(a));
    a = std::move(b);
    b = std::move(tmp);
}

若是T是可移動的，那麼整個操做會很高效，若是不可移動，那麼就和普通的交換函數是同樣的，不會發生什麼錯誤，很安全。

總結

由兩種值類型，左值和右值。
有三種引用類型，左值引用、右值引用和通用引用。左值引用只能綁定左值，右值引用只能綁定右值，通用引用由初始化時綁定的值的類型肯定。
左值和右值是獨立於他們的類型的，右值引用多是左值多是右值，若是這個右值引用已經被命名了，他就是左值。
引用摺疊規則：全部的右值引用疊加到右值引用上仍然是一個右值引用，其餘引用摺疊都爲左值引用。當T&&爲模板參數時，輸入左值，它將變成左值引用，輸入右值則變成具名的右值應用。
移動語義能夠減小無謂的內存拷貝，要想實現移動語義，須要實現移動構造函數和移動賦值函數。
std::move()將一個左值轉換成一個右值，強制使用移動拷貝和賦值函數，這個函數自己並無對這個左值什麼特殊操做。
std::forward()和universal references通用引用共同實現完美轉發。
用empalce_back()替換push_back()增長性能。