c++新特性11 (10)shared_ptr四”_Ptr_base 类“

Posted 2022-04-04 thefist11

template <class _Ty>
class _Ptr_base  // base class for shared_ptr and weak_ptr
public:
    using element_type = remove_extent_t<_Ty>;

    _NODISCARD long use_count() const noexcept 
        return _Rep ? _Rep->_Use_count() : 0;
    

    template <class _Ty2>
    _NODISCARD bool owner_before(const _Ptr_base<_Ty2>& _Right) const noexcept  // compare addresses of manager objects
        return _Rep < _Right._Rep;
    

    _Ptr_base(const _Ptr_base&) = delete;
    _Ptr_base& operator=(const _Ptr_base&) = delete;

protected:
    _NODISCARD element_type* get() const noexcept 
        return _Ptr;
    
 
    template <class _Ty2>
    void _Move_construct_from(_Ptr_base<_Ty2>&& _Right) noexcept 
        // implement shared_ptr's (converting) move ctor and weak_ptr's move ctor
        _Ptr = _Right._Ptr;
        _Rep = _Right._Rep;

        _Right._Ptr = nullptr;
        _Right._Rep = nullptr;
    

    template <class _Ty2>
    void _Copy_construct_from(const shared_ptr<_Ty2>& _Other) noexcept 
        // implement shared_ptr's (converting) copy ctor
        _Other._Incref();

        _Ptr = _Other._Ptr;
        _Rep = _Other._Rep;
    

    template <class _Ty2>
    void _Alias_construct_from(const shared_ptr<_Ty2>& _Other, element_type* _Px) noexcept 
        // implement shared_ptr's aliasing ctor
        _Other._Incref();

        _Ptr = _Px;
        _Rep = _Other._Rep;
    

    template <class _Ty2>
    void _Alias_move_construct_from(shared_ptr<_Ty2>&& _Other, element_type* _Px) noexcept 
        // implement shared_ptr's aliasing move ctor
        _Ptr = _Px;
        _Rep = _Other._Rep;

        _Other._Ptr = nullptr;
        _Other._Rep = nullptr;
    

    template <class _Ty0>
    friend class weak_ptr; // specifically, weak_ptr::lock()

    template <class _Ty2>
    bool _Construct_from_weak(const weak_ptr<_Ty2>& _Other) noexcept 
        // implement shared_ptr's ctor from weak_ptr, and weak_ptr::lock()
        if (_Other._Rep && _Other._Rep->_Incref_nz()) 
            _Ptr = _Other._Ptr;
            _Rep = _Other._Rep;
            return true;
        

        return false;
    

    void _Incref() const noexcept 
        if (_Rep) 
            _Rep->_Incref();
        
    

    void _Decref() noexcept  // decrement reference count
        if (_Rep) 
            _Rep->_Decref();
        
    

    void _Swap(_Ptr_base& _Right) noexcept  // swap pointers
        _STD swap(_Ptr, _Right._Ptr);
        _STD swap(_Rep, _Right._Rep);
    

    template <class _Ty2>
    void _Weakly_construct_from(const _Ptr_base<_Ty2>& _Other) noexcept  // implement weak_ptr's ctors
        if (_Other._Rep) 
            _Ptr = _Other._Ptr;
            _Rep = _Other._Rep;
            _Rep->_Incwref();
         else 
            _STL_INTERNAL_CHECK(!_Ptr && !_Rep);
        
    

    template <class _Ty2>
    void _Weakly_convert_lvalue_avoiding_expired_conversions(const _Ptr_base<_Ty2>& _Other) noexcept 
        // implement weak_ptr's copy converting ctor
        if (_Other._Rep) 
            _Rep = _Other._Rep; // always share ownership
            _Rep->_Incwref();

            if (_Rep->_Incref_nz()) 
                _Ptr = _Other._Ptr; // keep resource alive during conversion, handling virtual inheritance
                _Rep->_Decref();
             else 
                _STL_INTERNAL_CHECK(!_Ptr);
            
         else 
            _STL_INTERNAL_CHECK(!_Ptr && !_Rep);
        
    

    template <class _Ty2>
    void _Weakly_convert_rvalue_avoiding_expired_conversions(_Ptr_base<_Ty2>&& _Other) noexcept 
        // implement weak_ptr's move converting ctor
        _Rep        = _Other._Rep; // always transfer ownership
        _Other._Rep = nullptr;

        if (_Rep && _Rep->_Incref_nz()) 
            _Ptr = _Other._Ptr; // keep resource alive during conversion, handling virtual inheritance
            _Rep->_Decref();
         else 
            _STL_INTERNAL_CHECK(!_Ptr);
        

        _Other._Ptr = nullptr;
    

    void _Incwref() const noexcept 
        if (_Rep) 
            _Rep->_Incwref();
        
    

    void _Decwref() noexcept  // decrement weak reference count
        if (_Rep) 
            _Rep->_Decwref();
        
    

private:
    element_type* _Ptrnullptr;
    _Ref_count_base* _Repnullptr;    
;