目錄

lvalue 和 rvalue

rvalue 引用

移動語義

移動語義的概念

強制移動

---

lvalue 和 rvalue

每個表達式都會得到 lvalue 或 rvalue。它們的區別是，lvalue 是一個持久存在的值，其內存地址可被用來持續存儲值；rvalue 是一個暫時存儲的結果。之所以稱為 lvalue，是因為得到 lvalue 的表達式通常出現在賦值運算符的左邊，而 rvalue 只能出現在賦值運算符的右邊。表達式的結果不是 lvalue，就是 rvalue。包含一個變量名稱的表達式總是 lvalue。

注意：雖然名稱中帶有 value，但是 lvalue 和 rvalue 是表達式分類，而不是值分類。

int a{}, b{1}, c{-2}; a = b + c; double r = std::abs(a * c); auto p = std::pow(r, std::abs(c));

第一條語句把 a、b 和 c 定義成 int 類型，分別初始化為 0、1 和 -2。之后，名稱 a、b 和 c 都是 lvalue。

第二條語句中，會臨時存儲 b+c 的結果，并且復制到 a 中。執行完該語句后，就舍棄保存 b+c 結果的空間。因此，b+c 的結果是 rvalue。

涉及函數時，存在臨時結果這一點就更加明顯了。例如，在第三條語句中，a*c 被計算，作為臨時值存儲在內存中的某個位置。然后，這個臨時結果作為實參被傳遞給 std::abs() 函數。這使得 a*c 成為 rvalue。std::abs() 自己返回的值也是臨時的。它只是存在一小段時間，直到被隱式轉換為一個 double 值。

對于第四條語句的兩個函數調用，也是同樣的道理。例如，std::abs() 返回的值顯然只臨時存在，以用作 std::abs() 的實參。

注意：大部分函數調用表達式都是 rvalue。只有返回引用的函數調用是 lvalue。返回引用的函數調用可出現在內置賦值運算符的左側，說明它們是 lvalue，典型的容器的下標運算符 (operator[]()) 和 at() 函數是很好的例子。例如，如果 v 是 vector<int>，那么 v[1] = 1; 和 v.at(2) = 2; 都是完全有效的語句。顯然，它們是 lvalue。（ 源自：《C++17入門經典》）

觀察以下實例，判斷給定表達式是 lvalue 還是 rvalue：

int *x = &(a+b); int *y = &std::abs(a*d); int *z = &123; int *w = &a; int *u = &v.at(2);

當周圍語句完成執行后，存儲表達式 b+c 和 std::abs() 結果的內存將立即回收。如果允許它們存在，指針 x 和 y 將成為懸掛指針，沒有人能夠查看它們。這意味著這些表達式是 rvalue。所有數值字面量是 rvalue，而編譯器不允許獲取數值字面量的地址。

對于基本類型的表達式，lvalue 和 rvalue 的區別一般不重要。對于類類型的表達式，這種區別比較重要；而且即使是類類型表達式，也只有在某些情況下才重要，例如，把表達式傳遞給函數，且函數有專門定義為接收 rvalue 表達式結果的重載時，或者當在容器中存儲對象時。區分左值和右值的一個簡單辦法是：看能不能對表達式取地址，如果能，則為左值，否則為右值。

#include <iostream> #include <string>using namespace std;char &get_val(string &str, string::size_type ix) {return str[ix]; }char *get_val1(char a[], char *b) {b = &a[0];return b; }int main() {string s("a value");cout << s << endl;get_val(s, 0) = 'A';cout << s << endl;return 0; }輸出： a value A value

?

?

rvalue 引用

引用是一個名稱，可用作其他某個事物的別名。但是，實際上有兩種類型的引用：lvalue 引用和 rvalue 引用。在多數情況下使用的引用是 lvalue 引用。通常，lvalue 引用是另外一個變量的別名；之所以叫作 lvalue 引用，是因為它通常引用一個持久的數據存儲位置，可以出現在賦值運算符的左邊。

