Make_shared - 自己實現

Question

我努力使自己實現shared_ptr。我遇到問題make_shared。的std::make_shared的主要特徵在於它分配計數器塊和對象在連續的存儲器塊。我如何做同樣的事情？

我試圖做這樣的事情：

template<class T> 
class shared_ptr 
{ 
private: 
    class _ref_cntr 
    { 
    private: 
     long counter; 

    public: 
     _ref_cntr() : 
      counter(1) 
     { 
     } 

     void inc() 
     { 
      ++counter; 
     } 

     void dec() 
     { 
      if (counter == 0) 
      { 
       throw std::logic_error("already zero"); 
      } 

      --counter; 
     } 

     long use_count() const 
     { 
      return counter; 
     } 
    }; 

    template<class _T> 
    struct _object_and_block 
    { 
     _T object; 
     _ref_cntr cntr_block; 

     template<class ... Args> 
     _object_and_block(Args && ...args) : 
      object(args...) 
     { 
     } 
    }; 

    T* _obj_ptr; 
    _ref_cntr* _ref_counter; 

    void _check_delete_ptr() 
    { 
     if (_obj_ptr == nullptr) 
     { 
      return; 
     } 

     _ref_counter->dec(); 

     if (_ref_counter->use_count() == 0) 
     { 
      _delete_ptr(); 
     } 

     _obj_ptr = nullptr; 
     _ref_counter = nullptr; 
    } 

    void _delete_ptr() 
    { 
     delete _ref_counter; 
     delete _obj_ptr; 
    } 

    template<class _T, class ... Args> 
    friend shared_ptr<_T> make_shared(Args && ... args); 

public: 
    shared_ptr() : 
     _obj_ptr(nullptr), 
     _ref_counter(nullptr) 
    { 
    } 

    template<class _T> 
    explicit shared_ptr(_T* ptr) 
    { 
     _ref_counter = new counter_block(); 
     _obj_ptr = ptr; 
    } 

    template<class _T> 
    shared_ptr(const shared_ptr<_T> & other) 
    { 
     *this = other; 
    } 

    template<class _T> 
    shared_ptr<T> & operator=(const shared_ptr<_T> & other) 
    { 
     _obj_ptr = other._obj_ptr; 
     _ref_counter = other._ref_counter; 

     _ref_counter->inc(); 

     return *this; 
    } 

    ~shared_ptr() 
    { 
     _check_delete_ptr(); 
    } 

}; 

template<class T, class ... Args> 
shared_ptr<T> make_shared(Args && ... args) 
{ 
    shared_ptr<T> ptr; 
    auto tmp_object = new shared_ptr<T>::_object_and_block<T>(args...); 
    ptr._obj_ptr = &tmp_object->object; 
    ptr._ref_counter = &tmp_object->cntr_block; 

    return ptr; 
} 

但是當我刪除對象和計數器塊，無效的堆塊發生異常。

Answer 1

注： _T是reserved name，你不能使用它自己的類型/變量/參數等

的名字的問題是在這裏：

void _delete_ptr() 
{ 
    delete _ref_counter; 
    delete _obj_ptr; 
} 

這是錯誤的，make_shared情況，因爲你沒有分配兩個單獨的對象。

Boost和GCC的shared_ptr中的make_shared採用的方法是使用新的派生類型的控制塊，其中包括基類中的引用計數併爲派生類型中的被管理對象添加存儲空間。如果你讓_ref_cntr負責通過虛擬函數刪除對象，那麼派生類型可以覆蓋該虛函數以做一些不同的事情（例如，只使用顯式析構函數調用來銷燬對象而不釋放存儲）。

如果你給_ref_cntr虛析構函數，然後delete _ref_counter將正確地破壞派生類型，因此它應該成爲這樣的：

void _delete_ptr() 
{ 
    _ref_counter->dispose(); 
    delete _ref_counter; 
} 

但如果你不打算增加weak_ptr支持則沒有必要分離的管理對象和控制塊的破壞，你可以有控制塊的析構函數一舉兩得：

void _delete_ptr() 
{ 
    delete _ref_counter; 
} 

您當前的設計無法支持導入的shared_ptr螞蟻屬性，這是該template<class Y> explicit shared_ptr(Y* ptr)構造函數必須記住原始類型的ptr，並調用該刪除，而不是_obj_ptr（已轉換爲T*）。看到文檔的note爲boost::shared_ptr相應的構造函數。爲了使這項工作的_ref_cntr需要使用類型擦除存儲原始指針，從shared_ptr對象_obj_ptr分開，使_ref_cntr::dispose()可以刪除正確的值。設計中的這種變化也需要支持aliasing constructor。

class _ref_cntr 
{ 
private: 
    long counter; 

public: 
    _ref_cntr() : 
     counter(1) 
    { 
    } 

    virtual ~_ref_cntr() { dispose(); } 

    void inc() 
    { 
     ++counter; 
    } 

    void dec() 
    { 
     if (counter == 0) 
     { 
      throw std::logic_error("already zero"); 
     } 

     --counter; 
    } 

    long use_count() const 
    { 
     return counter; 
    } 

    virtual void dispose() = 0; 
}; 

template<class Y> 
struct _ptr_and_block : _ref_cntr 
{ 
    Y* _ptr; 
    explicit _ptr_and_block(Y* p) : _ptr(p) { } 
    virtual void dispose() { delete _ptr; } 
}; 

template<class Y> 
struct _object_and_block : _ref_cntr 
{ 
    Y object; 

    template<class ... Args> 
    _object_and_block(Args && ...args) : 
     object(args...) 
    { 
    } 

    virtual void dispose() { /* no-op */ } 
}; 

採用這種設計，make_shared變爲：

template<class T, class ... Args> 
shared_ptr<T> make_shared(Args && ... args) 
{ 
    shared_ptr<T> ptr; 
    auto tmp_object = new shared_ptr<T>::_object_and_block<T>(args...); 
    ptr._obj_ptr = &tmp_object->object; 
    ptr._ref_counter = tmp_object; 

    return ptr; 
} 

所以_ref_counter指向分配控制塊，當你做delete _ref_counter這意味着你你有一個正確的匹配new/delete一對分配和取消分配同一個對象，而不是用new創建一個對象，然後嘗試delete兩個不同的對象。

要添加weak_ptr支持，你需要第二次計數添加到控制塊，呼叫轉移到dispose()出來的析構函數，因此它被稱爲當第一計數爲零（例如，在dec()），只有通話第二個計數變爲零時的析構函數。然後以線程安全的方式做所有這些都會增加很多微妙的複雜性，這將比解答需要更長的時間來解釋。

而且，您的實現，這部分是錯誤的，出現內存泄漏：

void _check_delete_ptr() 
{ 
    if (_obj_ptr == nullptr) 
    { 
     return; 
    } 

這是可能的構造函數shared_ptr空指針，例如shared_ptr<int>((int*)nullptr)，在這種情況下，構造函數將分配一個控制塊，但由於_obj_ptr爲空，所以不會刪除控制塊。