問題背景

1. #include <iostream>
2. usingnamespace std;  
3. vector<int> doubleValues (const vector<int>& v)  
4. {  
5.     vector<int> new_values( v.size() );  
6.     for (auto itr = new_values.begin(), end_itr = new_values.end(); itr != end_itr; ++itr )  
7.     {  
8.         new_values.push_back( 2 * *itr );  
9.     }  
10.     return new_values;  
11. }  
12. int main()  
13. {  
14.     vector<int> v;  
15.     for ( int i = 0; i < 100; i++ )  
16.     {  
17.         v.push_back( i );  
18.     }  
19.     v = doubleValues( v );  
20. }  

先來分析一下上述程式碼的執行過程。

1. vector<int> v;  
2. for ( int i = 0; i < 100; i++ )  
3. {  
4.     v.push_back( i );  
5. }  

以上5行語句在棧上新建了一個vector的例項，並在裡面放了100個數。

1. v = doubleValues( v )  

這條語句呼叫函式doubleValues,函式的引數型別的const reference，常量引用，那麼在實參形參結合的時候並不會將v複製一份，而是直接傳遞引用。所以在函式體內部使用的v就是剛才建立的那個vector的例項。

但是

1. vector<int> new_values( v.size() );  

這條語句新建了一個vector的例項new_values，並且複製了v的所有內容。但這是合理的，因為我們這是要將一個vector中所有的值翻倍，所以我們不應該改變原有的vector的內容。

1. v = doubleValues( v );  

函式執行完之後，new_values中放了翻倍之後的數值，作為函式的返回值返回。但是注意，這個時候doubleValue(v)的呼叫已經結束。開始執行 = 的語義。

賦值的過程實際上是將返回的vector<int>複製一份放入新的記憶體空間，然後改變v的地址，讓v指向這篇記憶體空間。總的來說，我們剛才新建的那個vector又被複制了一遍。

但我們其實希望v能直接得到函式中複製好的那個vector。在C++11之前，我們只能通過傳遞指標來實現這個目的。但是指標用多了非常不爽。我們希望有更簡單的方法。這就是我們為什麼要引入右值引用和轉移建構函式的原因。

左值和右值

在說明左值的定義之前，我們可以先看幾個左值的例子。

1. int a;  
2. a = 1; // here, a is an lvalue

上述的a就是一個左值。 臨時變數可以做左值。同樣函式的返回值也可以做左值。

1. int x;  
2. int& getRef ()   
3. {  
4.         return x;  
5. }  
6. getRef() = 4;  

以上就是函式返回值做左值的例子。 其實左值就是指一個擁有地址的表示式。換句話說，左值指向的是一個穩定的記憶體空間（即可以是在堆上由使用者管理的記憶體空間，也可以是在棧上，離開了一個block就被銷燬的記憶體空間）。上面第二個例子，getRef返回的就是一個全域性變數（建立在堆上），所以可以當做左值使用。 與此相反，右值指向的不是一個穩定的記憶體空間，而是一個臨時的空間。比如說下面的例子：

1. int x;  
2. int getVal ()  
3. {  
4.     return x;  
5. }  
6. getVal();  

這裡getVal()得到的就是臨時的一個值，沒法對它進行賦值。
下面的語句就是錯的。

1. getVal() = 1;//compilation error

所以右值只能夠用來給其他的左值賦值。

右值引用

在C++11中，你可以使用const的左值引用來繫結一個右值，比如說：

1. constint& val = getVal();//right
2. int& val = getVal();//error

因為左值引用並不是左值，並沒有建立一片穩定的記憶體空間，所以如果不是const的話你就可以對它的內容進行修改，而右值又不能進行賦值，所以就會出錯。因此只能用const的左值引用來繫結一個右值。 在C++11中，我們可以顯示地使用“右值引用”來繫結一個右值,語法是"&&"。因為指定了是右值引用，所以無論是否const都是正確的。

1. const string&& name = getName(); // ok
2. string&& name = getName(); // also ok 

有了這個功能，我們就可以對原來的左值引用的函式進行過載，過載的函式引數使用右值引用。比如下面這個例子：

1. printReference (const String& str)  
2. {  
3.         cout << str;  
4. }  
5. printReference (String&& str)  
6. {  
7.         cout << str;  
8. }  