rvalue 引用也可以是變量的別名，這一點和 lvalue 引用相同，但與 lvalue 引用不同，rvalue 引用能夠引用一個 rvalue 表達式的結果，即使這個值一般來說是臨時的。綁定到 rvalue 引用，就延長了這種臨時值的生存期。只要 rvalue 引用還在作用域內，用于臨時值的內存就不會被丟棄。要指定 rvalue 引用，需要在類型名的后面使用兩個 & 符號，例如：

int count {5}; int && rtemp {count + 3}; std::cout << rtemp <<std::endl; int & rcount {count};

這段代碼可以編譯并運行，但不是使用 rvalue 引用的正確方式，這段代碼僅僅演示了 rvalue 引用的含義。

?

?

移動語義

移動語義的概念

如果想避免高開銷的復制，可以使用引用或指針。不過，從 C++11 開始，有了另一種新的更強大的方法，現在不只能夠復制對象，還可以移動對象。移動語義允許高效地將一個對象傳輸到另一個對象，不進行深層復制。在 C++11 之前的復制過程：

vector<string> vstr; 創建一個含有20000字符串的vector，每個字符串含有1000個字符。 ...... vector<string> vstr_copy1(vstr);

vector 和 string 類都使用動態內存分配，因此它們必須定義使用某種 new 版本的復制構造函數。為初始化對象 vstr_copy1，復制構造函數 vector<string> 將使用 new 給 2 萬個 string 對象分配內存，而每個 string 對象又將調用 string 的復制構造函數，該構造函數使用 new 為 1000 個字符分配內存。接下來，全部兩千萬個字符都將從 vstr 控制的內存復制到 vstr_copy1 控制的內存中，這里的工作量是很大的。

考慮以下情況：

vector(string) allcaps(const vector<string> & vs) {vector<string> temp;return temp; }假設這樣使用它： vector<string> vstr; vector<string> vstr_copy1(vstr); ??????????????// 1 vector<string> vstr_copy2( allcaps(vstr) ); ???// 2

從表面上看，語句 1 和語句 2 類似，它們都使用一個現有的對象初始化一個 vector<string> 對象。如果深入探索這些代碼，將發現 allcaps() 創建了對象 temp，該對象管理兩千萬個字符；vector 和 string 的復制構造函數創建這兩千萬個字符的副本，然后程序刪除 allcaps() 返回的臨時對象。這可不是一個小小的臨時對象啊！

如果編譯器將對數據的所有權直接轉讓給 vstr_copy2，不是更好嗎？也就是說，不將兩千萬個字符復制到新的地方，再刪除原來的字符，而是將字符留在原來的地方，并將 vstr_copy2 與之相關聯。這種方法被稱為移動語義（move semantics），但不要被它的名字所迷惑，移動語義實際上避免了移動原始數據，而只是修改了記錄。

要實現移動語義，需要采取某種方式讓編譯器知道什么時候需要復制，什么時候不需要。這就是右值引用發揮作用的地方。可定義兩個構造函數，其中一個是常規的復制構造函數，它使用 const 左值引用作為參數，這個引用關聯到左值實參，如語句 1 中的 vstr ；另一個是移動構造函數，它使用右值引用作為參數，該引用關聯到右值實參，如語句 2 中的 allcaps(vstr) 的返回值。賦值構造函數可執行深復制，而移動構造函數只調整記錄。在將所有權轉移給新對象的過程中，移動構造函數可能修改其實參，這意味著右值引用參數不應是 cosnt。

了解完需求及概念后，為了使用移動構造函數，并分析它與復制構造函數的不同。以下代碼在各個構造函數中添加了輸出信息的語句，用于區分不同構造函數的調用情況。

移動構造函數示例代碼：

