**轉載 自 https://www.jianshu.com/p/d19fc8447eaa**

c++中引入了`右值引用`和`移動語義`，可以避免無謂的複製，提高程式效能。有點難理解，於是花時間整理一下自己的理解。

## 左值、右值

`C++`中所有的值都必然屬於左值、右值二者之一。左值是指表示式結束後依然存在的*持久化物件*，右值是指表示式結束時就不再存在的*臨時物件*。所有的具名變數或者物件都是左值，而右值不具名。很難得到左值和右值的真正定義，但是有一個可以區分左值和右值的便捷方法：**看能不能對錶達式取地址，如果能，則為左值，否則為右值**。

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

而將亡值則是`c++11`新增的和右值引用相關的表示式，這樣的表示式通常時將要移動的物件、`T&&`函式返回值、`std::move()`函式的返回值等，

不懂將亡值和純右值的區別其實沒關係，統一看作右值即可，不影響使用。

示例：

```
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`是一個具體型別：

1.  左值引用， 使用 `T&`, 只能繫結**左值**
2.  右值引用， 使用 `T&&`， 只能繫結**右值**
3.  常量左值， 使用 `const T&`, 既可以繫結**左值**又可以繫結**右值**
4.  已命名的**右值引用**，編譯器會認為是個**左值**
5.  編譯器有返回值最佳化，但不要過於依賴

## 移動構造和移動賦值

回顧一下如何用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的區別。

![image](https://upload-images.jianshu.io/upload_images/4427263-81a47fdc9b8d9e98.png?imageMogr2/auto-orient/strip|imageView2/2/w/264/format/webp)

不用奇怪為什麼可以搶別人的資源，臨時物件的資源不好好利用也是浪費，因為生命週期本來就是很短，在你執行完這個表示式之後，它就毀滅了，充分利用資源，才能很高效。

對於一個左值，肯定是呼叫複製建構函式了，但是有些左值是區域性變數，生命週期也很短，能不能也移動而不是複製呢？`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的內容也失效了，不要再使用

```

需要注意一下幾點：

1.  `str6 = std::move(str2)`，雖然將`str2`的資源給了`str6`，但是`str2`並沒有立刻析構，只有在`str2`離開了自己的作用域的時候才會析構，所以，如果繼續使用`str2`的`m_data`變數，可能會發生意想不到的錯誤。
2.  如果我們沒有提供移動建構函式，只提供了複製建構函式，`std::move()`會失效但是不會發生錯誤，因為編譯器找不到移動建構函式就去尋找複製建構函式，也這是複製建構函式的引數是`const T&`常量左值引用的原因！
3.  `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`增加了引用摺疊的規則，總結如下：

1.  所有的右值引用疊加到右值引用上仍然使一個右值引用。
2.  所有的其他引用型別之間的疊加都將變成左值引用。

如上面的`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 rel="nofollow"> 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()`增加效能。

## TODO

*   對模板型別自動推導還不太熟悉，繼續學習[Effective Modern C++](https://book.douban.com/subject/25923597/)。
*   `std::move()和std::forward()`好像實現的並不複雜，有機會弄明白實現原理。</typename></a></vector></cstring></iostream></typename></t></typename></vector></cstring></iostream></int></int></int></int></string></string></string></typename></string></type_traits></iostream></typename></t></t></typename></typename></typename></typename></mystring></mystring></mystring></vector></cstring></iostream></mystring></vector></cstring></iostream></iostream>

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

相關文章