一文搞懂c++中的std::move函數
前言
在探討c++11中的Move函數前，先介紹兩個概念（左值和右值）
左值和右值
首先區(qū)分左值和右值
左值是表達式結束后依然存在的持久對象(代表一個在內存中占有確定位置的對象)
右值是表達式結束時不再存在的臨時對象(不在內存中占有確定位置的表達式）
便攜方法：對表達式取地址，如果能，則為左值，否則為右值
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的實現(xiàn)：
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源碼剖析
轉發(fā)左值
template<typename _Tp>
constexpr _Tp&&
forward(typename std::remove_reference<_Tp>::type& __t) noexcept
{ return static_cast<_Tp&&>(__t); }先通過獲得類型type，定義_t為左值引用的左值變量，通過static_cast進行強制轉換。_Tp&&會發(fā)生引用折疊，當_Tp推導為左值引用，則折疊為_Tp& &&，即_Tp&，當推導為右值引用，則為本身_Tp&&，即forward返回值與static_cast處都為_Tp&&。
轉發(fā)右值
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);
}
不同于轉發(fā)左值，_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轉換)而已。真正的移動操作是在移動構造函數或者移動賦值操作符中發(fā)生的
- 在類型聲明當中， “&&” 要不就是一個 rvalue reference ，要不就是一個 universal reference – 一種可以解析為lvalue reference或者rvalue reference的引用。對于某個被推導的類型T，universal references 總是以 T&& 的形式出現(xiàn)。
- 引用折疊是 會讓 universal references (其實就是一個處于引用折疊背景下的rvalue references ) 有時解析為 lvalue references 有時解析為 rvalue references 的根本機制。引用折疊只會在一些特定的可能會產生"引用的引用"場景下生效。這些場景包括模板類型推導，auto 類型推導， typedef 的形成和使用，以及decltype 表達式。
std::move使用場景
在實際場景中，右值引用和std::move被廣泛用于在STL和自定義類中實現(xiàn)移動語義，避免拷貝，從而提升程序性能。 在沒有右值引用之前，一個簡單的數組類通常實現(xiàn)如下，有構造函數、拷貝構造函數、賦值運算符重載、析構函數等。深拷貝/淺拷貝在此不做講解。
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_;
};
該類的拷貝構造函數、賦值運算符重載函數已經通過使用左值引用傳參來避免一次多余拷貝了，但是內部實現(xiàn)要深拷貝，無法避免。 這時，有人提出一個想法：是不是可以提供一個移動構造函數，把被拷貝者的數據移動過來，被拷貝者后邊就不要了，這樣就可以避免深拷貝了，如：
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個問題：
- 不優(yōu)雅，表示移動語義還需要一個額外的參數(或者其他方式)。
- 無法實現(xiàn)！
temp_array是個const左值引用，無法被修改，所以temp_array.data_ = nullptr;這行會編譯不過。當然函數參數可以改成非const：Array(Array& temp_array, bool move){...}，這樣也有問題，由于左值引用不能接右值，Array a = Array(Array(), true);這種調用方式就沒法用了。
可以發(fā)現(xiàn)左值引用真是用的很不爽，右值引用的出現(xiàn)解決了這個問題，在STL的很多容器中，都實現(xiàn)了以右值引用為參數的移動構造函數和移動賦值重載函數，或者其他函數，最常見的如std::vector的push_back和emplace_back。參數為左值引用意味著拷貝，為右值引用意味著移動。
class Array {
public:
......
// 優(yōu)雅
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); // 傳統(tǒng)方法，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中生成移動語義函數，但前提是用戶沒有主動定義該類的拷貝構造等函數(具體規(guī)則自行百度哈)。 因此，可移動對象在<需要拷貝且被拷貝者之后不再被需要>的場景，建議使用std::move觸發(fā)移動語義，提升性能。
還有些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本身只做類型轉換，對性能無影響。 我們可以在自己的類中實現(xiàn)移動語義，避免深拷貝，充分利用右值引用和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中的每一個元素執(zhí)行一個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&&類型的形參既能綁定右值，又能綁定左值
但是注意了：只有發(fā)生類型推導的時候，T&&才表示萬能引用（如模板函數傳參就會經過類型推導的過程）；否則，表示右值引用
所以，上面的案例我們可以修改為
template<typename T>
void func(T&& param) {
cout << param << endl;
}
int main() {
int num = 2019;
func(num);
func(2019);
return 0;
}引用折疊
萬能引用說完了，接著來聊引用折疊（Reference Collapse），因為完美轉發(fā)（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++中不允許對引用再進行引用，對于上述情況的處理有如下的規(guī)則：
所有的折疊引用最終都代表一個引用，要么是左值引用，要么是右值引用。規(guī)則是：如果任一引用為左值引用，則結果為左值引用。否則（即兩個都是右值引用），結果才是右值引用
即就是前面三種情況代表的都是左值引用，而第四種代表的右值引用
完美轉發(fā)
下面接著說完美轉發(fā)（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()函數調用實參是右值，根據上面所說的引用折疊規(guī)則，warp()函數接收的參數類型是右值引用，那么為什么卻調用了調用func()的左值版本了呢？這是因為在warp()函數內部，右值引用類型變?yōu)榱俗笾?，因為參數有了名稱，我們也通過變量名取得變量地址
那么問題來了，怎么保持函數調用過程中，變量類型的不變呢？這就是我們所謂的“變量轉發(fā)”技術，在C++11中通過std::forward()函數來實現(xiàn)。我們來修改我們的warp()函數如下：
template<typename T>
void warp(T&& param) {
func(std::forward<T>(param));
}
則可以輸出預期的結果
傳入的是左值
傳入的是右值
參考博文
現(xiàn)代C++之萬能引用、完美轉發(fā)、引用折疊(萬字長文)：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函數內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！
相關文章
C++標準模板庫（STL）提供了多種容器類型,包括順序容器、關聯(lián)容器、無序關聯(lián)容器和容器適配器,每種容器都有其特定的用途和特性,這篇文章主要介紹了C++中使用vector存儲并遍歷數據的基本步驟,需要的朋友可以參考下2025-01-01
這篇文章主要給大家介紹了關于C語言中長度為0的數組，文中通過示例代碼介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面隨著小編來一起學習學習吧2021-10-10
這篇文章主要為大家詳細介紹了C語言實現(xiàn)學籍管理系統(tǒng)，文中示例代碼介紹的非常詳細，具有一定的參考價值，感興趣的小伙伴們可以參考一下2022-03-03
C++中有兩種類型的枚舉：不限定作用域的枚舉類型和限定作用域的枚舉類型。限定作用域的枚舉類型是C++11標準引入的新類型，對C++11中限定作用域的枚舉類型相關知識感興趣的朋友一起看看吧2022-01-01
這篇文章主要為大家詳細介紹了C++中指針的相關知識，文中的示例代碼講解詳細，對我們的學習或工作有一定的價值，感興趣的小伙伴可以了解一下2023-03-03
冒泡排序是一種簡單排序。這種排序是采用“冒泡策略”將最大元素移到最右邊。在冒泡過程中，相鄰兩個元素比較，如果左邊大于右邊的，則進行交換兩個元素。這樣一次冒泡后，可確保最大的在最右邊。然后執(zhí)行n次冒泡后排序即可完畢2013-04-04
這篇文章主要為大家介紹了C語言驅動開發(fā)內核特征碼掃描PE代碼段，有需要的朋友可以借鑒參考下，希望能夠有所幫助，祝大家多多進步，早日升職加薪2022-10-10
貪心算法（又稱貪婪算法）是指，在對問題求解時，總是做出在當前看來是最好的選擇。也就是說，不從整體最優(yōu)上加以考慮，他所做出的僅是在某種意義上的局部最優(yōu)解2022-06-06
PCM(Pulse Code Modulation)也被稱為脈沖編碼調制，是數字通信的編碼方式之一。這篇文章主要和大家聊聊C++中音頻PCM數據的相關操作，需要的可以參考一下2023-02-02
這篇文章主要為大家詳細介紹了Qt實現(xiàn)的一個簡單的編輯框操作——主窗口失去焦點隱藏功能，文中的示例代碼講解詳細，感興趣的小伙伴可以了解一下2022-10-10