shared_ptr< _Ty > Class Template Reference

Inheritance diagram for shared_ptr< _Ty >:

Public Types
typedef shared_ptr< _Ty >	_Myt
typedef _Ptr_base< _Ty >	_Mybase
Public Types inherited from _Ptr_base< _Ty >
typedef _Ptr_base< _Ty >	_Myt
typedef _Ty	element_type

Public Member Functions
constexpr	shared_ptr () _NOEXCEPT
template<class _Ux >
	shared_ptr (_Ux *_Px)
template<class _Ux , class _Dx >
	shared_ptr (_Ux *_Px, _Dx _Dt)
constexpr	shared_ptr (nullptr_t) _NOEXCEPT
template<class _Dx >
	shared_ptr (nullptr_t, _Dx _Dt)
template<class _Dx , class _Alloc >
	shared_ptr (nullptr_t, _Dx _Dt, _Alloc _Ax)
template<class _Ux , class _Dx , class _Alloc >
	shared_ptr (_Ux *_Px, _Dx _Dt, _Alloc _Ax)
template<class _Ty2 >
	shared_ptr (const shared_ptr< _Ty2 > &_Right, _Ty *_Px) _NOEXCEPT
	shared_ptr (const _Myt &_Other) _NOEXCEPT
template<class _Ty2 , class = enable_if_t<is_convertible<_Ty2 *, _Ty *>::value>>
	shared_ptr (const shared_ptr< _Ty2 > &_Other) _NOEXCEPT
template<class _Ty2 >
	shared_ptr (const weak_ptr< _Ty2 > &_Other)
	shared_ptr (_No_bad_weak_ptr, const weak_ptr< _Ty > &_Other) _NOEXCEPT
	shared_ptr (_Myt &&_Right) _NOEXCEPT
template<class _Ty2 , class = enable_if_t<is_convertible<_Ty2 *, _Ty *>::value>>
	shared_ptr (shared_ptr< _Ty2 > &&_Right) _NOEXCEPT
template<class _Ux , class _Dx , class = enable_if_t<is_convertible< typename unique_ptr<_Ux, _Dx>::pointer, _Ty *>::value>>
	shared_ptr (unique_ptr< _Ux, _Dx > &&_Right)
template<class _Ux , class _Dx >
_Myt &	operator= (unique_ptr< _Ux, _Dx > &&_Right)
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT
template<class _Ty2 >
_Myt &	operator= (shared_ptr< _Ty2 > &&_Right) _NOEXCEPT
	~shared_ptr () _NOEXCEPT
_Myt &	operator= (const _Myt &_Right) _NOEXCEPT
template<class _Ty2 >
_Myt &	operator= (const shared_ptr< _Ty2 > &_Right) _NOEXCEPT
void	reset () _NOEXCEPT
template<class _Ux >
void	reset (_Ux *_Px)
template<class _Ux , class _Dx >
void	reset (_Ux *_Px, _Dx _Dt)
template<class _Ux , class _Dx , class _Alloc >
void	reset (_Ux *_Px, _Dx _Dt, _Alloc _Ax)
void	swap (_Myt &_Other) _NOEXCEPT
_Ty *	get () const _NOEXCEPT
add_lvalue_reference< _Ty >::type	operator* () const _NOEXCEPT
_Ty *	operator-> () const _NOEXCEPT
bool	unique () const _NOEXCEPT
	operator bool () const _NOEXCEPT
template<class _Ux >
void	_Resetp0 (_Ux *_Px, _Ref_count_base *_Rx)
Public Member Functions inherited from _Ptr_base< _Ty >
constexpr	_Ptr_base () _NOEXCEPT
	_Ptr_base (_Myt &&_Right)
template<class _Ty2 >
	_Ptr_base (_Ptr_base< _Ty2 > &&_Right)
