unique_ptr< _Ty, _Dx > Class Template Reference

Inheritance diagram for unique_ptr< _Ty, _Dx >:

Public Types
typedef unique_ptr< _Ty, _Dx >	_Myt
typedef _Unique_ptr_base< _Ty, _Dx, is_empty< _Dx >::value||is_same< default_delete< _Ty >, _Dx >::value >	_Mybase
typedef _Mybase::pointer	pointer
typedef _Ty	element_type
typedef _Dx	deleter_type

Public Member Functions
	unique_ptr () _NOEXCEPT
	unique_ptr (nullptr_t) _NOEXCEPT
_Myt &	operator= (nullptr_t) _NOEXCEPT
	unique_ptr (pointer _Ptr) _NOEXCEPT
	unique_ptr (pointer _Ptr, typename _If< is_reference< _Dx >::value, _Dx, const typename remove_reference< _Dx >::type & >::type _Dt) _NOEXCEPT
	unique_ptr (pointer _Ptr, typename remove_reference< _Dx >::type &&_Dt) _NOEXCEPT
	unique_ptr (unique_ptr &&_Right) _NOEXCEPT
template<class _Ty2 , class _Dx2 , class = typename enable_if<!is_array<_Ty2>::value && is_convertible<typename unique_ptr<_Ty2, _Dx2>::pointer, pointer>::value && ((is_reference<_Dx>::value && is_same<_Dx, _Dx2>::value) || (!is_reference<_Dx>::value && is_convertible<_Dx2, _Dx>::value)), void>::type>
	unique_ptr (unique_ptr< _Ty2, _Dx2 > &&_Right) _NOEXCEPT
template<class _Ty2 , class = typename enable_if<is_convertible<_Ty2 *, _Ty *>::value && is_same<_Dx, default_delete<_Ty> >::value, void>::type>
	unique_ptr (auto_ptr< _Ty2 > &&_Right) _NOEXCEPT
template<class _Ty2 , class _Dx2 >
enable_if<!is_array< _Ty2 >::value &&is_convertible< typename unique_ptr< _Ty2, _Dx2 >::pointer, pointer >::value, _Myt & >::type	operator= (unique_ptr< _Ty2, _Dx2 > &&_Right) _NOEXCEPT
_Myt &	operator= (_Myt &&_Right) _NOEXCEPT
void	swap (_Myt &_Right) _NOEXCEPT
	~unique_ptr () _NOEXCEPT
add_reference< _Ty >::type	operator* () const
pointer	operator-> () const _NOEXCEPT
pointer	get () const _NOEXCEPT
	operator bool () const _NOEXCEPT
pointer	release () _NOEXCEPT
void	reset (pointer _Ptr=pointer()) _NOEXCEPT
	unique_ptr (const _Myt &)=delete
_Myt &	operator= (const _Myt &)=delete

Additional Inherited Members
Private Types inherited from _Unique_ptr_base< _Ty, _Dx, is_empty< _Dx >::value||is_same< default_delete< _Ty >, _Dx >::value >
typedef remove_reference< _Dx >::type	_Dx_noref
typedef _Get_deleter_pointer_type< _Ty, _Dx_noref >::type	pointer
Private Member Functions inherited from _Unique_ptr_base< _Ty, _Dx, is_empty< _Dx >::value||is_same< default_delete< _Ty >, _Dx >::value >
	_Unique_ptr_base (pointer _Ptr, _Dx _Dt)
	_Unique_ptr_base (pointer _Ptr)
	_Unique_ptr_base (_Ptr2 _Ptr, _Dx2 _Dt)
	_Unique_ptr_base (_Ptr2 _Ptr)
_Dx_noref &	get_deleter ()
const _Dx_noref &	get_deleter () const
Private Attributes inherited from _Unique_ptr_base< _Ty, _Dx, is_empty< _Dx >::value||is_same< default_delete< _Ty >, _Dx >::value >
pointer	_Myptr
_Dx	_Mydel

Member Typedef Documentation

template<class _Ty, class _Dx>

typedef _Unique_ptr_base<_Ty, _Dx, is_empty<_Dx>::value || is_same<default_delete<_Ty>, _Dx>::value> unique_ptr< _Ty, _Dx >::_Mybase

template<class _Ty, class _Dx>

typedef unique_ptr<_Ty, _Dx> unique_ptr< _Ty, _Dx >::_Myt

template<class _Ty, class _Dx>

typedef _Dx unique_ptr< _Ty, _Dx >::deleter_type

template<class _Ty, class _Dx>

typedef _Ty unique_ptr< _Ty, _Dx >::element_type

template<class _Ty, class _Dx>

typedef _Mybase::pointer unique_ptr< _Ty, _Dx >::pointer

Constructor & Destructor Documentation

template<class _Ty, class _Dx>

unique_ptr< _Ty, _Dx >::unique_ptr ( )

inline

        : _Mybase(pointer())
        {   // default construct
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
        }

template<class _Ty, class _Dx>

unique_ptr< _Ty, _Dx >::unique_ptr ( nullptr_t  )

inline

        : _Mybase(pointer())
        {   // null pointer construct
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
        }

template<class _Ty, class _Dx>

unique_ptr< _Ty, _Dx >::unique_ptr ( pointer  _Ptr )

inlineexplicit

        : _Mybase(_Ptr)
        {   // construct with pointer
        static_assert(!is_pointer<_Dx>::value,
            "unique_ptr constructed with null deleter pointer");
        }

