_Ptr_base< _Ty > Class Template Reference

Inheritance diagram for _Ptr_base< _Ty >:

Public Types
typedef _Ptr_base< _Ty >	_Myt
typedef _Ty	element_type

Public Member Functions
	_Ptr_base ()
	_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)
template<class _Ty2 >
bool	owner_before (const _Ptr_base< _Ty2 > &_Right) const
void *	_Get_deleter (const _XSTD2 type_info &_Typeid) const
_Ty *	_Get () const
bool	_Expired () const
void	_Decref ()
void	_Reset ()
template<class _Ty2 >
void	_Reset (const _Ptr_base< _Ty2 > &_Other)
template<class _Ty2 >
void	_Reset (const _Ptr_base< _Ty2 > &_Other, bool _Throw)
template<class _Ty2 >
void	_Reset (const _Ptr_base< _Ty2 > &_Other, const _Static_tag &)
template<class _Ty2 >
void	_Reset (const _Ptr_base< _Ty2 > &_Other, const _Const_tag &)
template<class _Ty2 >
void	_Reset (const _Ptr_base< _Ty2 > &_Other, const _Dynamic_tag &)
template<class _Ty2 >
void	_Reset (auto_ptr< _Ty2 > &&_Other)
template<class _Ty2 >
void	_Reset (_Ty *_Ptr, const _Ptr_base< _Ty2 > &_Other)
void	_Reset (_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
void	_Reset (_Ty *_Other_ptr, _Ref_count_base *_Other_rep, bool _Throw)
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 (const _Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)
template<class _Ty2 >
void	_Resetw (_Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)

Private Attributes
_Ty *	_Ptr
_Ref_count_base *	_Rep

Friends
template<class _Ty0 >
class	_Ptr_base

Member Typedef Documentation

template<class _Ty>

typedef _Ptr_base<_Ty> _Ptr_base< _Ty >::_Myt

template<class _Ty>

typedef _Ty _Ptr_base< _Ty >::element_type

Constructor & Destructor Documentation

template<class _Ty>

_Ptr_base< _Ty >::_Ptr_base ( )

inline

        : _Ptr(0), _Rep(0)
        {   // construct
        }

template<class _Ty>

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

inline

        : _Ptr(0), _Rep(0)
        {   // construct _Ptr_base object that takes resource from _Right
        _Assign_rv(_STD forward<_Myt>(_Right));
        }

template<class _Ty>

template<class _Ty2 >

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

inline

        : _Ptr(_Right._Ptr), _Rep(_Right._Rep)
        {   // construct _Ptr_base object that takes resource from _Right
        _Right._Ptr = 0;
        _Right._Rep = 0;
        }

Member Function Documentation

template<class _Ty>

void _Ptr_base< _Ty >::_Assign_rv ( _Myt &&  _Right )

inline

        {   // assign by moving _Right
        if (this != &_Right)
            _Swap(_Right);
        }

template<class _Ty>

void _Ptr_base< _Ty >::_Decref ( )

inline

        {   // decrement reference count
        if (_Rep != 0)
            _Rep->_Decref();
        }

template<class _Ty>

void _Ptr_base< _Ty >::_Decwref ( )

inline

        {   // decrement weak reference count
        if (_Rep != 0)
            _Rep->_Decwref();
        }

template<class _Ty>

bool _Ptr_base< _Ty >::_Expired ( ) const

inline

        {   // test if expired
        return (!_Rep || _Rep->_Expired());
        }

template<class _Ty>

_Ty* _Ptr_base< _Ty >::_Get ( ) const

inline

        {   // return pointer to resource
        return (_Ptr);
        }

template<class _Ty>

void* _Ptr_base< _Ty >::_Get_deleter ( const _XSTD2 type_info &  _Typeid ) const

inline

        {   // return pointer to deleter object if its type is _Typeid
        return (_Rep ? _Rep->_Get_deleter(_Typeid) : 0);
        }

template<class _Ty>

void _Ptr_base< _Ty >::_Reset ( )

inline

        {   // release resource
        _Reset(0, 0);
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Reset ( const _Ptr_base< _Ty2 > &  _Other )

inline

        {   // release resource and take ownership of _Other._Ptr
        _Reset(_Other._Ptr, _Other._Rep);
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Reset ( const _Ptr_base< _Ty2 > &  _Other, bool  _Throw  )

inline

        {   // release resource and take ownership from weak_ptr _Other._Ptr
        _Reset(_Other._Ptr, _Other._Rep, _Throw);
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Reset ( const _Ptr_base< _Ty2 > &  _Other, const _Static_tag &    )

inline

        {   // release resource and take ownership of _Other._Ptr
        _Reset(static_cast<_Ty *>(_Other._Ptr), _Other._Rep);
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Reset ( const _Ptr_base< _Ty2 > &  _Other, const _Const_tag &    )

inline

        {   // release resource and take ownership of _Other._Ptr
        _Reset(const_cast<_Ty *>(_Other._Ptr), _Other._Rep);
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Reset ( const _Ptr_base< _Ty2 > &  _Other, const _Dynamic_tag &    )

inline

        {   // release resource and take ownership of _Other._Ptr
        _Ty *_Ptr = dynamic_cast<_Ty *>(_Other._Ptr);
        if (_Ptr)
            _Reset(_Ptr, _Other._Rep);
        else
            _Reset();
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Reset ( auto_ptr< _Ty2 > &&  _Other )

inline

        {   // release resource and take _Other.get()
        _Ty2 *_Px = _Other.get();
        _Reset0(_Px, new _Ref_count<_Ty>(_Px));
        _Other.release();
        _Enable_shared(_Px, _Rep);
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Reset ( _Ty *  _Ptr, const _Ptr_base< _Ty2 > &  _Other  )

inline

        {   // release resource and alias _Ptr with _Other_rep
        _Reset(_Ptr, _Other._Rep);
        }

template<class _Ty>

void _Ptr_base< _Ty >::_Reset ( _Ty *  _Other_ptr, _Ref_count_base *  _Other_rep  )

inline

        {   // release resource and take _Other_ptr through _Other_rep
        if (_Other_rep)
            _Other_rep->_Incref();
        _Reset0(_Other_ptr, _Other_rep);
        }

template<class _Ty>

void _Ptr_base< _Ty >::_Reset ( _Ty *  _Other_ptr, _Ref_count_base *  _Other_rep, bool  _Throw  )

inline

        {   // take _Other_ptr through _Other_rep from weak_ptr if not expired
            // otherwise, leave in default state if !_Throw,
            // otherwise throw exception
        if (_Other_rep && _Other_rep->_Incref_nz())
            _Reset0(_Other_ptr, _Other_rep);
        else if (_Throw)
            _THROW_NCEE(bad_weak_ptr, 0);
        }

template<class _Ty>

void _Ptr_base< _Ty >::_Reset0 ( _Ty *  _Other_ptr, _Ref_count_base *  _Other_rep  )

inline

        {   // release resource and take new resource
        if (_Rep != 0)
            _Rep->_Decref();
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
        }

template<class _Ty>

void _Ptr_base< _Ty >::_Resetw ( )

inline

        {   // release weak reference to resource
        _Resetw((_Ty *)0, 0);
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Resetw ( const _Ptr_base< _Ty2 > &  _Other )

inline

        {   // release weak reference to resource and take _Other._Ptr
        _Resetw(_Other._Ptr, _Other._Rep);
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Resetw ( const _Ty2 *  _Other_ptr, _Ref_count_base *  _Other_rep  )

inline

        {   // point to _Other_ptr through _Other_rep
        _Resetw(const_cast<_Ty2*>(_Other_ptr), _Other_rep);
        }

template<class _Ty>

template<class _Ty2 >

void _Ptr_base< _Ty >::_Resetw ( _Ty2 *  _Other_ptr, _Ref_count_base *  _Other_rep  )

inline

        {   // point to _Other_ptr through _Other_rep
        if (_Other_rep)
            _Other_rep->_Incwref();
        if (_Rep != 0)
            _Rep->_Decwref();
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
        }

template<class _Ty>

void _Ptr_base< _Ty >::_Swap ( _Ptr_base< _Ty > &  _Right )

inline

        {   // swap pointers
        _STD swap(_Rep, _Right._Rep);
        _STD swap(_Ptr, _Right._Ptr);
        }

template<class _Ty>

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

inline

        {   // construct _Ptr_base object that takes resource from _Right
        _Assign_rv(_STD forward<_Myt>(_Right));
        return (*this);
        }

template<class _Ty>

template<class _Ty2 >

bool _Ptr_base< _Ty >::owner_before ( const _Ptr_base< _Ty2 > &  _Right ) const

inline

        {   // compare addresses of manager objects
        return (_Rep < _Right._Rep);
        }

template<class _Ty>

long _Ptr_base< _Ty >::use_count ( ) const

inline

        {   // return use count
        return (_Rep ? _Rep->_Use_count() : 0);
        }

Friends And Related Function Documentation

template<class _Ty>

template<class _Ty0 >

friend class _Ptr_base

friend

Member Data Documentation

template<class _Ty>

_Ty* _Ptr_base< _Ty >::_Ptr

private

template<class _Ty>

_Ref_count_base* _Ptr_base< _Ty >::_Rep

private

---

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

• VS2013/inc/memory