_Myt &	operator= (_Myt &&_Right)
void	_Assign_rv (_Myt &&_Right)
long	use_count () const _NOEXCEPT
void	_Swap (_Ptr_base &_Right) _NOEXCEPT
template<class _Ty2 >
bool	owner_before (const _Ptr_base< _Ty2 > &_Right) const
void *	_Get_deleter (const type_info &_Typeid) const _NOEXCEPT
_Ty *	_Get () const _NOEXCEPT
bool	_Expired () const _NOEXCEPT
void	_Decref ()
void	_Reset ()
template<class _Ty2 >
void	_Reset (const _Ptr_base< _Ty2 > &_Other)
template<class _Ty2 >
bool	_Reset_weak (const _Ptr_base< _Ty2 > &_Other)
template<class _Ty2 >
void	_Reset (_Ty *_Other_ptr, const _Ptr_base< _Ty2 > &_Other)
void	_Reset (_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
bool	_Reset_weak (_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
void	_Reset0 (_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
void	_Decwref ()
void	_Resetw ()
template<class _Ty2 >
void	_Resetw (const _Ptr_base< _Ty2 > &_Other)
template<class _Ty2 >
void	_Resetw (_Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)

Private Member Functions
template<class _Ux >
void	_Resetp (_Ux *_Px)
template<class _Ux , class _Dx >
void	_Resetp (_Ux *_Px, _Dx _Dt)
template<class _Ux , class _Dx , class _Alloc >
void	_Resetp (_Ux *_Px, _Dx _Dt, _Alloc _Ax)

Member Typedef Documentation

template<class _Ty>

typedef _Ptr_base<_Ty> shared_ptr< _Ty >::_Mybase

template<class _Ty>

typedef shared_ptr<_Ty> shared_ptr< _Ty >::_Myt

Constructor & Destructor Documentation

template<class _Ty>

constexpr shared_ptr< _Ty >::shared_ptr ( )

inline

        {   // construct empty shared_ptr
        }

template<class _Ty>

template<class _Ux >

shared_ptr< _Ty >::shared_ptr ( _Ux *  _Px )

inlineexplicit

        {   // construct shared_ptr object that owns _Px
        _Resetp(_Px);
        }

template<class _Ty>

template<class _Ux , class _Dx >

shared_ptr< _Ty >::shared_ptr ( _Ux *  _Px, _Dx  _Dt  )

inline

        {   // construct with _Px, deleter
        _Resetp(_Px, _Dt);
        }

template<class _Ty>

constexpr shared_ptr< _Ty >::shared_ptr ( nullptr_t  )

inline

        {   // construct empty shared_ptr
        }

template<class _Ty>

template<class _Dx >

shared_ptr< _Ty >::shared_ptr ( nullptr_t  , _Dx  _Dt  )

inline

        {   // construct with nullptr, deleter
        _Resetp((_Ty *)0, _Dt);
        }

template<class _Ty>

template<class _Dx , class _Alloc >

shared_ptr< _Ty >::shared_ptr ( nullptr_t  , _Dx  _Dt, _Alloc  _Ax  )

inline

        {   // construct with nullptr, deleter, allocator
        _Resetp((_Ty *)0, _Dt, _Ax);
        }

template<class _Ty>

template<class _Ux , class _Dx , class _Alloc >

shared_ptr< _Ty >::shared_ptr ( _Ux *  _Px, _Dx  _Dt, _Alloc  _Ax  )

inline

        {   // construct with _Px, deleter, allocator
        _Resetp(_Px, _Dt, _Ax);
        }

template<class _Ty>

template<class _Ty2 >

shared_ptr< _Ty >::shared_ptr ( const shared_ptr< _Ty2 > &  _Right, _Ty *  _Px  )

inline

        {   // construct shared_ptr object that aliases _Right
        this->_Reset(_Px, _Right);
        }

template<class _Ty>

shared_ptr< _Ty >::shared_ptr ( const _Myt &  _Other )

inline

        {   // construct shared_ptr object that owns same resource as _Other
        this->_Reset(_Other);
        }

template<class _Ty>

template<class _Ty2 , class = enable_if_t<is_convertible<_Ty2 *, _Ty *>::value>>

shared_ptr< _Ty >::shared_ptr ( const shared_ptr< _Ty2 > &  _Other )

inline

        {   // construct shared_ptr object that owns same resource as _Other
        this->_Reset(_Other);
        }

template<class _Ty>

template<class _Ty2 >

shared_ptr< _Ty >::shared_ptr ( const weak_ptr< _Ty2 > &  _Other )

inlineexplicit

        {   // construct shared_ptr object that owns resource *_Other
        if (!this->_Reset_weak(_Other))
            {
            _THROW_NCEE(bad_weak_ptr, _EMPTY_ARGUMENT);
            }
        }

template<class _Ty>

shared_ptr< _Ty >::shared_ptr ( _No_bad_weak_ptr  , const weak_ptr< _Ty > &  _Other  )

inline

        {   // construct shared_ptr object that owns resource *_Other, no throw
        (void)this->_Reset_weak(_Other);
        }

template<class _Ty>

shared_ptr< _Ty >::shared_ptr ( _Myt &&  _Right )

inline

        : _Mybase(_STD move(_Right))
        {   // construct shared_ptr object that takes resource from _Right
        }

template<class _Ty>

template<class _Ty2 , class = enable_if_t<is_convertible<_Ty2 *, _Ty *>::value>>

shared_ptr< _Ty >::shared_ptr ( shared_ptr< _Ty2 > &&  _Right )

inline

        : _Mybase(_STD move(_Right))
        {   // construct shared_ptr object that takes resource from _Right
        }

template<class _Ty>

template<class _Ux , class _Dx , class = enable_if_t<is_convertible< typename unique_ptr<_Ux, _Dx>::pointer, _Ty *>::value>>

shared_ptr< _Ty >::shared_ptr ( unique_ptr< _Ux, _Dx > &&  _Right )

inline

        {   // construct from unique_ptr
        _Resetp(_Right.release(), _Right.get_deleter());
        }

template<class _Ty>

shared_ptr< _Ty >::~shared_ptr ( )

inline

        {   // release resource
        this->_Decref();
        }

Member Function Documentation

template<class _Ty>

template<class _Ux >

void shared_ptr< _Ty >::_Resetp ( _Ux *  _Px )

inlineprivate

        {   // release, take ownership of _Px
        _TRY_BEGIN  // allocate control block and reset
        _Resetp0(_Px, new _Ref_count<_Ux>(_Px));
        _CATCH_ALL  // allocation failed, delete resource
        delete _Px;
        _RERAISE;
        _CATCH_END
        }

template<class _Ty>

template<class _Ux , class _Dx >

void shared_ptr< _Ty >::_Resetp ( _Ux *  _Px, _Dx  _Dt  )

inlineprivate

        {   // release, take ownership of _Px, deleter _Dt
        _TRY_BEGIN  // allocate control block and reset
        _Resetp0(_Px, new _Ref_count_del<_Ux, _Dx>(_Px, _Dt));
        _CATCH_ALL  // allocation failed, delete resource
        _Dt(_Px);
        _RERAISE;
        _CATCH_END
        }

template<class _Ty>

template<class _Ux , class _Dx , class _Alloc >

void shared_ptr< _Ty >::_Resetp ( _Ux *  _Px, _Dx  _Dt, _Alloc  _Ax  )

inlineprivate

        {   // release, take ownership of _Px, deleter _Dt, allocator _Ax
        typedef _Ref_count_del_alloc<_Ux, _Dx, _Alloc> _Refd;
        typedef _Wrap_alloc<_Alloc> _Alref0;
        typename _Alref0::template rebind<_Refd>::other _Alref(_Ax);

        _TRY_BEGIN  // allocate control block and reset
        _Refd *_Pref = _Unfancy(_Alref.allocate(1));
        _Alref.construct(_Pref, _Px, _Dt, _Ax);
        _Resetp0(_Px, _Pref);
        _CATCH_ALL  // allocation failed, delete resource
        _Dt(_Px);
        _RERAISE;
        _CATCH_END
        }

template<class _Ty>

template<class _Ux >

void shared_ptr< _Ty >::_Resetp0 ( _Ux *  _Px, _Ref_count_base *  _Rx  )

inline

        {   // release resource and take ownership of _Px
        this->_Reset0(_Px, _Rx);
        _Enable_shared(_Px, _Rx);
        }

template<class _Ty>

_Ty* shared_ptr< _Ty >::get ( ) const

inline

        {   // return pointer to resource
        return (this->_Get());
        }

template<class _Ty>

shared_ptr< _Ty >::operator bool ( ) const

inlineexplicit

        {   // test if shared_ptr object owns no resource
        return (this->_Get() != 0);
        }

template<class _Ty>

add_lvalue_reference<_Ty>::type shared_ptr< _Ty >::operator* ( ) const

inline

        {   // return reference to resource
        return (*this->_Get());
        }

template<class _Ty>

_Ty* shared_ptr< _Ty >::operator-> ( ) const

inline

        {   // return pointer to resource
        return (this->_Get());
        }

template<class _Ty>

template<class _Ux , class _Dx >

_Myt& shared_ptr< _Ty >::operator= ( unique_ptr< _Ux, _Dx > &&  _Right )

inline

        {   // move from unique_ptr
        shared_ptr(_STD move(_Right)).swap(*this);
        return (*this);
        }

template<class _Ty>

_Myt& shared_ptr< _Ty >::operator= ( _Myt &&  _Right )

inline

        {   // take resource from _Right
        shared_ptr(_STD move(_Right)).swap(*this);
        return (*this);
        }

template<class _Ty>

template<class _Ty2 >

_Myt& shared_ptr< _Ty >::operator= ( shared_ptr< _Ty2 > &&  _Right )

inline

        {   // take resource from _Right
        shared_ptr(_STD move(_Right)).swap(*this);
        return (*this);
        }

template<class _Ty>

_Myt& shared_ptr< _Ty >::operator= ( const _Myt &  _Right )

inline

        {   // assign shared ownership of resource owned by _Right
        shared_ptr(_Right).swap(*this);
        return (*this);
        }

template<class _Ty>

template<class _Ty2 >

_Myt& shared_ptr< _Ty >::operator= ( const shared_ptr< _Ty2 > &  _Right )

inline

        {   // assign shared ownership of resource owned by _Right
        shared_ptr(_Right).swap(*this);
        return (*this);
        }

template<class _Ty>

void shared_ptr< _Ty >::reset ( )

inline

        {   // release resource and convert to empty shared_ptr object
        shared_ptr().swap(*this);
        }

template<class _Ty>

template<class _Ux >

void shared_ptr< _Ty >::reset ( _Ux *  _Px )

inline

        {   // release, take ownership of _Px
        shared_ptr(_Px).swap(*this);
        }

template<class _Ty>

template<class _Ux , class _Dx >

void shared_ptr< _Ty >::reset ( _Ux *  _Px, _Dx  _Dt  )

inline

        {   // release, take ownership of _Px, with deleter _Dt
        shared_ptr(_Px, _Dt).swap(*this);
        }

template<class _Ty>

template<class _Ux , class _Dx , class _Alloc >

void shared_ptr< _Ty >::reset ( _Ux *  _Px, _Dx  _Dt, _Alloc  _Ax  )

inline

        {   // release, take ownership of _Px, with deleter _Dt, allocator _Ax
        shared_ptr(_Px, _Dt, _Ax).swap(*this);
        }

template<class _Ty>

void shared_ptr< _Ty >::swap ( _Myt &  _Other )

inline

        {   // swap pointers
        this->_Swap(_Other);
        }

template<class _Ty>

bool shared_ptr< _Ty >::unique ( ) const

inline

        {   // return true if no other shared_ptr object owns this resource
        return (this->use_count() == 1);
        }

---

The documentation for this class was generated from the following file:

• VS2017/inc/memory