深入瞭解C++智慧指標的使用

2022-10-06 14:08:19

一、C++11智慧指標概述

在C++中，動態記憶體的使用時有一定的風險的，因為它沒有垃圾回收機制，很容易導致忘記釋放記憶體的問題，具體體現在異常的處理上。想要釋放掉拋異常的程式的一些記憶體，往往需要多次拋異常，這種處理方式是十分麻煩的。

智慧指標的本質就是使用一個物件來接管一段開闢的空間，在該物件在銷燬的時候，自動呼叫解構函式來釋放這段記憶體。

因此智慧指標的本質是一個類，類中最主要的物件是一個指標，該類的解構函式就是銷燬該指標指向的空間，使用智慧指標的本質就是將一個指向動態開闢空間的指標賦給該類中的指標。不過這樣的處理過程會有一定的問題，比如淺拷貝等。

C++標準庫提供了兩種智慧指標型別來管理動態物件，由於該物件的行為酷似指標，所以稱為智慧指標。它們分別是shared_ptr以及unique_ptr。還提供了一個weak_ptr它主要是為了解決shared_ptr的迴圈參照問題。

shared_ptr允許多個指標指向同一個物件，unique_ptr則獨佔所指向的物件。

二、C++98中的智慧指標

在很早以前，大佬們就已經認識到了記憶體釋放的問題，因此為標準庫中增加了一個類：auto_str。它有著和unique_str智慧指標類似的功能，它雖然成功的將一個開闢的資源塞給了一個類，不過存在很嚴重的問題，一些公司已經明令禁止使用它了：

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

此時如果對sptr1進行解除參照操作，會發生報錯。要了解報錯的原因，我們需要了解它的大致底層原理，作為第一個出現的智慧指標，它只是簡單執行了將資源轉移，以及在解構中加入資源釋放，還有一些解除參照的運運算元過載函數：

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;
    }
};

可以發現，最終是淺拷貝的鍋。因為在進行資源轉移的時候，必須將原來的指標置為nullptr，否則解構的時候會解構兩次。而將其置為nullptr之後再要使用該指標對其進行解除參照就會發生崩潰。

三、C++11中的智慧指標

1.unique_ptr

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

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

直接進行報錯處理。

我們也可以猜測出它的實現方式，那就是在拷貝構造和賦值構造的後面加上delete關鍵字。

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)參照計數器

shared_ptr是使用最多的智慧指標，即它可以進行拷貝構造。

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

    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)執行緒安全

涉及到共用，我們不得不將執行緒安全問題考慮進來，很顯然shared_ptr無論是要管理的資源的使用，還是要指向的該資源對應的計數器的加減操作，都不是執行緒安全的。

對於要管理的資源來說，如果多個執行緒不去使用該資源，是不會產生問題的。因此如果需要使用該資源由於程式碼量的不同位置，C++為了保證效能，希望使用者來自己保證它的執行緒安全，即由使用者自己來加鎖解鎖。
而對於資源計數器來說，只要增加一個智慧指標就會++，減少一個就會–，其邏輯明確簡單，因此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;//當為0的時候刪除計數器
            _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();//對管理的新資源的計數器進行++
        }
        return *this;
    }
    //獲取參照計數
    int use_count()
    {
        return *_pcount;
    }
    T& operator*()
    {
        return *_ptr;
    }
    T* operator->()
    {
        return _ptr;
    }
};

(3)刪除器

如果不是new出來的物件如何通過智慧指標進行管理呢？其實shared_ptr設計了一個刪除器來解決這一問題。

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進行初始化的時候就也可以進行清理空間了：

    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中的迴圈呼叫問題

迴圈呼叫問題在一些特殊的情況下會產生：

1.node1和node2兩個智慧指標指向兩個節點，參照計數變成1，我們不需要手動delete。

2.node1的_next指向node2，node2的_prev指向node1，參照計數變成2。

3.node1和node2解構，參照計數減到1，但是_next還指向下一個節點。但是_prev還指向上一個節點。

4.也就是說_next解構了，node2就釋放了。

5.也就是說_prev解構了，node1就釋放了。

6.但是_next屬於node的成員，node1釋放了，_next才會解構，而node1由_prev管理，_prev屬於node2成員，所

以這就叫回圈參照，誰也不會釋放。

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++智慧指標的使用的詳細內容，更多關於C++智慧指標的資料請關注it145.com其它相關文章！