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!

推薦閱讀: