右值引用

什麼是lvalue， 什麼是rvalue？

lvalue： 具有儲存性質的物件，即lvalue物件，是指要實際佔用記憶體空間、有記憶體地址的那些實體物件，例如：變數(variables)、函式、函式指標等。

rvalue：相比較於lvalue就是所謂的沒有儲存性質的物件， 也就是臨時物件。

也可以這樣理解：

lvalue： 通過它能夠找到記憶體中存放的變數（location value），位於賦值運算子左，可以賦值。
rvalue：存放在lvalue對應的記憶體中的東西（register value）， 位於賦值運算子左，不可賦值。

對左值和右值的一個最常見的誤解是：等號左邊的就是左值，等號右邊的就是右值。左值和右值都是針對表示式而言的，左值是指表示式結束後依然存在的持久物件，右值是指表示式結束時就不再存在的臨時物件

例子：

int a = 10;
int b = 20;
int *pFlag = &a;
vector<int> vctTemp;
vctTemp.push_back(1);
string str1 = "hello ";
string str2 = "world";
const int &m = 1;

  請問，a，b, a+b, a++, ++a, pFlag, *pFlag, vctTemp[0], 100, string("hello"), str1, str1+str2, m分別是左值還是右值？、

• a和b都是持久物件（可以對其取地址），是左值；
• a+b是臨時物件（不可以對其取地址），是右值；
• a++是先取出持久物件a的一份拷貝，再使持久物件a的值加1，最後返回那份拷貝，而那份拷貝是臨時物件（不可以對其取地址），故其是右值；
• ++a則是使持久物件a的值加1，並返回那個持久物件a本身（可以對其取地址），故其是左值；
• pFlag和*pFlag都是持久物件（可以對其取地址），是左值；
• vctTemp[0]呼叫了過載的[]操作符，而[]操作符返回的是一個int &，為持久物件（可以對其取地址），是左值；
• 100和string("hello")是臨時物件（不可以對其取地址），是右值；
• str1是持久物件（可以對其取地址），是左值；
• str1+str2是呼叫了+操作符，而+操作符返回的是一個string（不可以對其取地址），故其為右值；
•  m是一個常量引用，引用到一個右值，但引用本身是一個持久物件（可以對其取地址），為左值。
  

    //先來看一個例子：

    //stack 分配4位元組，並設定值5.
    int a = 5;

再看一個例子：

    int* p = NULL;
    p = new int(5);

這裡分配了兩個記憶體， 一個是在stack上（p， 地址為&p）， 一個是在heap上（*p， 地址為p）

對於p：  lvalue為&p（p的地址）， rvalue為&p地址上的值

對於*p： lvalue為p（*p的地址），lvalue為p地址上的值

左值引用

左值引用根據其修飾符的不同，可以分為非常量左值引用和常量左值引用。

int a = 5；
int& v1 = a；
const int& v2 = 5；

非常量左值引用

只能繫結到非常量左值，不能繫結到常量左值、非常量右值和常量右值。

    int a = 5;
    const int b = 5;

    int& v1 = a; // 繫結到非常量左值
    int& v2 = 5; // 常量右值， compile error
    int& v3 = b; // 常量左值， compile error
    int& v4 = a + b; // 非常量右值， compile error, a + b為臨時物件

如果允許繫結到常量左值和常量右值，則非常量左值引用可以用於修改常量左值和常量右值，這明顯違反了其常量的含義。

如果允許繫結到非常量右值，則會導致非常危險的情況出現，因為非常量右值是一個臨時物件，非常量左值引用可能會使用一個已經被銷燬了的臨時物件。

常量左值引用

可以繫結到所有型別的值，包括非常量左值、常量左值、非常量右值和常量右值。

    int a = 5;
    const int b = 5;

    const int& v1 = a; // 繫結到非常量左值   
    const int& v2 = 5; // 常量右值
    const int& v3 = b; // 常量左值
    const int& v4 = a + b; // 非常量右值， a + b為臨時物件

可以看出，使用左值引用時，我們無法區分出繫結的是否是非常量右值的情況（無法區分上面的v2，v4）

C++11 增加一個新的非常數引用(reference)型別，稱作右值引用(R-value reference)，標記為T &&。右值引用所引用的臨時物件可以在該臨時物件被初始化之後做修改，這是為了允許 move 語義。

右值引用

右值引用根據其修飾符的不同，也可以分為非常量右值引用和常量右值引用。

非常量右值引用

只能繫結到非常量右值，不能繫結到非常量左值、常量左值和常量右值。

    int a = 5;
    const int b = 5;

    int&& v1 = 5;
    int&& v2 = a;   //compile error
    int&& v3 = b;   //compile error
    int&& v4 = a + b;

如果允許繫結到非常量左值，則可能會錯誤地竊取一個持久物件的資料，而這是非常危險的；

如果允許繫結到常量左值和常量右值，則非常量右值引用可以用於修改常量左值和常量右值，這明顯違反了其常量的含義。

 常量右值引用

可以繫結到非常量右值和常量右值，不能繫結到非常量左值和常量左值

    int a = 5;
    const int b = 5;

    const int&& v1 = 5;
    const int&& v2 = a; //compile error
    const int&& v3 = b; //compile error
    const int&& v4 = a + b;

注： 基於安全考慮，具有名字的宣告為右值的引數不會被認定為右值：

bool is_r_value(int &&) { return true; }
bool is_r_value(const int &) { return false; }

void test(int && i)
{
    bool isRValue = is_r_value(i); // i 為具名變數，即使被宣告成右值也不會被認定是右值。false
    isRValue = is_r_value(std::move<int&>(i)); // 使用 std::move<T>() 取得右值。 true
}

move語義

那麼，為什麼要對非常量右值進行區分呢，區分出來了又有什麼好處呢？這就牽涉到C++中一個著名的效能問題——拷貝臨時物件。考慮下面的程式碼：

vector<int> getVector()
{
 vector<int> v;
 v.push_back(1);
 v.push_back(2);

 v.push_back(3);

 v.push_back(4);

儘管有些編譯器可以採用RVO（Return Value Optimization）來進行優化，但優化工作只在某些特定條件下才能進行。可以看到，上面很普通的一個函式呼叫，由於存在臨時物件的拷貝，導致了額外的兩次拷貝建構函式和解構函式的開銷。當然，我們也可以修改函式的形式為void getVector(vector<int> &v)，但這並不一定就是我們需要的形式

另外，考慮下面字串的連線操作：

 string s1("hello");
 string s = s1 + "a" + "b" + "c" + "d" + "e";

在對s進行初始化時，會產生大量的臨時物件，並涉及到大量字串的拷貝操作，這顯然會影響程式的效率和效能。怎麼解決這個問題呢？如果我們能確定某個值是一個非常量右值（或者是一個以後不會再使用的左值），則我們在進行臨時物件的拷貝時，可以不用拷貝實際的資料，而只是“竊取”指向實際資料的指標（類似於STL中的auto_ptr，會轉移所有權）。

在 C++11，一個std::vector的 "move 建構函式" 對某個vector的右值引用可以單純地從右值複製其內部 C-style 陣列的指標到新的 vector，然後留下空的右值。這個操作不需要陣列的複製，而且空的臨時物件的析構也不會摧毀記憶體。傳回vector臨時物件的函式不需要顯式地傳回std::vector<T>&&。如果vector沒有 move 建構函式，那麼複製建構函式將被呼叫，以const std::vector<T> &的正常形式。 如果它確實有 move 建構函式，那麼就會呼叫 move 建構函式，這能夠免除大幅的記憶體配置。