C語言智能指針之weak_ptr淺析

Posted on by

前言

weak_ptr這個指針天生一副“小弟”的模樣，也是在C++11的時候引入的標準庫，它的出現完全是為瞭彌補它老大shared_ptr天生有缺陷的問題，其實相比於上一代的智能指針auto_ptr來說，新進老大shared_ptr可以說近乎完美，但是通過引用計數實現的它，雖然解決瞭指針獨占的問題，但也引來瞭引用成環的問題，這種問題靠它自己是沒辦法解決的，所以在C++11的時候將shared_ptr和weak_ptr一起引入瞭標準庫，用來解決循環引用的問題。

weak_ptr本身也是一個模板類，但是不能直接用它來定義一個智能指針的對象，隻能配合shared_ptr來使用，可以將shared_ptr的對象賦值給weak_ptr，並且這樣並不會改變引用計數的值。查看weak_ptr的代碼時發現，它主要有lock、swap、reset、expired、operator=、use_count幾個函數，與shared_ptr相比多瞭lock、expired函數，但是卻少瞭get函數，甚至連operator* 和 operator->都沒有，可用的函數數量少的可憐，下面通過一些例子來瞭解一下weak_ptr的具體用法。

使用環境

1.VS2015 + Windows7（應該是C++11標準）

2.頭文件#include <memory>

3.命名空間using namespace std;

測試過程

1.weak_ptr解決shared_ptr循環引用的問題

定義兩個類，每個類中又包含一個指向對方類型的智能指針作為成員變量，然後創建對象，設置完成後查看引用計數後退出，看一下測試結果：

class CB;
class CA
{
public:
    CA() { cout << "CA() called! " << endl; }
    ~CA() { cout << "~CA() called! " << endl; }
    void set_ptr(shared_ptr<CB>& ptr) { m_ptr_b = ptr; }
    void b_use_count() { cout << "b use count : " << m_ptr_b.use_count() << endl; }
    void show() { cout << "this is class CA!" << endl; }
private:
    shared_ptr<CB> m_ptr_b;
};
class CB
{
public:
    CB() { cout << "CB() called! " << endl; }
    ~CB() { cout << "~CB() called! " << endl; }
    void set_ptr(shared_ptr<CA>& ptr) { m_ptr_a = ptr; }
    void a_use_count() { cout << "a use count : " << m_ptr_a.use_count() << endl; }
    void show() { cout << "this is class CB!" << endl; }
private:
    shared_ptr<CA> m_ptr_a;
};
void test_refer_to_each_other()
{
    shared_ptr<CA> ptr_a(new CA());
    shared_ptr<CB> ptr_b(new CB());
    cout << "a use count : " << ptr_a.use_count() << endl;
    cout << "b use count : " << ptr_b.use_count() << endl;
    ptr_a->set_ptr(ptr_b);
    ptr_b->set_ptr(ptr_a);
    cout << "a use count : " << ptr_a.use_count() << endl;
    cout << "b use count : " << ptr_b.use_count() << endl;
}

測試結果如下：

CA() called!
CB() called!
a use count : 1
b use count : 1
a use count : 2
b use count : 2

通過結果可以看到，最後CA和CB的對象並沒有被析構，其中的引用效果如下圖所示，起初定義完ptr_a和ptr_b時，隻有①③兩條引用，然後調用函數set_ptr後又增加瞭②④兩條引用，當test_refer_to_each_other這個函數返回時，對象ptr_a和ptr_b被銷毀，也就是①③兩條引用會被斷開，但是②④兩條引用依然存在，每一個的引用計數都不為0，結果就導致其指向的內部對象無法析構，造成內存泄漏。

wk_shared_ptr

解決這種狀況的辦法就是將兩個類中的一個成員變量改為weak_ptr對象，因為weak_ptr不會增加引用計數，使得引用形不成環，最後就可以正常的釋放內部的對象，不會造成內存泄漏，比如將CB中的成員變量改為weak_ptr對象，代碼如下：

class CB
{
public:
    CB() { cout << "CB() called! " << endl; }
    ~CB() { cout << "~CB() called! " << endl; }
    void set_ptr(shared_ptr<CA>& ptr) { m_ptr_a = ptr; }
    void a_use_count() { cout << "a use count : " << m_ptr_a.use_count() << endl; }
    void show() { cout << "this is class CB!" << endl; }
private:
    weak_ptr<CA> m_ptr_a;
};

測試結果如下：

CA() called!
CB() called!
a use count : 1
b use count : 1
a use count : 1
b use count : 2
~CA() called!
~CB() called!

通過這次結果可以看到，CA和CB的對象都被正常的析構瞭，引用關系如下圖所示，流程與上一例子相似，但是不同的是④這條引用是通過weak_ptr建立的，並不會增加引用計數，也就是說CA的對象隻有一個引用計數，而CB的對象隻有2個引用計數，當test_refer_to_each_other這個函數返回時，對象ptr_a和ptr_b被銷毀，也就是①③兩條引用會被斷開，此時CA對象的引用計數會減為0，對象被銷毀，其內部的m_ptr_b成員變量也會被析構，導致CB對象的引用計數會減為0，對象被銷毀，進而解決瞭引用成環的問題。

