一文搞懂c++中的std::move函數
前言
在探討c++11中的Move函數前，先介紹兩個概念（左值和右值）
左值和右值
首先區分左值和右值
左值是表達式結束後依然存在的持久對象(代表一個在內存中占有確定位置的對象)
右值是表達式結束時不再存在的臨時對象(不在內存中占有確定位置的表達式）
便攜方法：對表達式取地址，如果能，則為左值，否則為右值
int val; val = 4; // 正確 ① 4 = val; // 錯誤 ②
上述例子中，由於在之前已經對變量val進行瞭定義，故在棧上會給val分配內存地址，運算符=要求等號左邊是可修改的左值，4是臨時參與運算的值，一般在寄存器上暫存，運算結束後在寄存器上移除該值，故①是對的，②是錯的
左值引用
右值引用
std::move函數
- std::move作用主要可以將一個左值轉換成右值引用，從而可以調用C++11右值引用的拷貝構造函數
- std::move應該是針對你的對象中有在堆上分配內存這種情況而設置的，如下
remove_reference源碼剖析
在分析std::move()與std::forward()之前，先看看remove_reference，下面是remove_reference的實現：
template<typename _Tp>
struct remove_reference
{ typedef _Tp type; };
// 特化版本
template<typename _Tp>
struct remove_reference<_Tp&>
{ typedef _Tp type; };
template<typename _Tp>
struct remove_reference<_Tp&&>
{ typedef _Tp type; };
remove_reference的作用是去除T中的引用部分，隻獲取其中的類型部分。無論T是左值還是右值，最後隻獲取它的類型部分。
std::forward源碼剖析
轉發左值
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Tp&&>(__t); }
先通過獲得類型type，定義_t為左值引用的左值變量，通過static_cast進行強制轉換。_Tp&&會發生引用折疊，當_Tp推導為左值引用，則折疊為_Tp& &&，即_Tp&，當推導為右值引用，則為本身_Tp&&，即forward返回值與static_cast處都為_Tp&&。
轉發右值
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
" substituting _Tp is an lvalue reference type");
return static_cast<_Tp&&>(__t);
}
不同於轉發左值，_t為右值引用的左值變量，除此之外中間加瞭一個斷言，表示當不是左值的時候，也就是右值，才進行static_cast轉換。
std::move()源碼剖析
// FUNCTION TEMPLATE move
template <class _Ty>
_NODISCARD constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg) noexcept { // forward _Arg as movable
return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}
std::move的功能是：
- 傳遞的是左值，推導為左值引用，仍舊static_cast轉換為右值引用。
- 傳遞的是右值，推導為右值引用，仍舊static_cast轉換為右值引用。
- 在返回處，直接范圍右值引用類型即可。還是通過renive_reference獲得_Tp類型，然後直接type&&即可。
所以std::remove_reference<_Tp>::type&&，就是一個右值引用，我們就知道瞭std::move幹的事情瞭。
小結
- 在《Effective Modern C++》中建議：對於右值引用使用std::move，對於萬能引用使用std::forward。
- std::move()與std::forward()都僅僅做瞭類型轉換(可理解為static_cast轉換)而已。真正的移動操作是在移動構造函數或者移動賦值操作符中發生的
- 在類型聲明當中， “&&” 要不就是一個 rvalue reference ，要不就是一個 universal reference – 一種可以解析為lvalue reference或者rvalue reference的引用。對於某個被推導的類型T，universal references 總是以 T&& 的形式出現。
- 引用折疊是 會讓 universal references (其實就是一個處於引用折疊背景下的rvalue references ) 有時解析為 lvalue references 有時解析為 rvalue references 的根本機制。引用折疊隻會在一些特定的可能會產生"引用的引用"場景下生效。這些場景包括模板類型推導，auto 類型推導， typedef 的形成和使用，以及decltype 表達式。
std::move使用場景
在實際場景中，右值引用和std::move被廣泛用於在STL和自定義類中實現移動語義，避免拷貝，從而提升程序性能。 在沒有右值引用之前，一個簡單的數組類通常實現如下，有構造函數、拷貝構造函數、賦值運算符重載、析構函數等。深拷貝/淺拷貝在此不做講解。
class Array {
public:
Array(int size) : size_(size) {
data = new int[size_];
}
// 深拷貝構造
Array(const Array& temp_array) {
size_ = temp_array.size_;
data_ = new int[size_];
for (int i = 0; i < size_; i ++) {
data_[i] = temp_array.data_[i];
}
}
// 深拷貝賦值
Array& operator=(const Array& temp_array) {
delete[] data_;
size_ = temp_array.size_;
data_ = new int[size_];
for (int i = 0; i < size_; i ++) {
data_[i] = temp_array.data_[i];
}
}
~Array() {
delete[] data_;
}
public:
int *data_;
int size_;
};
該類的拷貝構造函數、賦值運算符重載函數已經通過使用左值引用傳參來避免一次多餘拷貝瞭，但是內部實現要深拷貝，無法避免。 這時，有人提出一個想法：是不是可以提供一個移動構造函數，把被拷貝者的數據移動過來，被拷貝者後邊就不要瞭，這樣就可以避免深拷貝瞭，如：
class Array {
public:
Array(int size) : size_(size) {
data = new int[size_];
}
// 深拷貝構造
Array(const Array& temp_array) {
...
}
// 深拷貝賦值
Array& operator=(const Array& temp_array) {
...
}
// 移動構造函數，可以淺拷貝
Array(const Array& temp_array, bool move) {
data_ = temp_array.data_;
size_ = temp_array.size_;
// 為防止temp_array析構時delete data，提前置空其data_
temp_array.data_ = nullptr;
}
~Array() {
delete [] data_;
}
public:
int *data_;
int size_;
};
這麼做有2個問題：
- 不優雅，表示移動語義還需要一個額外的參數(或者其他方式)。
- 無法實現！
temp_array是個const左值引用，無法被修改，所以temp_array.data_ = nullptr;這行會編譯不過。當然函數參數可以改成非const：Array(Array& temp_array, bool move){...}，這樣也有問題，由於左值引用不能接右值，Array a = Array(Array(), true);這種調用方式就沒法用瞭。
可以發現左值引用真是用的很不爽，右值引用的出現解決瞭這個問題，在STL的很多容器中，都實現瞭以右值引用為參數的移動構造函數和移動賦值重載函數，或者其他函數，最常見的如std::vector的push_back和emplace_back。參數為左值引用意味著拷貝，為右值引用意味著移動。
class Array {
public:
......
// 優雅
Array(Array&& temp_array) {
data_ = temp_array.data_;
size_ = temp_array.size_;
// 為防止temp_array析構時delete data，提前置空其data_
temp_array.data_ = nullptr;
}
public:
int *data_;
int size_;
};
如何使用：
// 例1：Array用法
int main(){
Array a;
// 做一些操作
.....
// 左值a，用std::move轉化為右值
Array b(std::move(a));
}
實例：vector::push_back使用std::move提高性能
// 例2：std::vector和std::string的實際例子
int main() {
std::string str1 = "aacasxs";
std::vector<std::string> vec;
vec.push_back(str1); // 傳統方法，copy
vec.push_back(std::move(str1)); // 調用移動語義的push_back方法，避免拷貝，str1會失去原有值，變成空字符串
vec.emplace_back(std::move(str1)); // emplace_back效果相同，str1會失去原有值
vec.emplace_back("axcsddcas"); // 當然可以直接接右值
}
// std::vector方法定義
void push_back (const value_type& val);
void push_back (value_type&& val);
void emplace_back (Args&&... args);
在vector和string這個場景，加個std::move會調用到移動語義函數，避免瞭深拷貝。
除非設計不允許移動，STL類大都支持移動語義函數，即可移動的。 另外，編譯器會默認在用戶自定義的class和struct中生成移動語義函數，但前提是用戶沒有主動定義該類的拷貝構造等函數(具體規則自行百度哈)。 因此，可移動對象在<需要拷貝且被拷貝者之後不再被需要>的場景，建議使用std::move觸發移動語義，提升性能。
還有些STL類是move-only的，比如unique_ptr，這種類隻有移動構造函數，因此隻能移動(轉移內部對象所有權，或者叫淺拷貝)，不能拷貝(深拷貝)
std::unique_ptr<A> ptr_a = std::make_unique<A>(); std::unique_ptr<A> ptr_b = std::move(ptr_a); // unique_ptr隻有‘移動賦值重載函數‘，參數是&& ，隻能接右值，因此必須用std::move轉換類型 std::unique_ptr<A> ptr_b = ptr_a; // 編譯不通過
std::move本身隻做類型轉換，對性能無影響。 我們可以在自己的類中實現移動語義，避免深拷貝，充分利用右值引用和std::move的語言特性。
std::vector<int> b(5); b[0] = 2; b[1] = 2; b[2] = 2; b[3] = 2; // 此處用move就不會對b中已有元素重新進行拷貝構造然後再放到a中 std::vector<int> a = std::move(b);
將vector B賦值給另一個vector A，如果是拷貝賦值，那麼顯然要對B中的每一個元素執行一個copy操作到A，如果是移動賦值的話，隻需要將指向B的指針拷貝到A中即可，試想一下如果vector中有相當多的元素，那是不是用move來代替copy就顯得十分高效瞭呢？建議看一看Scott Meyers 的Effective Modern C++，裡面對移動語義、右值引用以及類型推導進行瞭深入的探索
萬能引用
首先，我們先看一個例子
#include <iostream>
using std::cout;
using std::endl;
template<typename T>
void func(T& param) {
cout << param << endl;
}
int main() {
int num = 2019;
func(num);
return 0;
}
這樣例子的編譯輸出不存在什麼問題，但是如果修改成下面的調用方式呢？
int main(){
func(2019);
return 0;
}
編譯器會產生錯誤，因為上面的模板函數隻能接受左值或者左值引用（左值一般是有名字的變量，可以取到地址的），我們當然可以重載一個接受右值的模板函數，如下也可以達到效果
template<typename T>
void func(T& param) {
cout << "傳入的是左值" << endl;
}
template<typename T>
void func(T&& param) {
cout << "傳入的是右值" << endl;
}
int main() {
int num = 2019;
func(num);
func(2019);
return 0;
}
輸出結果
傳入的是左值
傳入的是右值
第一次函數調用的是左值得版本，第二次函數調用的是右值版本。但是，有沒有辦法隻寫一個模板函數即可以接收左值又可以接收右值呢？
C++11中有萬能引用（Universal Reference）的概念：使用T&&類型的形參既能綁定右值，又能綁定左值
但是註意瞭：隻有發生類型推導的時候，T&&才表示萬能引用（如模板函數傳參就會經過類型推導的過程）；否則，表示右值引用
所以，上面的案例我們可以修改為
template<typename T>
void func(T&& param) {
cout << param << endl;
}
int main() {
int num = 2019;
func(num);
func(2019);
return 0;
}
引用折疊
萬能引用說完瞭，接著來聊引用折疊（Reference Collapse），因為完美轉發（Perfect Forwarding）的概念涉及引用折疊。一個模板函數，根據定義的形參和傳入的實參的類型，我們可以有下面四中組合：
左值-左值 T& & # 函數定義的形參類型是左值引用，傳入的實參是左值引用
template<typename T>
void func(T& param) {
cout << param << endl;
}
int main(){
int num = 2021;
int& val = num;
func(val);
}
左值-右值 T& && # 函數定義的形參類型是左值引用，傳入的實參是右值引用
template<typename T>
void func(T& param) {
cout << param << endl;
}
int main(){
int&& val = 2021;
func(val);
}
右值-左值 T&& & # 函數定義的形參類型是右值引用，傳入的實參是左值引用
template<typename T>
void func(T&& param) {
cout << param << endl;
}
int main(){
int num = 2021;
int& val = num;
func(val);
}
右值-右值 T&& && # 函數定義的形參類型是右值引用，傳入的實參是右值引用
template<typename T>
void func(T&& param) {
cout << param << endl;
}
int main(){
int&& val = 4;
func(val);
}
但是C++中不允許對引用再進行引用，對於上述情況的處理有如下的規則：
所有的折疊引用最終都代表一個引用，要麼是左值引用，要麼是右值引用。規則是：如果任一引用為左值引用，則結果為左值引用。否則（即兩個都是右值引用），結果才是右值引用
即就是前面三種情況代表的都是左值引用，而第四種代表的右值引用
完美轉發
下面接著說完美轉發（Perfect Forwarding），首先，看一個例子
#include <iostream>
using std::cout;
using std::endl;
template<typename T>
void func(T& param) {
cout << "傳入的是左值" << endl;
}
template<typename T>
void func(T&& param) {
cout << "傳入的是右值" << endl;
}
template<typename T>
void warp(T&& param) {
func(param);
}
int main() {
int num = 2019;
warp(num);
warp(2019);
return 0;
}
輸出的結果
傳入的是左值
傳入的是左值
是不是和預期的不一樣，下面我們來分析一下原因：
warp()函數本身的形參是一個萬能引用，即可以接受左值又可以接受右值；第一個warp()函數調用實參是左值，所以，warp()函數中調用func()中傳入的參數也應該是左值；第二個warp()函數調用實參是右值，根據上面所說的引用折疊規則，warp()函數接收的參數類型是右值引用，那麼為什麼卻調用瞭調用func()的左值版本瞭呢？這是因為在warp()函數內部，右值引用類型變為瞭左值，因為參數有瞭名稱，我們也通過變量名取得變量地址
那麼問題來瞭，怎麼保持函數調用過程中，變量類型的不變呢？這就是我們所謂的“變量轉發”技術，在C++11中通過std::forward()函數來實現。我們來修改我們的warp()函數如下：
template<typename T>
void warp(T&& param) {
func(std::forward<T>(param));
}
則可以輸出預期的結果
傳入的是左值
傳入的是右值
參考博文
現代C++之萬能引用、完美轉發、引用折疊(萬字長文)：https://blog.csdn.net/guangcheng0312q/article/details/103572987
C++ 中的「移動」在內存或者寄存器中的操作是什麼，為什麼就比拷貝賦值性能高呢？：https://www.zhihu.com/question/55735384
一文讀懂C++右值引用和std::move：https://zhuanlan.zhihu.com/p/335994370
到此這篇關於c++中的std::move函數的文章就介紹到這瞭,更多相關c++ std::move函數內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！
推薦閱讀：
- C++右值引用與移動構造函數基礎與應用詳解
- 詳解C++右值引用
- C++ STL標準庫std::vector的使用詳解
- 解析C++11的std::ref、std::cref源碼
- C++中模板和STL介紹詳解