可以這麼呼叫它。

1. string me( "alex" );  
2. printReference(  me ); // 呼叫第一函式，引數為左值常量引用
3. printReference( getName() ); 呼叫第二個函式，引數為右值引用。  

好了，現在我們知道C++11可以進行顯示的右值引用了。但是我們如果用它來解決一開始那個複製的問題呢？ 這就要引入與此相關的另一個新特性，轉移建構函式和轉移賦值運算子

轉移建構函式和轉移賦值運算子

假設我們定義了一個ArrayWrapper的類，這個類對陣列進行了封裝。

1. class ArrayWrapper  
2. {  
3.     public:  
4.         ArrayWrapper (int n)  
5.             : _p_vals( newint[ n ] )  
6.             , _size( n )  
7.         {}  
8.         // copy constructor
9.         ArrayWrapper (const ArrayWrapper& other)  
10.             : _p_vals( newint[ other._size  ] )  
11.             , _size( other._size )  
12.         {  
13.             for ( int i = 0; i < _size; ++i )  
14.             {  
15.                 _p_vals[ i ] = other._p_vals[ i ];  
16.             }  
17.         }  
18.         ~ArrayWrapper ()  
19.         {  
20.             delete [] _p_vals;  
21.         }  
22.     private:  
23.     int *_p_vals;  
24.     int _size;  
25. };  

我們可以看到，這個類的拷貝建構函式顯示新建了一片記憶體空間，然後又對傳進來的左值引用進行了複製。 如果傳進來的實際引數是一個右值（馬上就銷燬），我們自然希望能夠繼續使用這個右值的空間，這樣可以節省申請空間和複製的時間。 我們可以使用轉移建構函式實現這個功能：

