C++移動語義詳細介紹使用
1.移動構造函數
移動語義就是使用移動構造函數來構造對象。
我們知道在類中如果存在指針數據成員,那麼我們就一定要寫拷貝構造函數,進行深拷貝
如下所示,就是拷貝構造函數的用法:
#include<iostream>
using namespace std;
class A
{
public:
int * ptr;
A():ptr(new int(0))
{
cout<<"constructor\n";
};
A(const A & h):ptr(new int(*h.ptr))//拷貝構造函數
{
cout<<"copy constructor\n";
//deep copy
};
~A()
{
cout<<"destructor\n";
delete ptr;
};
};
A getA()
{
return A();
}
int main()
{
A a=getA();
}
//g++ .\test.cpp -std=c++11 -fno-elide-constructors
constructor
copy constructor
destructor
copy constructor
destructor
destructor
可以知道上面代碼中,實際上產生瞭3個對象,在getA()函數中,使用默認構造函數產生一個對象,然後將其作為返回值時,又會通過拷貝構造函數產生一個對象,然後在main()函數中,又會通過拷貝構造函數構造出對象a,所以總共有3個對象產生,我們這裡的拷貝構造函數是進行的深拷貝,所以就會開辟3塊內存.
在C++11中,我們可以使用移動構造函數,對上述代碼進行優化
#include<iostream>
using namespace std;
class A
{
public:
int * ptr;
A():ptr(new int(0))
{
cout<<"constructor\n";
};
A(const A & h):ptr(new int(*h.ptr))//拷貝構造函數
{
cout<<"copy constructor\n";
//deep copy
};
A(A && h):ptr(h.ptr)//移動構造函數
{
h.ptr=nullptr;
cout<<"move constructor\n";
}
~A()
{
cout<<"destructor\n";
delete ptr;
};
};
A getA()
{
return A();
}
int main()
{
A a=getA();
}
//g++ .\test.cpp -std=c++11 -fno-elide-constructors
constructor
move constructor
destructor
move constructor
destructor
destructor
移動構造函數,它是進行的淺拷貝,由於被移動的值會立即進行析構,所以我們不關心它,隻需進行淺拷貝,將其開辟的內存空間轉讓給別人。上述代碼中,也會構造出3個對象,但是它們隻開辟一塊內存空間,這就是移動構造函數的優勢。
總之,我們發現移動構造函數和拷貝構造函數的區別,其實就是深拷貝和淺拷貝的區別,移動構造函數的開銷更小,當然我們關心的是,移動構造函數何時會被觸發?在上面代碼中就是一個例子,將getA()中的局部匿名對象移動給返回值,然後將返回值移動給 main()中的a。
這裡我們給出結論:移動構造函數隻有在使用右值或右值引用來構造對象時才會調用
那麼什麼是右值?
在getA()中的A()就是右值,getA()的返回值也是右值,所以用它們構造對象時,會調用移動構造函數
那麼什麼是右值引用?
顧名思義就是右值的引用
2.右值引用
在C++11中,我們將值劃分為:左值、右值（分為將亡值和純右值）
左值:可以取地址,有名字的值
右值:不能取地址,沒有名字的值
純右值:運算表達式,如1+2,或者和對象無關的字面值,如true,或者非引用的函數返回值,或者lambda表達式
將亡值:僅和右值引用相關的值,它包括:右值引用的函數返回值T&&,或者std::move的返回值,或者被轉換為T&&類型的函數返回值
註意:不管是純右值還是將亡值,它們的存活時間都很短。不要被將亡值的名稱所迷惑瞭,其實所以右值的都會即將消亡。
實際上,對於純右值和將亡值的定義很難給出,而且我們也不需要區分它們兩,但是,我們至少可以確定一個值是左值還是右值。
C++98中所提及的引用,在C++11中我們稱之為左值引用,即這個引用隻能綁定左值,在C++11中我們提供瞭一種新的能夠綁定右值的引用,即右值引用。
我們知道左值引用實際是一個變量的別名,右值引用它實際是一個匿名變量的別名
#include<iostream>
using namespace std;
class A
{
public:
int * ptr;
A():ptr(new int(0))
{
cout<<"constructor\n";
};
A(const A & h):ptr(new int(*h.ptr))//拷貝構造函數
{
cout<<"copy constructor\n";
//deep copy
};
A(A && h):ptr(h.ptr)//移動構造函數
{
h.ptr=nullptr;
cout<<"move constructor\n";
}
~A()
{
cout<<"destructor\n";
delete ptr;
};
};
A getA()
{
return A();
}
int main()
{
A&& a=getA();//右值引用
}
constructor
move constructor
destructor
destructor
在上述代碼中getA()的返回值是一個右值,它是一個臨時值,如果我們寫成A a=getA();,那麼這個臨時值給a進行移動構造後就會立即被析構,而如果我們使用A&& a=getA();,那就意味著我們給這個臨時值進行續命,a就是這個臨時值的別名,所以上述代碼就會少一個對象的構造。
總之,右值引用就是一種綁定右值的引用,實際上在C++98中,我們所知的const T &,這樣的引用,也可以綁定右值,他也叫做萬能引用,當他綁定右值的時候它的作用和右值引用是一樣的,隻不過這裡的const是底層的,所以我們不能用其修改右值,所以右值引用綁定右值時,可以修改該右值,而當萬能引用綁定右值時,我們不可以修改該右值
T& a;//左值引用,隻能綁定非常量左值 T&& a;//右值引用,隻能綁定非常量右值 const T& a;//萬能引用,它可以綁定一切值,但是它不能修改該值 const T&& a;//和萬能引用功能一樣(一般不使用)
我們仔細來思索一下右值引用的用處,從本質上講,它是給右值進行續命,而從實踐上講,它就是用來移動語義的,但是移動語義的時候,我們希望修改原來的右值(看上面代碼中的移動構造函數,它實際上修改瞭右值),所以我們說const T&&這種是無用的,
我們在學習瞭C++11中的移動語義和右值引用知識後,我們要深知一個編程規矩:
隻要類中有指針數據成員,就一定要重寫拷貝構造函數和移動構造函數
3.std::move()將左值強制轉換為右值引用
看一下下面這段代碼
#include<iostream>
using namespace std;
class A
{
public:
int * ptr;
A():ptr(new int(0))
{
cout<<"constructor\n";
};
A(const A & h):ptr(new int(*h.ptr))//拷貝構造函數
{
cout<<"copy constructor\n";
//deep copy
};
A(A && h):ptr(h.ptr)//移動構造函數
{
h.ptr=nullptr;
cout<<"move constructor\n";
}
~A()
{
cout<<"destructor\n";
delete ptr;
};
};
A&& getA()
{
return std::move(A());
}
int main()
{
A&& a=getA();
}
constructor
destructor
在getA()中的A()是右值,為什麼還要用std::move將其轉換為右值引用?因為A()是一個純右值,右值引用當然可以綁定純右值,但是A()是一個局部對象,在函數中返回引用時,我們禁止返回局部對象的引用,但是當我們使用std::move後,A()就會轉換為右值引用類型,這樣子就可以將其作為引用返回。這是一種返回局部對象引用的特殊方法。
註意,這是一個涉及原則的問題,匿名對象是純右值
class A
{};
int main()
{
A& a=A();//報錯,左值引用無法綁定純右值
}
實際上,std::move()等價於static_cast<T&&>(lvalue),即將左值轉換為右值引用。
但是,std::move()有一個bug,即被轉化為右值引用的左值,不會被立即析構。
#include<iostream>
using namespace std;
class A
{
public:
int* ptr;
A():ptr(new int(999)){}
~A(){delete ptr;}
A(const A& h):ptr(new int(*h.ptr)){}
A(A&& h):ptr(h.ptr)
{
h.ptr=nullptr;
}
};
int main()
{
A a;
A b(std::move(a));
cout<<*a.ptr<<endl;//報錯
}
上述代碼就會報錯,因為a被轉化為右值引用後,b會調用移動構造函數來構造它自己,而在移動構造函數中,它將a.ptr置空
#include<utility>
class A
{
public:
int *ptr;
A():ptr(new int(0)){}
~A(){delete ptr;}
A(const A& h):ptr(new int(*h.ptr)){}
A(A&& h):ptr(h.ptr){h.ptr=nullptr;}
};
class B
{
public:
int *ptr;
A elem;
B():ptr(new int(0)){}
~B(){delete ptr;}
B(const B&h):ptr(new int(*h.ptr)),elem(h.elem){}
B(B&& h):ptr(h.ptr),elem(std::move(h.elem)){h.ptr=nullptr;}
};
註意看,B(const B&h):ptr(new int(*h.ptr)),elem(h.elem){}中對elem的初始化使用的是A的拷貝構造函數,
而B(B&& h):ptr(h.ptr),elem(std::move(h.elem)){h.ptr=nullptr;}中對elem的初始化使用的是是A的移動構造函數. 註意一點,即使這裡我們忘記寫std::move()也並無大礙,它會自行調用拷貝構造函數,當然這也會導致一些開銷,所以在做類開發的時候,在寫類的移動構造函數的時候,總是要記得將類成員move成右值引用。
4.拷貝語義和移動語義
如果一個類支持拷貝構造函數和拷貝賦值函數,那麼我們就稱該類具有拷貝語義;同樣的如果一個類支持移動構造函數和移動賦值函數,那麼我們就稱該類具有移動語義。
當然有些類是同時支持移動語義和拷貝語義的。
在C++98中的類基本都是隻具有拷貝語義的,而在C++11中的基本所有類都支持移動語義,特別的,有些類隻支持移動語義,而不支持拷貝語義,這種類,我們稱之為資源型類,即資源隻能被移動而不能被拷貝,例如智能指針類unique_ptr,文件流ifstream等都是資源型類,在C++11中,我們可以通過一些工具來判斷一個類是否支持移動語義。
我們看一下下面的代碼
template <class T>
void swap(T& a, T& b)
{
T tmp(move(a));
a=move(b);
b=move(tmp);
}
上述代碼中,如果T支持移動語義,那麼它就會調用移動構造函數和移動賦值函數,而如果T隻支持拷貝語義,那麼它也可以調用拷貝構造函數和拷貝賦值函數
我們關於移動語義的另一個話題是:異常。因為如果移動語義沒有完成,卻拋出異常,那麼可能會導致產生懸掛指針。所以在C++11中我們同樣有std::move_if_noexcept()函數來檢測,移動構造函數是否用noexcept修飾。
再討論一個關於編譯器優化的問題,如今c++編譯器已經非常優化瞭,RVO機制,即所謂返回值優化機制,他能幫你完成類似移動語義的智能優化,但是要記住,編譯器優化不是完全奏效的,最好還是自己提高代碼效率。
到此這篇關於C++移動語義詳細介紹使用的文章就介紹到這瞭,更多相關C++移動語義內容請搜索WalkonNet以前的文章或繼續瀏覽下面的相關文章希望大傢以後多多支持WalkonNet！