深入了解C++智能指針的使用

更新時間：2022年10月04日 09:45:06 作者：賣寂寞的小男孩

智能指針的本質(zhì)就是使用一個對象來接管一段開辟的空間，在該對象在銷毀的時候，自動調(diào)用析構(gòu)函數(shù)來釋放這段內(nèi)存。本文就來和大家詳細(xì)聊聊智能指針的使用，需要的可以參考一下

一、C++11智能指針概述

在C++中，動態(tài)內(nèi)存的使用時有一定的風(fēng)險的，因為它沒有垃圾回收機(jī)制，很容易導(dǎo)致忘記釋放內(nèi)存的問題，具體體現(xiàn)在異常的處理上。想要釋放掉拋異常的程序的一些內(nèi)存，往往需要多次拋異常，這種處理方式是十分麻煩的。

智能指針的本質(zhì)就是使用一個對象來接管一段開辟的空間，在該對象在銷毀的時候，自動調(diào)用析構(gòu)函數(shù)來釋放這段內(nèi)存。

因此智能指針的本質(zhì)是一個類，類中最主要的對象是一個指針，該類的析構(gòu)函數(shù)就是銷毀該指針指向的空間，使用智能指針的本質(zhì)就是將一個指向動態(tài)開辟空間的指針賦給該類中的指針。不過這樣的處理過程會有一定的問題，比如淺拷貝等。

C++標(biāo)準(zhǔn)庫提供了兩種智能指針類型來管理動態(tài)對象，由于該對象的行為酷似指針，所以稱為智能指針。它們分別是shared_ptr以及unique_ptr。還提供了一個weak_ptr它主要是為了解決shared_ptr的循環(huán)引用問題。

shared_ptr允許多個指針指向同一個對象，unique_ptr則獨占所指向的對象。

二、C++98中的智能指針

在很早以前，大佬們就已經(jīng)認(rèn)識到了內(nèi)存釋放的問題，因此為標(biāo)準(zhǔn)庫中增加了一個類：auto_str。它有著和unique_str智能指針類似的功能，它雖然成功的將一個開辟的資源塞給了一個類，不過存在很嚴(yán)重的問題，一些公司已經(jīng)明令禁止使用它了：

    auto_ptr<int> sptr1(new int);
    auto_ptr<int> sptr2(sptr1);
    *sptr1;

此時如果對sptr1進(jìn)行解引用操作，會發(fā)生報錯。要了解報錯的原因，我們需要了解它的大致底層原理，作為第一個出現(xiàn)的智能指針，它只是簡單執(zhí)行了將資源轉(zhuǎn)移，以及在析構(gòu)中加入資源釋放，還有一些解引用的運(yùn)算符重載函數(shù)：

template<class T>
class MyAuto
{
private:
    T* _ptr;
public:
    MyAuto(T* ptr)
        :_ptr(ptr)
    {}
    ~MyAuto()
    {
        if (_ptr != nullptr)
        {
            cout << "delete: " << _ptr << endl;
            delete _ptr;
            _ptr = nullptr;
        }
    }
    MyAuto(MyAuto<T>& Ptr)
    {
        _ptr = Ptr._ptr;
        Ptr._ptr = nullptr;
    }
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
};

可以發(fā)現(xiàn)，最終是淺拷貝的鍋。因為在進(jìn)行資源轉(zhuǎn)移的時候，必須將原來的指針置為nullptr，否則析構(gòu)的時候會析構(gòu)兩次。而將其置為nullptr之后再要使用該指針對其進(jìn)行解引用就會發(fā)生崩潰。

三、C++11中的智能指針

1.unique_ptr

unique_ptr處理上述問題簡單而粗暴，即不讓進(jìn)行拷貝操作：

    unique_ptr<int> sptr1(new int);
    unique_ptr<int> sptr2(sptr1);

直接進(jìn)行報錯處理。

我們也可以猜測出它的實現(xiàn)方式，那就是在拷貝構(gòu)造和賦值構(gòu)造的后面加上delete關(guān)鍵字。

template<class T>
class MyUnique
{
private:
    T* _ptr;
public:
    MyUnique(T* ptr)
        :_ptr(ptr)
    {}
    ~MyUnique()
    {
        if (_ptr != nullptr)
        {
            cout << "delete: " << _ptr << endl;
            delete _ptr;
            _ptr = nullptr;
        }
    }
    MyUnique(MyUnique<T>& Ptr) = delete;
    MyUnique& operator=(MyUnique<T>& Ptr) = delete;
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
};

2.shared_ptr

(1)引用計數(shù)器

shared_ptr是使用最多的智能指針，即它可以進(jìn)行拷貝構(gòu)造。

每一個智能指針類都有一個專門用于記錄該智能指針指向的資源的指針個數(shù)的計數(shù)器。
當(dāng)多了一個智能指針指向該資源，則對所有指向該資源的智能指針的計數(shù)器進(jìn)行++操作，當(dāng)一個智能指針不再指向該資源的時候·，所有指向該資源的智能指針的計數(shù)器進(jìn)行–操作。
當(dāng)某一個智能指針將其–到0的時候由該智能指針釋放該資源。從而解決了不讓拷貝的根本問題：防止資源釋放多次。
同時智能指針有一個use_count函數(shù)來返回計數(shù)器的值。

    shared_ptr<int> sptr1(new int(1));
    shared_ptr<int> sptr2(sptr1);
    shared_ptr<int> sptr3(sptr2);
    cout << sptr1.use_count() << endl;
    cout << sptr2.use_count() << endl;
    cout << sptr2.use_count() << endl;
    cout << "資源釋放成功" << endl;

