轉載 自 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
是一個具體類型：
- 左值引用， 使用
T&
- 右值引用， 使用
T&&
- 常量左值， 使用
const T&
- 已命名的右值引用，編譯器會認為是個左值
- 編譯器有傳回值優化，但不要過于依賴
移動構造和移動指派
回顧一下如何用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的差別。
不用奇怪為什麼可以搶别人的資源，臨時對象的資源不好好利用也是浪費，因為生命周期本來就是很短，在你執行完這個表達式之後，它就毀滅了，充分利用資源，才能很高效。
對于一個左值，肯定是調用拷貝構造函數了，但是有些左值是局部變量，生命周期也很短，能不能也移動而不是拷貝呢？
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的内容也失效了，不要再使用
需要注意一下幾點：
-
str6 = std::move(str2)
str2
str6
str2
str2
str2
m_data
- 如果我們沒有提供移動構造函數，隻提供了拷貝構造函數，
std::move()
const T&
-
c++11中
move
move
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
增加了引用折疊的規則，總結如下：
- 所有的右值引用疊加到右值引用上仍然使一個右值引用。
- 所有的其他引用類型之間的疊加都将變成左值引用。
如上面的
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> 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++
-
std::move()和std::forward()
![C語言第四章自述2第四章 選擇結構程式設計[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)