#include <iostream> #include <string> using namespace std;class Asd {private:int n; //元素的數量char * pc; //指向數據static int numsum; //對象的數量void Showobject() const; //展示對象信息，元素數量及地址public:Asd();explicit Asd(int k);Asd(int k, char ch);Asd(const Asd &f); //copy constructor 復制構造函數Asd(Asd &&f); //move constructor 移動構造函數~Asd();Asd operator +(const Asd &f) const;void Showdata() const; };int Asd::numsum = 0;Asd::Asd() {++numsum;n = 0;pc = NULL;cout << "Default constructor, number of objects:" << numsum <<endl;Showobject(); }Asd::Asd(int k) : n(k) {++numsum;cout << "Int constructor, number of objects:" << numsum <<endl;pc = new char[n];Showobject(); }Asd::Asd(int k, char ch) : n(k) {++numsum;cout << "Int, char constructor, number of objects:" << numsum <<endl;pc = new char[n];for(int i = 0; i < n; i++){pc[i] = ch;}Showobject(); }Asd::Asd(const Asd &f) : n(f.n) {++numsum;cout << "Copy constructor, number of objects:" << numsum <<endl;pc = new char[n];for (int i = 0; i < n; i++){pc[i] = f.pc[i];}Showobject(); }Asd::Asd(Asd &&f) : n(f.n) {++numsum;cout << "Move constructor, number of objects:" << numsum <<endl;pc = f.pc;f.pc = NULL;f.n = 0;Showobject(); }Asd::~Asd() {cout << "Destructor, number of objects:" << --numsum <<endl;cout << "Delete object:\n";Showobject();cout << "End" <<endl;delete [] pc; }Asd Asd::operator +(const Asd &f)const {cout << "Entering Operator+() \n";Asd temp = Asd(n + f.n);for (int i = 0; i < n; i++)temp.pc[i] = pc[i];for (int i = n; i < temp.n; i++)temp.pc[i] = f.pc[i-n];cout << "Leaving Operator+() \n";return temp; } void Asd::Showobject() const {cout << "Number of elements:" << n;cout << " Data address: " << (void *)pc <<endl; }void Asd::Showdata() const {if (n == 0)cout << "Empty";elsefor(int i = 0; i < n; i++)cout << pc[i];cout <<endl; }int main() {{Asd one(10, 'x');Asd two = one;Asd three(10, 'o');Asd four(one + three); //這里調用了operator+()，移動構造函數cout << "one:";one.Showdata();cout << "two:";two.Showdata();cout << "three:";three.Showdata();cout << "four:";four.Showdata();}return 0; }

對象 two 是對象 one 的副本，它們的數據是相同的，但是數據的地址不一樣。另一方面，在方法 operator+() 中創建的對象的數據地址與對象 four 存儲的數據地址相同，而對象 four 是由移動構造函數創建的。另外，在創建對象 four 后，為臨時對象調用了析構函數。之所以是臨時對象，因為它們的元素數和數據地址都是 0。

如果不關閉 RVO （返回值優化），是看不到調用移動構造函數的。一般不用太在意這一點，這是因為編譯器進行優化的結果與未優化時的結果相同。

?

移動構造函數

雖然使用右值引用可以支持移動語義，但這并不會自己神奇的發生。要想完成相應的功能，需要兩個步驟。

(1) 右值引用讓編譯器知道何時使用移動語義

Asd two = one;? ? ? ? ? ? //匹配復制構造函數 Asd four(one + three);?? //匹配移動構造函數

對象 one 是左值，與左值引用相匹配，而表達式 one+three 是右值，與右值引用匹配。因此，右值引用讓編譯器使用移動構造函數來初始化對象 four。

?

(2) 編寫移動構造函數

Asd::Asd(Asd &&f) : n(f.n) {++numsum;pc = f.pc;?????????// pc指向f.pcf.pc = NULL;??? ???//f.pc指向空，這樣就可以避免調用析構函數時對同一個空間釋放兩次。f.n = 0;Showobject(); }

?

賦值

適用于構造函數的移動語義也適用于賦值運算符。例如：

(1) 復制賦值運算符

深復制，申請空間后復制原數據。 Asd Asd::operator =(const Asd &f) {if (this == &f)return *this;delete [] pc;n = f.n;pc = new char[n];for (int i = 0; i < n; i++)pc[i] = f.pc[i];return *this; }

?

(2) 移動賦值運算符

修改指針指向，然后讓原指針指向 nullptr Asd Asd::operator =(Asd && f) {if (this == &f)return *this;delete [] pc;n = f.n;pc = f.pc;f.n = 0;f.pc = nullptr;return *this; }

?

強制移動

移動構造函數和移動賦值運算符使用右值。如果要讓它們使用左值，該怎么辦？例如，程序可能分析一個包含候選對象的數組，選擇其中一個對象使用，并丟棄數組。如果可以使用移動構造函數或移動賦值運算符來保留選定的對象，那該多好啊。然而，若按以下方式做：

Asd test[10]; Asd best; int pick; ... best = test[pick];

由于 test[pick] 是左值，因此會使用復制賦值運算符，而不是移動賦值運算符。但如果讓 test[pick] 看起來像右值，便將使用移動賦值運算符。為此，可使用運算符 static_cast<> 將對象的類型強制轉換成 Asd &&，但自 C++11 提供了一種更簡單的方式——使用 std::move() 函數。

代碼如下：

#include <iostream> #include <string> using namespace std;class Asd {private:int n; //元素的數量char * pc; //指向數據static int numsum; //對象的數量void Showobject() const; //展示對象信息，元素數量及地址public:Asd();explicit Asd(int k);Asd(int k, char ch);Asd(const Asd &f); //copy constructor 復制構造函數Asd(Asd &&f); //move constructor 移動構造函數~Asd();Asd operator +(const Asd &f) const;Asd & operator =(const Asd &f);Asd & operator =(Asd &&f);void Showdata() const; };int Asd::numsum = 0;Asd::Asd() {++numsum;n = 0;pc = NULL; }Asd::Asd(int k) : n(k) {++numsum;pc = new char[n]; }Asd::Asd(int k, char ch) : n(k) {++numsum;pc = new char[n];for(int i = 0; i < n; i++)pc[i] = ch; }Asd::Asd(const Asd &f) : n(f.n) {++numsum;pc = new char[n];for (int i = 0; i < n; i++)pc[i] = f.pc[i]; }Asd::Asd(Asd &&f) : n(f.n) {++numsum;pc = f.pc;f.pc = NULL;f.n = 0; }Asd::~Asd() {delete [] pc; }Asd Asd::operator +(const Asd &f)const {Asd temp = Asd(n + f.n);for (int i = 0; i < n; i++)temp.pc[i] = pc[i];for (int i = n; i < temp.n; i++)temp.pc[i] = f.pc[i-n];return temp; } Asd & Asd::operator =(const Asd &f) {cout << "Copy assignment:\n";if (this == &f)return *this;delete [] pc;n = f.n;pc = new char[n];for (int i = 0; i < n; i++)pc[i] = f.pc[i];return *this; } Asd & Asd::operator =(Asd && f) {cout << "Move assignment:\n";if (this == &f)return *this;delete [] pc;n = f.n;pc = f.pc;f.n = 0;f.pc = nullptr;return *this; }void Asd::Showobject() const {cout << "Number of elements:" << n;cout << " Data address: " << (void *)pc <<endl; }void Asd::Showdata() const {if (n == 0)cout << "Empty";elsefor(int i = 0; i < n; i++)cout << pc[i];cout <<endl; }int main() {{Asd one(10, 'x');Asd two = one + one;cout << "One:";one.Showdata();cout << "Two:";two.Showdata();Asd three, four;cout << "Three = One:\n";three = one;cout << "Now, object three:";three.Showdata();cout << "and object one = ";one.Showdata();cout << "Four = one + two\n";four = one + two; //移動賦值運算符cout << "Now, object four = ";four.Showdata();cout << "four = move(one)\n";four = move(one);cout << "Now, object four = ";four.Showdata();cout << "and object one = ";one.Showdata();}return 0; }

從上面實驗可看出，將 one 賦給 three 調用了復制賦值運算符，但將 move(one) 賦給 four 調用的是移動賦值運算符。對大多數程序員來說，右值引用帶來的主要好處并非是讓他們能夠編寫使用右值引用的代碼，而是能夠使用利用右值引用實現移動語義的庫代碼。例如，STL 類現在都有復制構造函數、移動構造函數、復制賦值運算符和移動賦值運算符。

總結

以上是生活随笔為你收集整理的C++易被忽略的知识点：移动语义 左值右值的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。