(2)線程安全

涉及到共享，我們不得不將線程安全問題考慮進(jìn)來，很顯然shared_ptr無論是要管理的資源的使用，還是要指向的該資源對應(yīng)的計數(shù)器的加減操作，都不是線程安全的。

對于要管理的資源來說，如果多個線程不去使用該資源，是不會產(chǎn)生問題的。因此如果需要使用該資源由于代碼量的不同位置，C++為了保證性能，希望用戶來自己保證它的線程安全，即由用戶自己來加鎖解鎖。
而對于資源計數(shù)器來說，只要增加一個智能指針就會++，減少一個就會–，其邏輯明確簡單，因此shared_ptr為其加了鎖。

template<class T>
class MyShared
{
private:
    T* _ptr;
    mutex* _pmtx;
    int* _pcount;
public:
    MyShared(T* ptr)
        :_ptr(ptr),
        _pmtx(new mutex),
        _pcount(new int(1))
    {}
    void AddCount()
    {
        _pmtx->lock();
        (*_pcount)++;
        _pmtx->unlock();
    }
    void DelCount()
    {
        _pmtx->lock();
        bool flag = false;
        if (--(*_pcount) == 0)
        {
            if (_ptr != nullptr)
            {
                cout << "delete: " << _ptr << endl;
                delete _ptr;
                _ptr = nullptr;
            }
            delete _pcount;//當(dāng)為0的時候刪除計數(shù)器
            _pcount = nullptr;
            flag = true;
        }
        _pmtx->unlock();
        if (flag == true)
        {
            delete _pmtx;
            _pmtx = nullptr;
        }
    }
    MyShared(MyShared<T>& sp)
        :_ptr(sp._ptr),
        _pcount(sp._pcount),
        _pmtx(sp._pmtx)
    {
        AddCount();
    }
    MyShared& operator=(MyShared<T>& sp)
    {
        if (_ptr != sp._ptr)
        {
            DelCount();//釋放管理的舊資源
            _ptr = sp._ptr;
            _pcount = sp._pcount;
            _pmtx = sp._pmtx;
            AddCount();//對管理的新資源的計數(shù)器進(jìn)行++
        }
        return *this;
    }
    //獲取引用計數(shù)
    int use_count()
    {
        return *_pcount;
    }
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
};

(3)刪除器

如果不是new出來的對象如何通過智能指針進(jìn)行管理呢？其實shared_ptr設(shè)計了一個刪除器來解決這一問題。

template<class T>
struct FreeFunc
{
    void operator()(T* ptr)
    {
        cout << "free:" << ptr << endl;
        free(ptr);
    }
};
template<class T>
struct DeleteArrayFunc
{
    void operator()(T* ptr)
    {
        cout << "delete[]" << ptr << endl;
        delete[] ptr;
    }

???????};

此時使用malloc進(jìn)行初始化的時候就也可以進(jìn)行清理空間了：

    FreeFunc<int> freeFunc;
    shared_ptr<int> sp1((int*)malloc(4), freeFunc);
    DeleteArrayFunc<int> deleteArrayFunc;
    shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);

3.weak_ptr

(1)shared_ptr中的循環(huán)調(diào)用問題

循環(huán)調(diào)用問題在一些特殊的情況下會產(chǎn)生：

1.node1和node2兩個智能指針指向兩個節(jié)點，引用計數(shù)變成1，我們不需要手動delete。

2.node1的_next指向node2，node2的_prev指向node1，引用計數(shù)變成2。

3.node1和node2析構(gòu)，引用計數(shù)減到1，但是_next還指向下一個節(jié)點。但是_prev還指向上一個節(jié)點。

4.也就是說_next析構(gòu)了，node2就釋放了。

5.也就是說_prev析構(gòu)了，node1就釋放了。

6.但是_next屬于node的成員，node1釋放了，_next才會析構(gòu)，而node1由_prev管理，_prev屬于node2成員，所

以這就叫循環(huán)引用，誰也不會釋放。

struct ListNode
{
    shared_ptr<ListNode> _next;
    shared_ptr<ListNode> _prev;
};
    shared_ptr<ListNode> node1(new ListNode);
    shared_ptr<ListNode> node2(new ListNode);
    node1 ->_next = node2;
    node2 -> _prev = node1;

通俗來講，就是此時如果想釋放node2，那么就需要delete(n1->next)，但是如果要釋放n1->next就必須delete(n1)，而要deleten1又需要delete(node2->prev)因此如果不讓prev指向n就沒有問題。

(2)weak_ptr

struct ListNode
{
	std::weak_ptr<ListNode> _next;
	std::weak_ptr<ListNode> _prev;
	int _val;
	~ListNode()
	{
		cout << "~ListNode()" << endl;
	}
};
int main()
{
	std::shared_ptr<ListNode> node1(new ListNode);
	std::shared_ptr<ListNode> node2(new ListNode);

	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	node1->_next = node2;
	node2->_prev = node1;
	//...
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}

以上就是深入了解C++智能指針的使用的詳細(xì)內(nèi)容，更多關(guān)于C++智能指針的資料請關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: