移動語意 std::move() 的用途與原則
tags: operator
用一句話概括
用同一個等號，把對方的資源搶過來。
struct ImgData{
int size;
int* data;
...
};
ImgData img1, img2;
img1 = std::move(img2); // 搶對方指標納為已用，並設置對方指向null (copy 8byte)
img1 = img2; // 陣列多長就複製多長 (copy len * type byte)
std::move()
協助你呼叫淺度拷貝函式
用來區分什麼時候要移動，什麼時候要複製
部分知識補充
兩種拷貝方法
我們要先介紹兩個名詞深度拷貝與淺度拷貝，這兩種拷貝會發生在一個成員具有指標的物件，這時候拷貝可以有兩種情況
- 深度拷貝：要求新空間且實際複製
指針所指之處的內容 - 淺度拷貝：只複製
指針容器內的指針
淺度拷貝後A物件被更動，B物件也會跟著被改變，因為他們指向同一個位址
移動語意
如名字所敘移動語意是指
移動行為，而既照語意來說就是，移動的過程中不會產生物件複製行為，進一步來說就是在不發生深度拷貝的前提下把資源從 a 處弄到 b 處
淺度拷貝與此語意相符僅複製指標過去而不複製物件本身。
比較容易讓人產生誤解的是
std::move() 本身並不具備移動的函式，他所做的事情是協助你呼叫淺度拷貝函式
把這一句話背下來，將協助你解決很多很多的困擾
如果
operator=() 同時重載了深度拷貝與淺度拷貝，我把它稱為具移動函式的物件；深度拷貝則稱為複製函式、淺度拷貝則稱為移動函式。使用條件
既然是協助呼叫淺度拷貝函式，也就代表說
也要該物件具有淺度拷貝函式才能夠使用
如果一個物件不具有移動函式，那麼有沒有使用std::move()結果將沒有區別
因為
因為
fun(const &T); 可以接收左右值，結果而言你所轉換的右值會呼叫該函式Arr & operator=(Arr const & rhs){}
我們可以加載這個移動函式來區分左右值的引用
Arr & operator=(Arr && rhs){}
原先的左值會呼叫原先的函式，而被你標記為移動語意的物件將會呼叫移動函式
Arr a, b;
// 複製函式
a = b;
// 移動函式
a = std::move(b);
產生的問題
未指定行為
既然所謂的移動語意是淺層拷貝，那執行完上面的函式不就出問題了嗎？我更改a將會連動到b。
自己就要記清楚，這個 b 已經不要了，不可以再使用了
這麼想其實也很合理，不正是因為不要了才要移動嗎？如果還要該是呼叫複製函式對吧！然後經過 std::move() 之後也會做語法標記，被標記的物件雖然可以存取，但是會發生未指定行為。
轉發右值
右值有一個大原則他沒有名字
而右值引用的引用變數是帶有名字的
這在轉發的時候會出問題的，你所接收的右值在接收的那一個瞬間已經被轉成左值了
void fun(Arr const && i){
Arr temp;
temp = i;
}
void main(){
Arr a;
fun(std::move(a));
}
那個 a 雖然你正確的轉成右值輸入，但是當他變成 i 的時候他就有一個名字叫做 i 了，你將會呼叫複製函式而不是移動函式。
接收右值必須在std::move()一次，才能正確地使用移動函式
void fun(Arr const && i){
Arr temp;
temp = std::move(i);
}
void main(){
Arr a;
fun(std::move(a));
}
重複釋放同一個地址
當我們使用移動函式的時候，會把a物件的指針複製到b物件的指針，這樣會導致一個狀況
兩個物件同時指向同一個地址
同時指向還不是太大的問題，問題在於當他們生命周期結束時會個別呼叫個別的解構子，這樣會造成同一個地址被解構兩次，進而造成程式崩潰。
移動函式必須將，原移動對象歸零，指向nullptr
為什麼選用 非const版本 的引入參數?
左值參考
同樣的你可能也會好奇，為什麼複製函式是選用 const 版本的
因為結果很明確，不會動到來源
除此外還有一個特性，const可以接收兩者，但是 non-const，只能接收 non-const ，這種情況下你必須寫兩種版本的函式
Arr & operator=(Arr const & rhs){}
Arr & operator=(Arr & rhs){}
然而他們居然是做同一件事情，當然能整合寫一個就整合寫一個
右值參考
接下來你可能會覺的，那移動語意應該也該選擇 const 版本整合兩者不是嗎？
不~還有另一條，根據上面的規則，移動過後必須歸零來源！
不~還有另一條，根據上面的規則，移動過後必須歸零來源！
如果你選了 const 那將妨礙到移動語意的操作，無法歸零來源
其次，這會導致複製函式的語意被
初始化規則否決，當存在以下兩條函式時Arr & operator=(Arr const & rhs){} //原複製函式
Arr & operator=(Arr const && rhs){}
在接收右值的時候會優先執行下方的函式，複製函式將沒有機會實現，這會造成我們失去主動權，可以在主程式選擇
右值參考 要使用複製函式或是移動函式。std::move() 的存在就是協助給予我們主動權
讓我們可以由決定該用哪一種方式執行程式。
不要以為返回 move 可以省下複製成本
函式的返回時會創建一個站存值，這個會造成一個複製成本
int fun(){
int i;
return i;
}
在函式內
int i 是新創值，當他返回到主程式的時候，又會複製一份新的站存值，如果不複製將會因為副程式內的 i 生命週期結束，主程式無法接收
於是你可能會想這麼做
int & fun(){
int i;
return i;
}
看起來是一個很好的解決方案，但是你要知道副程式執行完畢 i 就被解構了，返回的參考，將會參考到一個非法空間。
或許移動語意取代複製語意是個好方法?
int fun(){
int i;
return std::move(i);
}
實際上並不會，因為最初的做法編譯器會自動做優化(return value optimization)，他會直接就地構造，差不多就相當於在主程式宣告，所以一開始說的多餘複製其實是不會發生的，除非主程式的物件已經存在。
當你使用 move() 語意將會破壞這個超級優化
/*****************************************************************
Name :
Date : 2017/04/07
By : CharlotteHonG
Final: 2017/04/07
*****************************************************************/
#include <iostream>
using namespace std;
struct A {
A() = default;
A(A && rhs){cout << "mctor" << endl;}
~A(){cout << "dctor" << endl;}
};
A fun(){
A i;
// return std::move(i);
return i;
}
/*==============================================================*/
int main(int argc, char const *argv[]){
A a = fun();
return 0;
}
/*==============================================================*/
可以看出解構只執行一次，從頭到尾就只有創建一個。使用move語意後雖然會確實的執行move語意，但是會導致創建兩個實體，並沒有比較好。