wk_weak_ptr

2. 測試weak_ptr對引用計數的影響

其實weak_ptr本身設計的很簡單，就是為瞭輔助shared_ptr的，它本身不能直接定義指向原始指針的對象，隻能指向shared_ptr對象，同時也不能將weak_ptr對象直接賦值給shared_ptr類型的變量，最重要的一點是賦值給它不會增加引用計數：

void test1()
{
    // 編譯錯誤 // error C2665: “std::weak_ptr<CA>::weak_ptr”: 3 個重載中沒有一個可以轉換所有參數類型
    // weak_ptr<CA> ptr_1(new CA());
    shared_ptr<CA> ptr_1(new CA());
    cout << "ptr_1 use count : " << ptr_1.use_count() << endl; // 輸出：ptr_1 use count : 1
    shared_ptr<CA> ptr_2 = ptr_1;
    cout << "ptr_1 use count : " << ptr_1.use_count() << endl; // 輸出：ptr_1 use count : 2
    cout << "ptr_2 use count : " << ptr_2.use_count() << endl; // 輸出：ptr_1 use count : 2
    weak_ptr<CA> wk_ptr = ptr_1;
    cout << "ptr_1 use count : " << ptr_1.use_count() << endl; // 輸出：ptr_1 use count : 2
    cout << "ptr_2 use count : " << ptr_2.use_count() << endl; // 輸出：ptr_1 use count : 2
    // 編譯錯誤
    // error C2440 : “初始化”: 無法從“std::weak_ptr<CA>”轉換為“std::shared_ptr<CA>”
    // shared_ptr<CA> ptr_3 = wk_ptr;
}

測試weak_ptr常用函數的用法

weak_ptr中隻有函數lock和expired兩個函數比較重要，因為它本身不會增加引用計數，所以它指向的對象可能在它用的時候已經被釋放瞭，所以在用之前需要使用expired函數來檢測是否過期，然後使用lock函數來獲取其對應的shared_ptr對象，然後進行後續操作：

void test2()
{
    shared_ptr<CA> ptr_a(new CA());     // 輸出：CA() called!
    shared_ptr<CB> ptr_b(new CB());     // 輸出：CB() called!
    cout << "ptr_a use count : " << ptr_a.use_count() << endl; // 輸出：ptr_a use count : 1
    cout << "ptr_b use count : " << ptr_b.use_count() << endl; // 輸出：ptr_b use count : 1
    weak_ptr<CA> wk_ptr_a = ptr_a;
    weak_ptr<CB> wk_ptr_b = ptr_b;
    if (!wk_ptr_a.expired())
    {
        wk_ptr_a.lock()->show();        // 輸出：this is class CA!
    }
    if (!wk_ptr_b.expired())
    {
        wk_ptr_b.lock()->show();        // 輸出：this is class CB!
    }
    // 編譯錯誤
    // 編譯必須作用於相同的指針類型之間
    // wk_ptr_a.swap(wk_ptr_b);         // 調用交換函數
    wk_ptr_b.reset();                   // 將wk_ptr_b的指向清空
    if (wk_ptr_b.expired())
    {
        cout << "wk_ptr_b is invalid" << endl;  // 輸出：wk_ptr_b is invalid 說明改指針已經無效
    }
    wk_ptr_b = ptr_b;
    if (!wk_ptr_b.expired())
    {
        wk_ptr_b.lock()->show();        // 輸出：this is class CB! 調用賦值操作後，wk_ptr_b恢復有效
    }
    // 編譯錯誤
    // 編譯必須作用於相同的指針類型之間
    // wk_ptr_b = wk_ptr_a;

    // 最後輸出的引用計數還是1，說明之前使用weak_ptr類型賦值，不會影響引用計數
    cout << "ptr_a use count : " << ptr_a.use_count() << endl; // 輸出：ptr_a use count : 1
    cout << "ptr_b use count : " << ptr_b.use_count() << endl; // 輸出：ptr_b use count : 1
}

現象分析

引用計數的出現，解決瞭對象獨占的問題，但是也帶來瞭循環引用的困擾，使用weak_ptr可以打破這種循環，當你理不清引用關系的時候，不妨采用文中畫圖的方式來理一理頭緒，或許就會有眼前一亮的感覺。

總結 weak_ptr雖然是一個模板類，但是不能用來直接定義指向原始指針的對象。weak_ptr接受shared_ptr類型的變量賦值，但是反過來是行不通的，需要使用lock函數。weak_ptr設計之初就是為瞭服務於shared_ptr的，所以不增加引用計數就是它的核心功能。由於不知道什麼之後weak_ptr所指向的對象就會被析構掉，所以使用之前請先使用expired函數檢測一下。 測試源碼

總結

本篇文章就到這裡瞭，希望能夠給你帶來幫助，也希望您能夠多多關註WalkonNet的更多內容！

推薦閱讀：