[[337215]]

眾所周知C++11新增了右值引用，談右值引用我們也可以擴展一些相關概念：

•  左值
•  右值
•  純右值
•  將亡值
•  左值引用
•  右值引用
•  移動語義
•  完美轉發
•  返回值優化

程序喵下面會一一介紹：

左值、右值

概念1：

左值：可以放到等號左邊的東西叫左值。

右值：不可以放到等號左邊的東西就叫右值。

概念2：

左值：可以取地址并且有名字的東西就是左值。

右值：不能取地址的沒有名字的東西就是右值。

舉例： 

int a = b + c; 

a是左值，有變量名，可以取地址，也可以放到等號左邊, 表達式b+c的返回值是右值，沒有名字且不能取地址，&(b+c)不能通過編譯，而且也不能放到等號左邊。 

int a = 4; // a是左值，4作為普通字面量是右值 

左值一般有：

•  函數名和變量名
•  返回左值引用的函數調用
•  前置自增自減表達式++i、--i
•  由賦值表達式或賦值運算符連接的表達式(a=b, a += b等)
•  解引用表達式*p
•  字符串字面值"abcd"

純右值、將亡值

純右值和將亡值都屬于右值。

純右值

運算表達式產生的臨時變量、不和對象關聯的原始字面量、非引用返回的臨時變量、lambda表達式等都是純右值。

舉例：

•  除字符串字面值外的字面值
•  返回非引用類型的函數調用
•  后置自增自減表達式i++、i--
•  算術表達式(a+b, a*b, a&&b, a==b等)
•  取地址表達式等(&a)

將亡值

將亡值是指C++11新增的和右值引用相關的表達式，通常指將要被移動的對象、T&&函數的返回值、std::move函數的返回值、轉換為T&&類型轉換函數的返回值，將亡值可以理解為即將要銷毀的值，通過“盜取”其它變量內存空間方式獲取的值，在確保其它變量不再被使用或者即將被銷毀時，可以避免內存空間的釋放和分配，延長變量值的生命周期，常用來完成移動構造或者移動賦值的特殊任務。

舉例： 

class A {  
    xxx;  
};  
A a;  
auto c = std::move(a); // c是將亡值  
auto d = static_cast<A&&>(a); // d是將亡值 

左值引用、右值引用

根據名字大概就可以猜到意思，左值引用就是對左值進行引用的類型，右值引用就是對右值進行引用的類型，他們都是引用，都是對象的一個別名，并不擁有所綁定對象的堆存，所以都必須立即初始化。 

type &name = exp; // 左值引用  
type &&name = exp; // 右值引用 

左值引用

看代碼： 

int a = 5;  
int &b = a; // b是左值引用  
b = 4;  
int &c = 10; // error，10無法取地址，無法進行引用  
const int &d = 10; // ok，因為是常引用，引用常量數字，這個常量數字會存儲在內存中，可以取地址 

可以得出結論：對于左值引用，等號右邊的值必須可以取地址，如果不能取地址，則會編譯失敗，或者可以使用const引用形式，但這樣就只能通過引用來讀取輸出，不能修改數組，因為是常量引用。

右值引用

如果使用右值引用，那表達式等號右邊的值需要時右值，可以使用std::move函數強制把左值轉換為右值。 

int a = 4;  
int &&b = a; // error, a是左值  
int &&c = std::move(a); // ok 

移動語義

談移動語義前，我們首先需要了解深拷貝與淺拷貝的概念

深拷貝、淺拷貝

直接拿代碼舉例: 

class A {  
public:  
    A(int size) : size_(size) {  
        data_ = new int[size];  
    }  
    A(){}  
    A(const A& a) {  
        size_ = a.size_;  
        data_ = a.data_;  
        cout << "copy " << endl;  
    }  
    ~A() {  
        delete[] data_;  
    }  
    int *data_;  
    int size_;  
};  
int main() {  
    A a(10);  
    A b = a;  
    cout << "b " << b.data_ << endl;  
    cout << "a " << a.data_ << endl;  
    return 0;  
} 

上面代碼中，兩個輸出的是相同的地址，a和b的data_指針指向了同一塊內存，這就是淺拷貝，只是數據的簡單賦值，那再析構時data_內存會被釋放兩次，導致程序出問題，這里正常會出現double free導致程序崩潰的，但是不知道為什么我自己測試程序卻沒有崩潰，能力有限，沒搞明白，無論怎樣，這樣的程序肯定是有隱患的，如何消除這種隱患呢，可以使用如下深拷貝： 

class A {  
public:  
    A(int size) : size_(size) {  
        data_ = new int[size];  
    }  
    A(){}  
    A(const A& a) {  
        size_ = a.size_;  
        data_ = new int[size_]; 
        cout << "copy " << endl;  
    }  
    ~A() {  
        delete[] data_;  
    }  
    int *data_;  
    int size_;  
};  
int main() {  
    A a(10);  
    A b = a;  
    cout << "b " << b.data_ << endl;  
    cout << "a " << a.data_ << endl;  
    return 0;  
} 

深拷貝就是再拷貝對象時，如果被拷貝對象內部還有指針引用指向其它資源，自己需要重新開辟一塊新內存存儲資源，而不是簡單的賦值。

聊完了深拷貝淺拷貝，可以聊聊移動語義啦：

移動語義，在程序喵看來可以理解為轉移所有權，之前的拷貝是對于別人的資源，自己重新分配一塊內存存儲復制過來的資源，而對于移動語義，類似于轉讓或者資源竊取的意思，對于那塊資源，轉為自己所擁有，別人不再擁有也不會再使用，通過C++11新增的移動語義可以省去很多拷貝負擔，怎么利用移動語義呢，是通過移動構造函數。 

class A {  
public:  
    A(int size) : size_(size) {  
        data_ = new int[size];  
    }  
    A(){}  
    A(const A& a) {  
        size_ = a.size_;  
        data_ = new int[size_];  
        cout << "copy " << endl;  
    }  
    A(A&& a) {  
        this->data_ = a.data_; 
         a.data_ = nullptr;  
        cout << "move " << endl;  
    }  
    ~A() {  
        if (data_ != nullptr) {  
         delete[] data_;  
        }  
    }  
    int *data_;  
    int size_; 
 };  
int main() {  
    A a(10);  
    A b = a;  
    A c = std::move(a); // 調用移動構造函數  
    return 0;  
} 

如果不使用std::move()，會有很大的拷貝代價，使用移動語義可以避免很多無用的拷貝，提供程序性能，C++所有的STL都實現了移動語義，方便我們使用。例如： 

std::vector<string> vecs;  
...  
std::vector<string> vecm = std::move(vecs); // 免去很多拷貝 

注意：移動語義僅針對于那些實現了移動構造函數的類的對象，對于那種基本類型int、float等沒有任何優化作用，還是會拷貝，因為它們實現沒有對應的移動構造函數。

完美轉發

完美轉發指可以寫一個接受任意實參的函數模板，并轉發到其它函數，目標函數會收到與轉發函數完全相同的實參，轉發函數實參是左值那目標函數實參也是左值，轉發函數實參是右值那目標函數實參也是右值。那如何實現完美轉發呢，答案是使用std::forward()。 

void PrintV(int &t) {  
    cout << "lvalue" << endl;  
}  
void PrintV(int &&t) {  
    cout << "rvalue" << endl;  
}  
template<typename T>  
void Test(T &&t) {  
    PrintV(t);  
    PrintV(std::forward<T>(t));   
    PrintV(std::move(t));  
}  
int main() {  
    Test(1); // lvalue rvalue rvalue  
    int a = 1;  
    Test(a); // lvalue lvalue rvalue  
    Test(std::forward<int>(a)); // lvalue rvalue rvalue  
    Test(std::forward<int&>(a)); // lvalue lvalue rvalue  
    Test(std::forward<int&&>(a)); // lvalue rvalue rvalue  
    return 0;  
} 

分析

•  Test(1)：1是右值，模板中T &&t這種為萬能引用，右值1傳到Test函數中變成了右值引用，但是調用PrintV()時候，t變成了左值，因為它變成了一個擁有名字的變量，所以打印lvalue，而PrintV(std::forward<T>(t))時候，會進行完美轉發，按照原來的類型轉發，所以打印rvalue，PrintV(std::move(t))毫無疑問會打印rvalue。
•  Test(a)：a是左值，模板中T &&這種為萬能引用，左值a傳到Test函數中變成了左值引用，所以有代碼中打印。
•  Test(std::forward<T>(a))：轉發為左值還是右值，依賴于T，T是左值那就轉發為左值，T是右值那就轉發為右值。

返回值優化

返回值優化(RVO)是一種C++編譯優化技術，當函數需要返回一個對象實例時候，就會創建一個臨時對象并通過復制構造函數將目標對象復制到臨時對象，這里有復制構造函數和析構函數會被多余的調用到，有代價，而通過返回值優化，C++標準允許省略調用這些復制構造函數。

那什么時候編譯器會進行返回值優化呢?

•  return的值類型與函數的返回值類型相同
•  return的是一個局部對象

看幾個例子:

示例1： 

std::vector<int> return_vector(void) {  
    std::vector<int> tmp {1,2,3,4,5};  
    return tmp;  
}  
std::vector<int> &&rval_ref = return_vector(); 

不會觸發RVO，拷貝構造了一個臨時的對象，臨時對象的生命周期和rval_ref綁定，等價于下面這段代碼： 

const std::vector<int>& rval_ref = return_vector(); 

示例2： 

std::vector<int>&& return_vector(void) {  
    std::vector<int> tmp {1,2,3,4,5};  
    return std::move(tmp); 
}  
std::vector<int> &&rval_ref = return_vector(); 

這段代碼會造成運行時錯誤，因為rval_ref引用了被析構的tmp。講道理來說這段代碼是錯的，但我自己運行過程中卻成功了，我沒有那么幸運，這里不糾結，繼續向下看什么時候會觸發RVO。

示例3： 

std::vector<int> return_vector(void) {  
    std::vector<int> tmp {1,2,3,4,5};  
    return std::move(tmp);  
}  
std::vector<int> &&rval_ref = return_vector(); 

和示例1類似，std::move一個臨時對象是沒有必要的，也會忽略掉返回值優化。

最好的代碼： 

std::vector<int> return_vector(void) {  
    std::vector<int> tmp {1,2,3,4,5};  
    return tmp;  
}  
std::vector<int> rval_ref = return_vector(); 

這段代碼會觸發RVO，不拷貝也不移動，不生成臨時對象。