template<class _Ty, class _Dx>

unique_ptr< _Ty, _Dx >::unique_ptr ( pointer  _Ptr, typename _If< is_reference< _Dx >::value, _Dx, const typename remove_reference< _Dx >::type & >::type  _Dt  )

inline

        : _Mybase(_Ptr, _Dt)
        {   // construct with pointer and (maybe const) deleter&
        }

template<class _Ty, class _Dx>

unique_ptr< _Ty, _Dx >::unique_ptr ( pointer  _Ptr, typename remove_reference< _Dx >::type &&  _Dt  )

inline

        : _Mybase(_Ptr, _STD move(_Dt))
        {   // construct by moving deleter
        static_assert(!is_reference<_Dx>::value,
            "unique_ptr constructed with reference to rvalue deleter");
        }

template<class _Ty, class _Dx>

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

inline

        : _Mybase(_Right.release(),
            _STD forward<_Dx>(_Right.get_deleter()))
        {   // construct by moving _Right
        }

template<class _Ty, class _Dx>

template<class _Ty2 , class _Dx2 , class = typename enable_if<!is_array<_Ty2>::value && is_convertible<typename unique_ptr<_Ty2, _Dx2>::pointer, pointer>::value && ((is_reference<_Dx>::value && is_same<_Dx, _Dx2>::value) || (!is_reference<_Dx>::value && is_convertible<_Dx2, _Dx>::value)), void>::type>

unique_ptr< _Ty, _Dx >::unique_ptr ( unique_ptr< _Ty2, _Dx2 > &&  _Right )

inline

            : _Mybase(_Right.release(),
                _STD forward<_Dx2>(_Right.get_deleter()))
        {   // construct by moving _Right
        }

template<class _Ty, class _Dx>

template<class _Ty2 , class = typename enable_if<is_convertible<_Ty2 *, _Ty *>::value && is_same<_Dx, default_delete<_Ty> >::value, void>::type>

unique_ptr< _Ty, _Dx >::unique_ptr ( auto_ptr< _Ty2 > &&  _Right )

inline

            : _Mybase(_Right.release())
        {   // construct by moving _Right
        }

template<class _Ty, class _Dx>

unique_ptr< _Ty, _Dx >::~unique_ptr ( )

inline

        {   // destroy the object
        if (this->_Myptr != pointer())
            this->get_deleter()(this->_Myptr);
        }

template<class _Ty, class _Dx>

unique_ptr< _Ty, _Dx >::unique_ptr ( const _Myt &  )

delete

Member Function Documentation

template<class _Ty, class _Dx>

pointer unique_ptr< _Ty, _Dx >::get ( ) const

inline

        {   // return pointer to object
        return (this->_Myptr);
        }

template<class _Ty, class _Dx>

unique_ptr< _Ty, _Dx >::operator bool ( ) const

inlineexplicit

        {   // test for non-null pointer
        return (this->_Myptr != pointer());
        }

template<class _Ty, class _Dx>

add_reference<_Ty>::type unique_ptr< _Ty, _Dx >::operator* ( ) const

inline

        {   // return reference to object
        return (*this->_Myptr);
        }

template<class _Ty, class _Dx>

pointer unique_ptr< _Ty, _Dx >::operator-> ( ) const

inline

        {   // return pointer to class object
        return (_STD pointer_traits<pointer>::pointer_to(**this));
        }

template<class _Ty, class _Dx>

_Myt& unique_ptr< _Ty, _Dx >::operator= ( nullptr_t  )

inline

        {   // assign a null pointer
        reset();
        return (*this);
        }

template<class _Ty, class _Dx>

template<class _Ty2 , class _Dx2 >

enable_if<!is_array<_Ty2>::value && is_convertible<typename unique_ptr<_Ty2, _Dx2>::pointer, pointer>::value, _Myt&>::type unique_ptr< _Ty, _Dx >::operator= ( unique_ptr< _Ty2, _Dx2 > &&  _Right )

inline

        {   // assign by moving _Right
        reset(_Right.release());
        this->get_deleter() = _STD forward<_Dx2>(_Right.get_deleter());
        return (*this);
        }

template<class _Ty, class _Dx>

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

inline

        {   // assign by moving _Right
        if (this != &_Right)
            {   // different, do the move
            reset(_Right.release());
            this->get_deleter() = _STD forward<_Dx>(_Right.get_deleter());
            }
        return (*this);
        }

template<class _Ty, class _Dx>

_Myt& unique_ptr< _Ty, _Dx >::operator= ( const _Myt &  )

delete

template<class _Ty, class _Dx>

pointer unique_ptr< _Ty, _Dx >::release ( )

inline

        {   // yield ownership of pointer
        pointer _Ans = this->_Myptr;
        this->_Myptr = pointer();
        return (_Ans);
        }

template<class _Ty, class _Dx>

void unique_ptr< _Ty, _Dx >::reset ( pointer  _Ptr = pointer() )

inline

        {   // establish new pointer
        pointer _Old = this->_Myptr;
        this->_Myptr = _Ptr;
        if (_Old != pointer())
            this->get_deleter()(_Old);
        }

template<class _Ty, class _Dx>

void unique_ptr< _Ty, _Dx >::swap ( _Myt &  _Right )

inline

        {   // swap elements
        _Swap_adl(this->_Myptr, _Right._Myptr);
        _Swap_adl(this->get_deleter(),
            _Right.get_deleter());
        }

---

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

• VS2013/inc/memory