1. class ArrayWrapper  
2. {  
3. public:  
4.     // default constructor produces a moderately sized array
5.     ArrayWrapper ()  
6.         : _p_vals( newint[ 64 ] )  
7.         , _size( 64 )  
8.     {}  
9.     ArrayWrapper (int n)  
10.         : _p_vals( newint[ n ] )  
11.         , _size( n )  
12.     {}  
13.     // move constructor
14.     ArrayWrapper (ArrayWrapper&& other)  
15.         : _p_vals( other._p_vals  )  
16.         , _size( other._size )  
17.     {  
18.         other._p_vals = NULL;  
19.     }  
20. 相關推薦

    C++11 新特性之右值引用和轉移建構函式

    問題背景 #include <iostream> usingnamespace std;   vector<int> doubleValues (const vector<int>& v)   {  

    C++11新特性之右值引用

    什麼是左值，什麼是右值？ An l-value expression refers to an object's identity, whereas a r-value expression refers to an object's value. 左值標識物件的身份，右值標識物件的值（我把它理解為被物

    C++ 面試 C++ 11 新特性之右值引用與移動

    右值引用 什麼是左值，什麼是右值，簡單說左值可以賦值，右值不可以賦值。以下面程式碼為例，“ A a = getA();”該語句中a是左值，getA()的返回值是右值。 #include <iostream> class A { public

    C++11嚐鮮：右值引用和轉發型引用

    右值引用 為了解決移動語義及完美轉發問題，C++11標準引入了右值引用（rvalue reference）這一重要的新概念。右值引用採用T&&這一語法形式，比傳統的引用T&（如今被稱作左值引用 lvalue reference）多一個&。

    深入淺出C++11（3） -- 右值引用和move語義

    右值引用 什麼是lvalue， 什麼是rvalue？ lvalue： 具有儲存性質的物件，即lvalue物件，是指要實際佔用記憶體空間、有記憶體地址的那些實體物件，例如：變數(variables)、函式、函式指標等。 rvalue：相比較於lvalue就是所謂的沒有儲存性質

    C++11特性之右值引用

    wap 移動語義 ostream 更改 let 強制轉換 生命期 不能 size title: 右值引用與移動語義 date: 2019-2-24 15:06:34 tags: 學習 categories: 日常 --- 什麽是右值？在C++中，一種被廣泛認可的說法是，不

    C++11新特性之 std::forward(完美轉發)（轉）

    tails array sin .com std utili res details calling 我們也要時刻清醒，有時候右值會轉為左值，左值會轉為右值。 （也許“轉換”二字用的不是很準確） 如果我們要避免這種轉換呢？ 我們需要一種方法能按照參數原來的類型轉發到另一個函

    c++11：物件移動 & 右值引用 & 移動建構函式

    一、概述 c++ 11 新標準中最主要的特徵是可以移動而非拷貝物件的能力。很多情況下，物件拷貝後就會立即被銷燬。 在這些情況下，移動而非拷貝物件會大幅度提升效能。 在舊 C++ 標準中，沒有直接的方法移動物件。因此，即使不必要拷貝物件的情況下，我們也不得不拷貝。如果物件本身要求

    [轉] c++11 int&& 右值引用

    [轉自 http://blog.csdn.net/yuanwang1986/article/details/8666459 ] C++ 11中引入的右值引用正好可用於標識一個非常量右值。C++ 11中用&表示左值引用，用&&表示右值引用，如： int &&a = 1

    C++11新特性之十：enable_shared_from_this

     enable_shared_from_this是一個模板類，定義於標頭檔案<memory>，其原型為： template< class T > class enable_shared_from_this;        std::enable_s

    C++11新特性之final override識別符號

    final: 　　final修飾符可用於修飾類，放在類名後面，被final修飾符修飾的類不能被繼承。示例程式碼： // 正確的示範 #include <iostream> class A { public: void show_a_info() { st

    C++11新特性之final override標識符

    並不會 ptr 輸出 erro 子類 main count color 特性 final: 　　final修飾符可用於修飾類，放在類名後面，被final修飾符修飾的類不能被繼承。示例代碼： // 正確的示範 #include <iostream> class

    C++11 新特性之operator "" xxx

    從C++11開始，我們可以使用以下形式通過常量字串構造自定義型別， 比如： class Person { public: Person(const std::string& name): _name(name){} std::string name() const {

    C++11新特性之Lambda函式

    我是搞C++的 一直都在提醒自己，我是搞C++的；但是當C++11出來這麼長時間了，我卻沒有跟著隊伍走，發現很對不起自己的身份，也還好，發現自己也有段時間沒有寫C++程式碼了。今天看到了C++中的Lambda表示式，雖然用過C#的，但是C++的，一直沒有用，也不知道怎麼

    C++11新特性之列表初始化

    在我們實際程式設計中，我們經常會碰到變數初始化的問題，對於不同的變數初始化的手段多種多樣，比如說對於一個數組我們可以使用 int arr[] = {1,2,3}的方式初始化，又比如對於一個簡單的結構體： struct A { int x; int y; }a={1,2

    C++11新特性之 Move semantics(移動語義)

    按值傳遞的意義是什麼？ 當一個函式的引數按值傳遞時，這就會進行拷貝。當然，編譯器懂得如何去拷貝。 而對於我們自定義的型別，我們也許需要提供拷貝建構函式。 但是不得不說，拷貝的代價是昂貴的。 所以我們需要尋找一個避免不必要拷貝的方法，即C++11提供的移動

    C++11新特性之智慧指標

    　　這一節將從用法上、記憶體儲存上以及生存週期上，對unique_ptr， shared_ptr和weak_ptr做一個深入剖析。 unique_ptr 　　不共享它的指標。它無法複製到其他 unique_ptr，無法通過值傳遞到函式，也無法用於需要副本的

    C++11新特性之 std::array container

    陣列每個人都很熟悉，vector更是我們常常用到的。 但是某些場合，使用vector是多餘的，尤其能明確元素個數的情況下，這樣我們就付出了效率稍低的代價！ 但是你使用陣列的代價是那麼的不安全，那麼的不方便。 於是，C++11推出了模板類array，位於st

    C++11新特性之 std::forward(完美轉發)

    上篇部落格對右值、右值引用都做了簡要介紹。 我們也要時刻清醒，有時候右值會轉為左值，左值會轉為右值。 （也許“轉換”二字用的不是很準確） 如果我們要避免這種轉換呢？ 我們需要一種方法能按照引數原來的型別轉發到另一個函式中，這才完美，我們稱之為完美轉發

    C++11 新特性之 序列for循環

    return 新特性 art tor href mes 定義 數組 pac 版權聲明：本文為博主原創文章。未經博主同意不