Pointer Abstractions
Utilities » Memory
Collaboration diagram for Pointer Abstractions:

## Classes

struct | std::default_delete< _Tp >
struct | std::default_delete< _Tp[]>
class | std::enable_shared_from_this< _Tp >
struct | std::hash< shared_ptr< _Tp > >
struct | std::hash< unique_ptr< _Tp, _Dp > >
struct | std::owner_less< _Tp >
struct | std::owner_less< shared_ptr< _Tp > >
struct | std::owner_less< void >
struct | std::owner_less< weak_ptr< _Tp > >
struct | std::pointer_traits< _Ptr >
struct | std::pointer_traits< _Tp * >
class | std::shared_ptr< _Tp >
class | std::unique_ptr< _Tp, _Dp >
class | std::unique_ptr< _Tp[], _Dp >
class | std::weak_ptr< _Tp >

## Macros

#define | __cpp_lib_enable_shared_from_this
#define | __cpp_lib_make_unique

## Typedefs

typedef unique_ptr< _Tp[]> | std::_MakeUniq< _Tp[]>::__array
template<typename _Up >
using | std::unique_ptr< _Tp[], _Dp >::__safe_conversion_raw = __and_< __or_< __or_< is_same< _Up, pointer >, is_same< _Up, nullptr_t > >, __and_< is_pointer< _Up >, is_same< pointer, element_type * >, is_convertible< typename remove_pointer< _Up >::type(*)[], element_type(*)[]> > > >
template<typename _Up , typename _Ep >
using | std::unique_ptr< _Tp, _Dp >::__safe_conversion_up = __and_< is_convertible< typename unique_ptr< _Up, _Ep >::pointer, pointer >, __not_< is_array< _Up > > >
template<typename _Up , typename _Ep , typename _UPtr = unique_ptr<_Up, _Ep>, typename _UP_pointer = typename _UPtr::pointer, typename _UP_element_type = typename _UPtr::element_type>
using | std::unique_ptr< _Tp[], _Dp >::__safe_conversion_up = __and_< is_array< _Up >, is_same< pointer, element_type * >, is_same< _UP_pointer, _UP_element_type * >, is_convertible< _UP_element_type(*)[], element_type(*)[]> >
typedef unique_ptr< _Tp > | std::_MakeUniq< _Tp >::__single_object
using | std::__uniq_ptr_impl< _Tp, _Dp >::_DeleterConstraint = enable_if< __and_< __not_< is_pointer< _Dp > >, is_default_constructible< _Dp > >::value >
using | std::unique_ptr< _Tp, _Dp >::deleter_type = _Dp
using | std::unique_ptr< _Tp[], _Dp >::deleter_type = _Dp
using | std::shared_ptr< _Tp >::element_type = typename __shared_ptr< _Tp >::element_type
using | std::unique_ptr< _Tp, _Dp >::element_type = _Tp
using | std::unique_ptr< _Tp[], _Dp >::element_type = _Tp
using | std::__uniq_ptr_impl< _Tp, _Dp >::pointer = typename _Ptr< _Tp, _Dp >::type
using | std::unique_ptr< _Tp, _Dp >::pointer = typename __uniq_ptr_impl< _Tp, _Dp >::pointer
using | std::unique_ptr< _Tp[], _Dp >::pointer = typename __uniq_ptr_impl< _Tp, _Dp >::pointer
using | std::__uniq_ptr_impl< _Tp, _Dp >::_Ptr< _Up, _Ep, typename >::type = _Up *
using | std::__uniq_ptr_impl< _Tp, _Dp >::_Ptr< _Up, _Ep, __void_t< typename remove_reference< _Ep >::type::pointer > >::type = typename remove_reference< _Ep >::type::pointer

## Functions

| std::__uniq_ptr_impl< _Tp, _Dp >::__uniq_ptr_impl (pointer __p)
template<typename _Del >
| std::__uniq_ptr_impl< _Tp, _Dp >::__uniq_ptr_impl (pointer __p, _Del &&__d)
| std::_Sp_locker::_Sp_locker (const _Sp_locker &)=delete
| std::_Sp_locker::_Sp_locker (const void *) noexcept
| std::_Sp_locker::_Sp_locker (const void *, const void *) noexcept
constexpr | std::default_delete< _Tp >::default_delete () noexcept=default
constexpr | std::default_delete< _Tp[]>::default_delete () noexcept=default
template<typename _Up , typename = typename enable_if<is_convertible<_Up*, _Tp*>::value>::type>
| std::default_delete< _Tp >::default_delete (const default_delete< _Up > &) noexcept
template<typename _Up , typename = typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>
| std::default_delete< _Tp[]>::default_delete (const default_delete< _Up[]> &) noexcept
| std::enable_shared_from_this< _Tp >::enable_shared_from_this (const enable_shared_from_this &) noexcept
constexpr | std::shared_ptr< _Tp >::shared_ptr () noexcept
template<typename _Yp , typename = _Constructible<_Yp*>>
| std::shared_ptr< _Tp >::shared_ptr (_Yp *__p)
template<typename _Yp , typename _Deleter , typename = _Constructible<_Yp*, _Deleter>>
| std::shared_ptr< _Tp >::shared_ptr (_Yp *__p, _Deleter __d)
template<typename _Yp , typename _Deleter , typename _Alloc , typename = _Constructible<_Yp*, _Deleter, _Alloc>>
| std::shared_ptr< _Tp >::shared_ptr (_Yp *__p, _Deleter __d, _Alloc __a)
| std::shared_ptr< _Tp >::shared_ptr (const shared_ptr &) noexcept=default
template<typename _Yp , typename = _Constructible<const shared_ptr<_Yp>&>>
| std::shared_ptr< _Tp >::shared_ptr (const shared_ptr< _Yp > &__r) noexcept
template<typename _Yp >
| std::shared_ptr< _Tp >::shared_ptr (const shared_ptr< _Yp > &__r, element_type *__p) noexcept
template<typename _Yp , typename = _Constructible<const weak_ptr<_Yp>&>>
| std::shared_ptr< _Tp >::shared_ptr (const weak_ptr< _Yp > &__r)
template<typename _Deleter >
| std::shared_ptr< _Tp >::shared_ptr (nullptr_t __p, _Deleter __d)
template<typename _Deleter , typename _Alloc >
| std::shared_ptr< _Tp >::shared_ptr (nullptr_t __p, _Deleter __d, _Alloc __a)
constexpr | std::shared_ptr< _Tp >::shared_ptr (nullptr_t) noexcept
| std::shared_ptr< _Tp >::shared_ptr (shared_ptr &&__r) noexcept
template<typename _Yp , typename = _Constructible<shared_ptr<_Yp>>>
| std::shared_ptr< _Tp >::shared_ptr (shared_ptr< _Yp > &&__r) noexcept
template<typename _Yp , typename _Del , typename = _Constructible<unique_ptr<_Yp, _Del>>>
| std::shared_ptr< _Tp >::shared_ptr (unique_ptr< _Yp, _Del > &&__r)
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>
constexpr | std::unique_ptr< _Tp, _Dp >::unique_ptr () noexcept
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>
constexpr | std::unique_ptr< _Tp[], _Dp >::unique_ptr () noexcept
template<typename _Up , typename _Vp = _Dp, typename = _DeleterConstraint<_Vp>, typename = typename enable_if< __safe_conversion_raw<_Up>::value, bool>::type>
| std::unique_ptr< _Tp[], _Dp >::unique_ptr (_Up __p) noexcept
template<typename _Up , typename = typename enable_if< __safe_conversion_raw<_Up>::value, bool>::type>
| std::unique_ptr< _Tp[], _Dp >::unique_ptr (_Up __p, typename conditional< is_reference< deleter_type >::value, deleter_type, const deleter_type & >::type __d) noexcept
template<typename _Up , typename = typename enable_if< __safe_conversion_raw<_Up>::value, bool>::type>
| std::unique_ptr< _Tp[], _Dp >::unique_ptr (_Up __p, typename remove_reference< deleter_type >::type &&__d) noexcept
| std::unique_ptr< _Tp, _Dp >::unique_ptr (const unique_ptr &)=delete
| std::unique_ptr< _Tp[], _Dp >::unique_ptr (const unique_ptr &)=delete
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>
constexpr | std::unique_ptr< _Tp, _Dp >::unique_ptr (nullptr_t) noexcept
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>
constexpr | std::unique_ptr< _Tp[], _Dp >::unique_ptr (nullptr_t) noexcept
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>
| std::unique_ptr< _Tp, _Dp >::unique_ptr (pointer __p) noexcept
| std::unique_ptr< _Tp, _Dp >::unique_ptr (pointer __p, typename conditional< is_reference< deleter_type >::value, deleter_type, const deleter_type & >::type __d) noexcept
| std::unique_ptr< _Tp, _Dp >::unique_ptr (pointer __p, typename remove_reference< deleter_type >::type &&__d) noexcept
| std::unique_ptr< _Tp, _Dp >::unique_ptr (unique_ptr &&__u) noexcept
| std::unique_ptr< _Tp[], _Dp >::unique_ptr (unique_ptr &&__u) noexcept
template<typename _Up , typename _Ep , typename = _Require< __safe_conversion_up<_Up, _Ep>, typename conditional<is_reference<_Dp>::value, is_same<_Ep, _Dp>, is_convertible<_Ep, _Dp>>::type>>
| std::unique_ptr< _Tp, _Dp >::unique_ptr (unique_ptr< _Up, _Ep > &&__u) noexcept
template<typename _Up , typename _Ep , typename = _Require< __safe_conversion_up<_Up, _Ep>, typename conditional<is_reference<_Dp>::value, is_same<_Ep, _Dp>, is_convertible<_Ep, _Dp>>::type>>
| std::unique_ptr< _Tp[], _Dp >::unique_ptr (unique_ptr< _Up, _Ep > &&__u) noexcept
template<typename _Yp , typename = _Constructible<const shared_ptr<_Yp>&>>
| std::weak_ptr< _Tp >::weak_ptr (const shared_ptr< _Yp > &__r) noexcept
| std::weak_ptr< _Tp >::weak_ptr (const weak_ptr &) noexcept=default
template<typename _Yp , typename = _Constructible<const weak_ptr<_Yp>&>>
| std::weak_ptr< _Tp >::weak_ptr (const weak_ptr< _Yp > &__r) noexcept
| std::weak_ptr< _Tp >::weak_ptr (weak_ptr &&) noexcept=default
template<typename _Yp , typename = _Constructible<weak_ptr<_Yp>>>
| std::weak_ptr< _Tp >::weak_ptr (weak_ptr< _Yp > &&__r) noexcept
| std::unique_ptr< _Tp[], _Dp >::~unique_ptr ()
| std::unique_ptr< _Tp, _Dp >::~unique_ptr () noexcept
_Dp & | std::__uniq_ptr_impl< _Tp, _Dp >::_M_deleter ()
const _Dp & | std::__uniq_ptr_impl< _Tp, _Dp >::_M_deleter () const
pointer & | std::__uniq_ptr_impl< _Tp, _Dp >::_M_ptr ()
pointer | std::__uniq_ptr_impl< _Tp, _Dp >::_M_ptr () const
template<typename _Tp , typename _Alloc , typename... _Args>
shared_ptr< _Tp > | std::allocate_shared (const _Alloc &__a, _Args &&... __args)
template<typename _Tp , typename _Up >
shared_ptr< _Tp > | std::const_pointer_cast (const shared_ptr< _Up > &__r) noexcept
template<typename _Tp , typename _Up >
shared_ptr< _Tp > | std::dynamic_pointer_cast (const shared_ptr< _Up > &__r) noexcept
pointer | std::unique_ptr< _Tp, _Dp >::get () const noexcept
pointer | std::unique_ptr< _Tp[], _Dp >::get () const noexcept
const deleter_type & | std::unique_ptr< _Tp, _Dp >::get_deleter () const noexcept
const deleter_type & | std::unique_ptr< _Tp[], _Dp >::get_deleter () const noexcept
deleter_type & | std::unique_ptr< _Tp, _Dp >::get_deleter () noexcept
deleter_type & | std::unique_ptr< _Tp[], _Dp >::get_deleter () noexcept
template<typename _Del , typename _Tp , _Lock_policy _Lp>
_Del * | std::get_deleter (const __shared_ptr< _Tp, _Lp > &__p) noexcept
shared_ptr< _Tp > | std::weak_ptr< _Tp >::lock () const noexcept
template<typename _Tp , typename... _Args>
shared_ptr< _Tp > | std::make_shared (_Args &&... __args)
template<typename _Tp , typename... _Args>
_MakeUniq< _Tp >::__single_object | std::make_unique (_Args &&... __args)
template<typename _Tp , typename... _Args>
_MakeUniq< _Tp >::__invalid_type | std::make_unique (_Args &&...)=delete
template<typename _Tp >
_MakeUniq< _Tp >::__array | std::make_unique (size_t __num)
| std::unique_ptr< _Tp, _Dp >::operator bool () const noexcept
| std::unique_ptr< _Tp[], _Dp >::operator bool () const noexcept
template<typename _Tp , typename _Up >
bool | std::operator!= (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept
template<typename _Tp >
bool | std::operator!= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool | std::operator!= (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)
template<typename _Tp , typename _Dp >
bool | std::operator!= (const unique_ptr< _Tp, _Dp > &__x, nullptr_t) noexcept
template<typename _Tp >
bool | std::operator!= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
template<typename _Tp , typename _Dp >
bool | std::operator!= (nullptr_t, const unique_ptr< _Tp, _Dp > &__x) noexcept
void | std::default_delete< _Tp >::operator() (_Tp *__ptr) const
template<typename _Up >
enable_if< is_convertible< _Up(*)[], _Tp(*)[]>::value >::type | std::default_delete< _Tp[]>::operator() (_Up *__ptr) const
size_t | std::hash< shared_ptr< _Tp > >::operator() (const shared_ptr< _Tp > &__s) const noexcept
size_t | std::hash< unique_ptr< _Tp, _Dp > >::operator() (const unique_ptr< _Tp, _Dp > &__u) const noexcept
add_lvalue_reference< element_type >::type | std::unique_ptr< _Tp, _Dp >::operator* () const
pointer | std::unique_ptr< _Tp, _Dp >::operator-> () const noexcept
template<typename _Tp , typename _Up >
bool | std::operator< (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept
template<typename _Tp >
bool | std::operator< (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool | std::operator< (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)
template<typename _Tp , typename _Dp >
bool | std::operator< (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)
template<typename _Tp >
bool | std::operator< (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
template<typename _Tp , typename _Dp >
bool | std::operator< (nullptr_t, const unique_ptr< _Tp, _Dp > &__x)
template<typename _Ch , typename _Tr , typename _Tp , _Lock_policy _Lp>
std::basic_ostream< _Ch, _Tr > & | std::operator<< (std::basic_ostream< _Ch, _Tr > &__os, const __shared_ptr< _Tp, _Lp > &__p)
template<typename _Tp , typename _Up >
bool | std::operator<= (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept
template<typename _Tp >
bool | std::operator<= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool | std::operator<= (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)
template<typename _Tp , typename _Dp >
bool | std::operator<= (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)
template<typename _Tp >
bool | std::operator<= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
template<typename _Tp , typename _Dp >
bool | std::operator<= (nullptr_t, const unique_ptr< _Tp, _Dp > &__x)
_Sp_locker & | std::_Sp_locker::operator= (const _Sp_locker &)=delete
enable_shared_from_this & | std::enable_shared_from_this< _Tp >::operator= (const enable_shared_from_this &) noexcept
shared_ptr & | std::shared_ptr< _Tp >::operator= (const shared_ptr &) noexcept=default
template<typename _Yp >
_Assignable< const shared_ptr< _Yp > & > | std::shared_ptr< _Tp >::operator= (const shared_ptr< _Yp > &__r) noexcept
template<typename _Yp >
_Assignable< const shared_ptr< _Yp > & > | std::weak_ptr< _Tp >::operator= (const shared_ptr< _Yp > &__r) noexcept
unique_ptr & | std::unique_ptr< _Tp, _Dp >::operator= (const unique_ptr &)=delete
unique_ptr & | std::unique_ptr< _Tp[], _Dp >::operator= (const unique_ptr &)=delete
weak_ptr & | std::weak_ptr< _Tp >::operator= (const weak_ptr &__r) noexcept=default
template<typename _Yp >
_Assignable< const weak_ptr< _Yp > & > | std::weak_ptr< _Tp >::operator= (const weak_ptr< _Yp > &__r) noexcept
unique_ptr & | std::unique_ptr< _Tp, _Dp >::operator= (nullptr_t) noexcept
unique_ptr & | std::unique_ptr< _Tp[], _Dp >::operator= (nullptr_t) noexcept
shared_ptr & | std::shared_ptr< _Tp >::operator= (shared_ptr &&__r) noexcept
template<class _Yp >
_Assignable< shared_ptr< _Yp > > | std::shared_ptr< _Tp >::operator= (shared_ptr< _Yp > &&__r) noexcept
unique_ptr & | std::unique_ptr< _Tp, _Dp >::operator= (unique_ptr &&__u) noexcept
unique_ptr & | std::unique_ptr< _Tp[], _Dp >::operator= (unique_ptr &&__u) noexcept
template<typename _Up , typename _Ep >
enable_if< __and_< __safe_conversion_up< _Up, _Ep >, is_assignable< deleter_type &, _Ep && > >::value, unique_ptr & >::type | std::unique_ptr< _Tp, _Dp >::operator= (unique_ptr< _Up, _Ep > &&__u) noexcept
template<typename _Up , typename _Ep >
enable_if< __and_< __safe_conversion_up< _Up, _Ep >, is_assignable< deleter_type &, _Ep && > >::value, unique_ptr & >::type | std::unique_ptr< _Tp[], _Dp >::operator= (unique_ptr< _Up, _Ep > &&__u) noexcept
template<typename _Yp , typename _Del >
_Assignable< unique_ptr< _Yp, _Del > > | std::shared_ptr< _Tp >::operator= (unique_ptr< _Yp, _Del > &&__r)
weak_ptr & | std::weak_ptr< _Tp >::operator= (weak_ptr &&__r) noexcept=default
template<typename _Yp >
_Assignable< weak_ptr< _Yp > > | std::weak_ptr< _Tp >::operator= (weak_ptr< _Yp > &&__r) noexcept
template<typename _Tp , typename _Up >
bool | std::operator== (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept
template<typename _Tp >
bool | std::operator== (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool | std::operator== (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)
template<typename _Tp , typename _Dp >
bool | std::operator== (const unique_ptr< _Tp, _Dp > &__x, nullptr_t) noexcept
template<typename _Tp >
bool | std::operator== (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
template<typename _Tp , typename _Dp >
bool | std::operator== (nullptr_t, const unique_ptr< _Tp, _Dp > &__x) noexcept
template<typename _Tp , typename _Up >
bool | std::operator> (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept
template<typename _Tp >
bool | std::operator> (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool | std::operator> (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)
template<typename _Tp , typename _Dp >
bool | std::operator> (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)
template<typename _Tp >
bool | std::operator> (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
template<typename _Tp , typename _Dp >
bool | std::operator> (nullptr_t, const unique_ptr< _Tp, _Dp > &__x)
template<typename _Tp , typename _Up >
bool | std::operator>= (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept
template<typename _Tp >
bool | std::operator>= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
bool | std::operator>= (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)
template<typename _Tp , typename _Dp >
bool | std::operator>= (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)
template<typename _Tp >
bool | std::operator>= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
template<typename _Tp , typename _Dp >
bool | std::operator>= (nullptr_t, const unique_ptr< _Tp, _Dp > &__x)
std::add_lvalue_reference< element_type >::type | std::unique_ptr< _Tp[], _Dp >::operator[] (size_t __i) const
pointer | std::unique_ptr< _Tp, _Dp >::release () noexcept
pointer | std::unique_ptr< _Tp[], _Dp >::release () noexcept
template<typename _Up , typename = _Require< __or_<is_same<_Up, pointer>, __and_<is_same<pointer, element_type*>, is_pointer<_Up>, is_convertible< typename remove_pointer<_Up>::type(*)[], element_type(*)[] > > > >>
void | std::unique_ptr< _Tp[], _Dp >::reset (_Up __p) noexcept
void | std::unique_ptr< _Tp[], _Dp >::reset (nullptr_t=nullptr) noexcept
void | std::unique_ptr< _Tp, _Dp >::reset (pointer __p=pointer()) noexcept
shared_ptr< _Tp > | std::enable_shared_from_this< _Tp >::shared_from_this ()
shared_ptr< const _Tp > | std::enable_shared_from_this< _Tp >::shared_from_this () const
template<typename _Tp , typename _Up >
shared_ptr< _Tp > | std::static_pointer_cast (const shared_ptr< _Up > &__r) noexcept
template<typename _Tp >
void | std::swap (shared_ptr< _Tp > &__a, shared_ptr< _Tp > &__b) noexcept
void | std::unique_ptr< _Tp, _Dp >::swap (unique_ptr &__u) noexcept
void | std::unique_ptr< _Tp[], _Dp >::swap (unique_ptr &__u) noexcept
template<typename _Tp , typename _Dp >
enable_if< __is_swappable< _Dp >::value >::type | std::swap (unique_ptr< _Tp, _Dp > &__x, unique_ptr< _Tp, _Dp > &__y) noexcept
template<typename _Tp >
void | std::swap (weak_ptr< _Tp > &__a, weak_ptr< _Tp > &__b) noexcept
weak_ptr< const _Tp > | std::enable_shared_from_this< _Tp >::weak_from_this () const noexcept
weak_ptr< _Tp > | std::enable_shared_from_this< _Tp >::weak_from_this () noexcept

## Friends

const friend enable_shared_from_this * | std::enable_shared_from_this< _Tp >::__enable_shared_from_this_base (const __shared_count<> &, const enable_shared_from_this *__p)
template<typename , _Lock_policy >
class | std::enable_shared_from_this< _Tp >::__shared_ptr
template<typename _Yp , typename _Alloc , typename... _Args>
shared_ptr< _Yp > | std::shared_ptr< _Tp >::allocate_shared (const _Alloc &__a, _Args &&... __args)
class | std::shared_ptr< _Tp >::weak_ptr< _Tp >
template<typename _Tp , _Lock_policy _Lp>
bool | std::atomic_is_lock_free (const __shared_ptr< _Tp, _Lp > *__p)
template<typename _Tp >
bool | std::atomic_is_lock_free (const shared_ptr< _Tp > *__p)
template<typename _Tp >
shared_ptr< _Tp > | std::atomic_load_explicit (const shared_ptr< _Tp > *__p, memory_order)
template<typename _Tp >
shared_ptr< _Tp > | std::atomic_load (const shared_ptr< _Tp > *__p)
template<typename _Tp , _Lock_policy _Lp>
__shared_ptr< _Tp, _Lp > | std::atomic_load_explicit (const __shared_ptr< _Tp, _Lp > *__p, memory_order)
template<typename _Tp , _Lock_policy _Lp>
__shared_ptr< _Tp, _Lp > | std::atomic_load (const __shared_ptr< _Tp, _Lp > *__p)
template<typename _Tp >
void | std::atomic_store_explicit (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r, memory_order)
template<typename _Tp >
void | std::atomic_store (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r)
template<typename _Tp , _Lock_policy _Lp>
void | std::atomic_store_explicit (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > __r, memory_order)
template<typename _Tp , _Lock_policy _Lp>
void | std::atomic_store (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > __r)
template<typename _Tp >
shared_ptr< _Tp > | std::atomic_exchange_explicit (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r, memory_order)
template<typename _Tp >
shared_ptr< _Tp > | std::atomic_exchange (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r)
template<typename _Tp , _Lock_policy _Lp>
__shared_ptr< _Tp, _Lp > | std::atomic_exchange_explicit (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > __r, memory_order)
template<typename _Tp , _Lock_policy _Lp>
__shared_ptr< _Tp, _Lp > | std::atomic_exchange (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > __r)
template<typename _Tp >
bool | std::atomic_compare_exchange_strong_explicit (shared_ptr< _Tp > *__p, shared_ptr< _Tp > *__v, shared_ptr< _Tp > __w, memory_order, memory_order)
template<typename _Tp >
bool | std::atomic_compare_exchange_strong (shared_ptr< _Tp > *__p, shared_ptr< _Tp > *__v, shared_ptr< _Tp > __w)
template<typename _Tp >
bool | std::atomic_compare_exchange_weak_explicit (shared_ptr< _Tp > *__p, shared_ptr< _Tp > *__v, shared_ptr< _Tp > __w, memory_order __success, memory_order __failure)
template<typename _Tp >
bool | std::atomic_compare_exchange_weak (shared_ptr< _Tp > *__p, shared_ptr< _Tp > *__v, shared_ptr< _Tp > __w)
template<typename _Tp , _Lock_policy _Lp>
bool | std::atomic_compare_exchange_strong_explicit (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > *__v, __shared_ptr< _Tp, _Lp > __w, memory_order, memory_order)
template<typename _Tp , _Lock_policy _Lp>
bool | std::atomic_compare_exchange_strong (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > *__v, __shared_ptr< _Tp, _Lp > __w)
template<typename _Tp , _Lock_policy _Lp>
bool | std::atomic_compare_exchange_weak_explicit (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > *__v, __shared_ptr< _Tp, _Lp > __w, memory_order __success, memory_order __failure)
template<typename _Tp , _Lock_policy _Lp>
bool | std::atomic_compare_exchange_weak (__shared_ptr< _Tp, _Lp > *__p, __shared_ptr< _Tp, _Lp > *__v, __shared_ptr< _Tp, _Lp > __w)

## Detailed Description

Smart pointers, etc.

## Function Documentation

## default_delete() [1/4]

template<typename _Tp >

constexpr std::default_delete< _Tp >::default_delete | ( |  | ) |

constexpr default noexcept

Default constructor.

## default_delete() [2/4]

template<typename _Tp >

constexpr std::default_delete< _Tp[]>::default_delete | ( |  | ) |

constexpr default noexcept

Default constructor.

## default_delete() [3/4]

template<typename _Tp >
template<typename _Up , typename = typename enable_if<is_convertible<_Up*, _Tp*>::value>::type>

std::default_delete< _Tp >::default_delete | ( | const default_delete< _Up > & |  | ) |

inline noexcept

Converting constructor.

Allows conversion from a deleter for arrays of another type, `_Up`, only if `_Up*` is convertible to `_Tp*`.

Definition at line 68 of file unique_ptr.h.

## default_delete() [4/4]

template<typename _Tp >
template<typename _Up , typename = typename enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type>

std::default_delete< _Tp[]>::default_delete | ( | const default_delete< _Up[]> & |  | ) |

inline noexcept

Converting constructor.

Allows conversion from a deleter for arrays of another type, such as a const-qualified version of `_Tp`.

Conversions from types derived from `_Tp` are not allowed because it is unsafe to `delete`[] an array of derived types through a pointer to the base type.

Definition at line 103 of file unique_ptr.h.

## shared_ptr() [1/12]

template<typename _Tp >

constexpr std::shared_ptr< _Tp >::shared_ptr | ( |  | ) |

inline constexpr noexcept

Construct an empty shared_ptr.

Postcondition
  use_count()==0 && get()==0

Definition at line 117 of file bits/shared_ptr.h.

## shared_ptr() [2/12]

template<typename _Tp >
template<typename _Yp , typename = _Constructible<_Yp*>>

std::shared_ptr< _Tp >::shared_ptr | ( | _Yp * | __p | ) |

inline explicit

Construct a shared_ptr that owns the pointer __p.

Parameters

  __p | A pointer that is convertible to element_type*.

Postcondition
  use_count() == 1 && get() == __p

Exceptions

  std::bad_alloc,in | which case `delete` __p is called.

Definition at line 129 of file bits/shared_ptr.h.

## shared_ptr() [3/12]

template<typename _Tp >
template<typename _Yp , typename _Deleter , typename = _Constructible<_Yp*, _Deleter>>

std::shared_ptr< _Tp >::shared_ptr | ( | _Yp * | __p,
|  | _Deleter | __d
| ) |  |

inline

Construct a shared_ptr that owns the pointer __p and the deleter __d.

Parameters

  __p | A pointer.
  __d | A deleter.

Postcondition
  use_count() == 1 && get() == __p

Exceptions

  std::bad_alloc,in | which case __d(__p) is called.

Requirements: _Deleter's copy constructor and destructor must not throw

__shared_ptr will release __p by calling __d(__p)

Definition at line 146 of file bits/shared_ptr.h.

## shared_ptr() [4/12]

template<typename _Tp >
template<typename _Yp , typename _Deleter , typename _Alloc , typename = _Constructible<_Yp*, _Deleter, _Alloc>>

std::shared_ptr< _Tp >::shared_ptr | ( | _Yp * | __p,
|  | _Deleter | __d,
|  | _Alloc | __a
| ) |  |

inline

Construct a shared_ptr that owns the pointer __p and the deleter __d.

Parameters

  __p | A pointer.
  __d | A deleter.
  __a | An allocator.

Postcondition
  use_count() == 1 && get() == __p

Exceptions

  std::bad_alloc,in | which case __d(__p) is called.

Requirements: _Deleter's copy constructor and destructor must not throw _Alloc's copy constructor and destructor must not throw.

__shared_ptr will release __p by calling __d(__p)

Definition at line 183 of file bits/shared_ptr.h.

## shared_ptr() [5/12]

template<typename _Tp >
template<typename _Yp , typename = _Constructible<const shared_ptr<_Yp>&>>

std::shared_ptr< _Tp >::shared_ptr | ( | const shared_ptr< _Yp > & | __r | ) |

inline noexcept

If __r is empty, constructs an empty shared_ptr; otherwise construct a shared_ptr that shares ownership with __r.

Parameters

  __r | A shared_ptr.

Postcondition
  get() == __r.get() && use_count() == __r.use_count()

Definition at line 236 of file bits/shared_ptr.h.

## shared_ptr() [6/12]

template<typename _Tp >
template<typename _Yp >

std::shared_ptr< _Tp >::shared_ptr | ( | const shared_ptr< _Yp > & | __r,
|  | element_type * | __p
| ) |  |

inline noexcept

Constructs a shared_ptr instance that stores __p and shares ownership with __r.

Parameters

  __r | A shared_ptr.
  __p | A pointer that will remain valid while *__r is valid.

Postcondition
  get() == __p && use_count() == __r.use_count()

This can be used to construct a `shared_ptr` to a sub-object of an object managed by an existing `shared_ptr`.

shared_ptr< pair<int,int> > pii(new pair<int,int>());
shared_ptr<int> pi(pii, &pii->first);
assert(pii.use_count() == 2);

Definition at line 224 of file bits/shared_ptr.h.

## shared_ptr() [7/12]

template<typename _Tp >
template<typename _Yp , typename = _Constructible<const weak_ptr<_Yp>&>>

std::shared_ptr< _Tp >::shared_ptr | ( | const weak_ptr< _Yp > & | __r | ) |

inline explicit

Constructs a shared_ptr that shares ownership with __r and stores a copy of the pointer stored in __r.

Parameters

  __r | A weak_ptr.

Postcondition
  use_count() == __r.use_count()

Exceptions

  bad_weak_ptr | when __r.expired(), in which case the constructor has no effect.

Definition at line 265 of file bits/shared_ptr.h.

## shared_ptr() [8/12]

template<typename _Tp >
template<typename _Deleter >

std::shared_ptr< _Tp >::shared_ptr | ( | nullptr_t | __p,
|  | _Deleter | __d
| ) |  |

inline

Construct a shared_ptr that owns a null pointer and the deleter __d.

Parameters

  __p | A null pointer constant.
  __d | A deleter.

Postcondition
  use_count() == 1 && get() == __p

Exceptions

  std::bad_alloc,in | which case __d(__p) is called.

Requirements: _Deleter's copy constructor and destructor must not throw

The last owner will call __d(__p)

Definition at line 163 of file bits/shared_ptr.h.

## shared_ptr() [9/12]

template<typename _Tp >
template<typename _Deleter , typename _Alloc >

std::shared_ptr< _Tp >::shared_ptr | ( | nullptr_t | __p,
|  | _Deleter | __d,
|  | _Alloc | __a
| ) |  |

inline

Construct a shared_ptr that owns a null pointer and the deleter __d.

Parameters

  __p | A null pointer constant.
  __d | A deleter.
  __a | An allocator.

Postcondition
  use_count() == 1 && get() == __p

Exceptions

  std::bad_alloc,in | which case __d(__p) is called.

Requirements: _Deleter's copy constructor and destructor must not throw _Alloc's copy constructor and destructor must not throw.

The last owner will call __d(__p)

Definition at line 202 of file bits/shared_ptr.h.

## shared_ptr() [10/12]

template<typename _Tp >

constexpr std::shared_ptr< _Tp >::shared_ptr | ( | nullptr_t |  | ) |

inline constexpr noexcept

Construct an empty shared_ptr.

Postcondition
  use_count() == 0 && get() == nullptr

Definition at line 294 of file bits/shared_ptr.h.

## shared_ptr() [11/12]

template<typename _Tp >

std::shared_ptr< _Tp >::shared_ptr | ( | shared_ptr< _Tp > && | __r | ) |

inline noexcept

Move-constructs a shared_ptr instance from __r.

Parameters

  __r | A shared_ptr rvalue.

Postcondition
  *this contains the old value of __r, __r is empty.

Definition at line 244 of file bits/shared_ptr.h.

## shared_ptr() [12/12]

template<typename _Tp >
template<typename _Yp , typename = _Constructible<shared_ptr<_Yp>>>

std::shared_ptr< _Tp >::shared_ptr | ( | shared_ptr< _Yp > && | __r | ) |

inline noexcept

Move-constructs a shared_ptr instance from __r.

Parameters

  __r | A shared_ptr rvalue.

Postcondition
  *this contains the old value of __r, __r is empty.

Definition at line 253 of file bits/shared_ptr.h.

## unique_ptr() [1/13]

template<typename _Tp , typename _Dp = default_delete<_Tp>>
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>

constexpr std::unique_ptr< _Tp, _Dp >::unique_ptr | ( |  | ) |

inline constexpr noexcept

Default constructor, creates a unique_ptr that owns nothing.

Definition at line 183 of file unique_ptr.h.

## unique_ptr() [2/13]

template<typename _Tp , typename _Dp >
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>

constexpr std::unique_ptr< _Tp[], _Dp >::unique_ptr | ( |  | ) |

inline constexpr noexcept

Default constructor, creates a unique_ptr that owns nothing.

Definition at line 446 of file unique_ptr.h.

## unique_ptr() [3/13]

template<typename _Tp , typename _Dp >
template<typename _Up , typename _Vp = _Dp, typename = _DeleterConstraint<_Vp>, typename = typename enable_if< __safe_conversion_raw<_Up>::value, bool>::type>

std::unique_ptr< _Tp[], _Dp >::unique_ptr | ( | _Up | __p | ) |

inline explicit noexcept

Takes ownership of a pointer.

Parameters

  __p | A pointer to an array of a type safely convertible to an array of `element_type`

The deleter will be value-initialized.

Definition at line 463 of file unique_ptr.h.

## unique_ptr() [4/13]

template<typename _Tp , typename _Dp >
template<typename _Up , typename = typename enable_if< __safe_conversion_raw<_Up>::value, bool>::type>

std::unique_ptr< _Tp[], _Dp >::unique_ptr | ( | _Up | __p,
|  | typename conditional< is_reference< deleter_type >::value, deleter_type, const deleter_type & >::type | __d
| ) |  |

inline noexcept

Takes ownership of a pointer.

Parameters

  __p | A pointer to an array of a type safely convertible to an array of `element_type`
  __d | A reference to a deleter.

The deleter will be initialized with `__d`

Definition at line 478 of file unique_ptr.h.

## unique_ptr() [5/13]

template<typename _Tp , typename _Dp >
template<typename _Up , typename = typename enable_if< __safe_conversion_raw<_Up>::value, bool>::type>

std::unique_ptr< _Tp[], _Dp >::unique_ptr | ( | _Up | __p,
|  | typename remove_reference< deleter_type >::type && | __d
| ) |  |

inline noexcept

Takes ownership of a pointer.

Parameters

  __p | A pointer to an array of a type safely convertible to an array of `element_type`
  __d | A reference to a deleter.

The deleter will be initialized with `std::move(__d)`

Definition at line 494 of file unique_ptr.h.

## unique_ptr() [6/13]

template<typename _Tp , typename _Dp = default_delete<_Tp>>
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>

constexpr std::unique_ptr< _Tp, _Dp >::unique_ptr | ( | nullptr_t |  | ) |

inline constexpr noexcept

Creates a unique_ptr that owns nothing.

Definition at line 228 of file unique_ptr.h.

## unique_ptr() [7/13]

template<typename _Tp , typename _Dp >
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>

constexpr std::unique_ptr< _Tp[], _Dp >::unique_ptr | ( | nullptr_t |  | ) |

inline constexpr noexcept

Creates a unique_ptr that owns nothing.

Definition at line 507 of file unique_ptr.h.

## unique_ptr() [8/13]

template<typename _Tp , typename _Dp = default_delete<_Tp>>
template<typename _Up = _Dp, typename = _DeleterConstraint<_Up>>

std::unique_ptr< _Tp, _Dp >::unique_ptr | ( | pointer | __p | ) |

inline explicit noexcept

Takes ownership of a pointer.

Parameters

  __p | A pointer to an object of `element_type`

The deleter will be value-initialized.

Definition at line 196 of file unique_ptr.h.

## unique_ptr() [9/13]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

std::unique_ptr< _Tp, _Dp >::unique_ptr | ( | pointer | __p,
|  | typename conditional< is_reference< deleter_type >::value, deleter_type, const deleter_type & >::type | __d
| ) |  |

inline noexcept

Takes ownership of a pointer.

Parameters

  __p | A pointer to an object of `element_type`
  __d | A reference to a deleter.

The deleter will be initialized with `__d`

Definition at line 207 of file unique_ptr.h.

## unique_ptr() [10/13]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

std::unique_ptr< _Tp, _Dp >::unique_ptr | ( | pointer | __p,
|  | typename remove_reference< deleter_type >::type && | __d
| ) |  |

inline noexcept

Takes ownership of a pointer.

Parameters

  __p | A pointer to an object of `element_type`
  __d | An rvalue reference to a deleter.

The deleter will be initialized with `std::move(__d)`

Definition at line 219 of file unique_ptr.h.

## unique_ptr() [11/13]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

std::unique_ptr< _Tp, _Dp >::unique_ptr | ( | unique_ptr< _Tp, _Dp > && | __u | ) |

inline noexcept

Move constructor.

Definition at line 233 of file unique_ptr.h.

## unique_ptr() [12/13]

template<typename _Tp , typename _Dp >

std::unique_ptr< _Tp[], _Dp >::unique_ptr | ( | unique_ptr< _Tp[], _Dp > && | __u | ) |

inline noexcept

Move constructor.

Definition at line 501 of file unique_ptr.h.

## unique_ptr() [13/13]

template<typename _Tp , typename _Dp = default_delete<_Tp>>
template<typename _Up , typename _Ep , typename = _Require< __safe_conversion_up<_Up, _Ep>, typename conditional<is_reference<_Dp>::value, is_same<_Ep, _Dp>, is_convertible<_Ep, _Dp>>::type>>

std::unique_ptr< _Tp, _Dp >::unique_ptr | ( | unique_ptr< _Up, _Ep > && | __u | ) |

inline noexcept

Converting constructor from another type.

Requires that the pointer owned by `__u` is convertible to the type of pointer owned by this object, `__u` does not own an array, and `__u` has a compatible deleter type.

Definition at line 247 of file unique_ptr.h.

## ~unique_ptr() [1/2]

template<typename _Tp , typename _Dp >

std::unique_ptr< _Tp[], _Dp >::~unique_ptr | ( |  | ) |

inline

Destructor, invokes the deleter if the stored pointer is not null.

Definition at line 519 of file unique_ptr.h.

References std::unique_ptr< _Tp, _Dp >::get_deleter().

## ~unique_ptr() [2/2]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

std::unique_ptr< _Tp, _Dp >::~unique_ptr | ( |  | ) |

inline noexcept

Destructor, invokes the deleter if the stored pointer is not null.

Definition at line 259 of file unique_ptr.h.

## allocate_shared()

template<typename _Tp , typename _Alloc , typename... _Args>

shared_ptr<_Tp> std::allocate_shared | ( | const _Alloc & | __a,
|  | _Args &&... | __args
| ) |  |

inline

Create an object that is owned by a shared_ptr.

Parameters

  __a | An allocator.
  __args | Arguments for the _Tp object's constructor.

Returns
  A shared_ptr that owns the newly created object.

Exceptions

  An | exception thrown from _Alloc::allocate or from the constructor of _Tp.

A copy of __a will be used to allocate memory for the shared_ptr and the new object.

Definition at line 688 of file bits/shared_ptr.h.

## atomic_compare_exchange_strong() [1/2]

template<typename _Tp , _Lock_policy _Lp>

bool std::atomic_compare_exchange_strong | ( | __shared_ptr< _Tp, _Lp > * | __p,
|  | __shared_ptr< _Tp, _Lp > * | __v,
|  | __shared_ptr< _Tp, _Lp > | __w
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 294 of file shared_ptr_atomic.h.

References std::atomic_compare_exchange_strong_explicit().

## atomic_compare_exchange_strong() [2/2]

template<typename _Tp >

bool std::atomic_compare_exchange_strong | ( | shared_ptr< _Tp > * | __p,
|  | shared_ptr< _Tp > * | __v,
|  | shared_ptr< _Tp > | __w
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 242 of file shared_ptr_atomic.h.

References std::atomic_compare_exchange_strong_explicit().

## atomic_compare_exchange_strong_explicit() [1/2]

template<typename _Tp , _Lock_policy _Lp>

bool std::atomic_compare_exchange_strong_explicit | ( | __shared_ptr< _Tp, _Lp > * | __p,
|  | __shared_ptr< _Tp, _Lp > * | __v,
|  | __shared_ptr< _Tp, _Lp > | __w,
|  | memory_order | ,
|  | memory_order |
| ) |  |

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 272 of file shared_ptr_atomic.h.

Referenced by std::atomic_compare_exchange_strong(), and std::atomic_compare_exchange_weak_explicit().

## atomic_compare_exchange_strong_explicit() [2/2]

template<typename _Tp >

bool std::atomic_compare_exchange_strong_explicit | ( | shared_ptr< _Tp > * | __p,
|  | shared_ptr< _Tp > * | __v,
|  | shared_ptr< _Tp > | __w,
|  | memory_order | ,
|  | memory_order |
| ) |  |

Atomic compare-and-swap for shared_ptr objects.

Parameters

  __p | A non-null pointer to a shared_ptr object.
  __v | A non-null pointer to a shared_ptr object.
  __w | A non-null pointer to a shared_ptr object.

Returns
  True if `*__p` was equivalent to `*__v`, false otherwise.

The memory order for failure shall not be `memory_order_release` or `memory_order_acq_rel`, or stronger than the memory order for success.

Definition at line 220 of file shared_ptr_atomic.h.

## atomic_compare_exchange_weak() [1/2]

template<typename _Tp , _Lock_policy _Lp>

bool std::atomic_compare_exchange_weak | ( | __shared_ptr< _Tp, _Lp > * | __p,
|  | __shared_ptr< _Tp, _Lp > * | __v,
|  | __shared_ptr< _Tp, _Lp > | __w
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 316 of file shared_ptr_atomic.h.

References std::atomic_compare_exchange_weak_explicit().

## atomic_compare_exchange_weak() [2/2]

template<typename _Tp >

bool std::atomic_compare_exchange_weak | ( | shared_ptr< _Tp > * | __p,
|  | shared_ptr< _Tp > * | __v,
|  | shared_ptr< _Tp > | __w
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 263 of file shared_ptr_atomic.h.

References std::atomic_compare_exchange_weak_explicit().

## atomic_compare_exchange_weak_explicit() [1/2]

template<typename _Tp , _Lock_policy _Lp>

bool std::atomic_compare_exchange_weak_explicit | ( | __shared_ptr< _Tp, _Lp > * | __p,
|  | __shared_ptr< _Tp, _Lp > * | __v,
|  | __shared_ptr< _Tp, _Lp > | __w,
|  | memory_order | __success,
|  | memory_order | __failure
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 304 of file shared_ptr_atomic.h.

References std::atomic_compare_exchange_strong_explicit().

Referenced by std::atomic_compare_exchange_weak().

## atomic_compare_exchange_weak_explicit() [2/2]

template<typename _Tp >

bool std::atomic_compare_exchange_weak_explicit | ( | shared_ptr< _Tp > * | __p,
|  | shared_ptr< _Tp > * | __v,
|  | shared_ptr< _Tp > | __w,
|  | memory_order | __success,
|  | memory_order | __failure
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 251 of file shared_ptr_atomic.h.

References std::atomic_compare_exchange_strong_explicit().

## atomic_exchange() [1/2]

template<typename _Tp , _Lock_policy _Lp>

__shared_ptr<_Tp, _Lp> std::atomic_exchange | ( | __shared_ptr< _Tp, _Lp > * | __p,
|  | __shared_ptr< _Tp, _Lp > | __r
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 200 of file shared_ptr_atomic.h.

References std::atomic_exchange_explicit().

## atomic_exchange() [2/2]

template<typename _Tp >

shared_ptr<_Tp> std::atomic_exchange | ( | shared_ptr< _Tp > * | __p,
|  | shared_ptr< _Tp > | __r
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 181 of file shared_ptr_atomic.h.

References std::atomic_exchange_explicit().

## atomic_exchange_explicit() [1/2]

template<typename _Tp , _Lock_policy _Lp>

__shared_ptr<_Tp, _Lp> std::atomic_exchange_explicit | ( | __shared_ptr< _Tp, _Lp > * | __p,
|  | __shared_ptr< _Tp, _Lp > | __r,
|  | memory_order |
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 189 of file shared_ptr_atomic.h.

Referenced by std::atomic_exchange().

## atomic_exchange_explicit() [2/2]

template<typename _Tp >

shared_ptr<_Tp> std::atomic_exchange_explicit | ( | shared_ptr< _Tp > * | __p,
|  | shared_ptr< _Tp > | __r,
|  | memory_order |
| ) |  |

inline

Atomic exchange for shared_ptr objects.

Parameters

  __p | A non-null pointer to a shared_ptr object.
  __r | New value to store in `*__p`.

Returns
  The original value of `*__p`

Definition at line 171 of file shared_ptr_atomic.h.

## atomic_is_lock_free() [1/2]

template<typename _Tp , _Lock_policy _Lp>

bool std::atomic_is_lock_free | ( | const __shared_ptr< _Tp, _Lp > * | __p | ) |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 71 of file shared_ptr_atomic.h.

## atomic_is_lock_free() [2/2]

template<typename _Tp >

bool std::atomic_is_lock_free | ( | const shared_ptr< _Tp > * | __p | ) |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 82 of file shared_ptr_atomic.h.

## atomic_load() [1/2]

template<typename _Tp , _Lock_policy _Lp>

__shared_ptr<_Tp, _Lp> std::atomic_load | ( | const __shared_ptr< _Tp, _Lp > * | __p | ) |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 119 of file shared_ptr_atomic.h.

References std::atomic_load_explicit().

## atomic_load() [2/2]

template<typename _Tp >

shared_ptr<_Tp> std::atomic_load | ( | const shared_ptr< _Tp > * | __p | ) |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 106 of file shared_ptr_atomic.h.

References std::atomic_load_explicit().

## atomic_load_explicit() [1/2]

template<typename _Tp , _Lock_policy _Lp>

__shared_ptr<_Tp, _Lp> std::atomic_load_explicit | ( | const __shared_ptr< _Tp, _Lp > * | __p,
|  | memory_order |
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 111 of file shared_ptr_atomic.h.

Referenced by std::atomic_load().

## atomic_load_explicit() [2/2]

template<typename _Tp >

shared_ptr<_Tp> std::atomic_load_explicit | ( | const shared_ptr< _Tp > * | __p,
|  | memory_order |
| ) |  |

inline

Atomic load for shared_ptr objects.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  `*__p`

The memory order shall not be `memory_order_release` or `memory_order_acq_rel`.

Definition at line 98 of file shared_ptr_atomic.h.

## atomic_store() [1/2]

template<typename _Tp , _Lock_policy _Lp>

void std::atomic_store | ( | __shared_ptr< _Tp, _Lp > * | __p,
|  | __shared_ptr< _Tp, _Lp > | __r
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 158 of file shared_ptr_atomic.h.

References std::atomic_store_explicit().

## atomic_store() [2/2]

template<typename _Tp >

void std::atomic_store | ( | shared_ptr< _Tp > * | __p,
|  | shared_ptr< _Tp > | __r
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 143 of file shared_ptr_atomic.h.

References std::atomic_store_explicit().

## atomic_store_explicit() [1/2]

template<typename _Tp , _Lock_policy _Lp>

void std::atomic_store_explicit | ( | __shared_ptr< _Tp, _Lp > * | __p,
|  | __shared_ptr< _Tp, _Lp > | __r,
|  | memory_order |
| ) |  |

inline

Report whether shared_ptr atomic operations are lock-free.

Parameters

  __p | A non-null pointer to a shared_ptr object.

Returns
  True if atomic access to `*__p` is lock-free, false otherwise.

Definition at line 148 of file shared_ptr_atomic.h.

Referenced by std::atomic_store().

## atomic_store_explicit() [2/2]

template<typename _Tp >

void std::atomic_store_explicit | ( | shared_ptr< _Tp > * | __p,
|  | shared_ptr< _Tp > | __r,
|  | memory_order |
| ) |  |

inline

Atomic store for shared_ptr objects.

Parameters

  __p | A non-null pointer to a shared_ptr object.
  __r | The value to store.

The memory order shall not be `memory_order_acquire` or `memory_order_acq_rel`.

Definition at line 134 of file shared_ptr_atomic.h.

## get() [1/2]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

pointer std::unique_ptr< _Tp, _Dp >::get | ( |  | ) | const

inline noexcept

Return the stored pointer.

Definition at line 331 of file unique_ptr.h.

Referenced by std::unique_ptr< _Result< _Res > >::operator bool(), std::unique_ptr< _Tp[], _Dp >::operator bool(), std::unique_ptr< _Result< _Res > >::release(), and std::unique_ptr< _Tp[], _Dp >::release().

## get() [2/2]

template<typename _Tp , typename _Dp >

pointer std::unique_ptr< _Tp[], _Dp >::get | ( |  | ) | const

inline noexcept

Return the stored pointer.

Definition at line 583 of file unique_ptr.h.

## get_deleter() [1/5]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

const deleter_type& std::unique_ptr< _Tp, _Dp >::get_deleter | ( |  | ) | const

inline noexcept

Return a reference to the stored deleter.

Definition at line 341 of file unique_ptr.h.

## get_deleter() [2/5]

template<typename _Tp , typename _Dp >

const deleter_type& std::unique_ptr< _Tp[], _Dp >::get_deleter | ( |  | ) | const

inline noexcept

Return a reference to the stored deleter.

Definition at line 593 of file unique_ptr.h.

## get_deleter() [3/5]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

deleter_type& std::unique_ptr< _Tp, _Dp >::get_deleter | ( |  | ) |

inline noexcept

Return a reference to the stored deleter.

Definition at line 336 of file unique_ptr.h.

Referenced by std::unique_ptr< _Result< _Res > >::operator=(), std::unique_ptr< _Tp[], _Dp >::operator=(), std::unique_ptr< _Result< _Res > >::reset(), std::unique_ptr< _Tp[], _Dp >::reset(), std::unique_ptr< _Result< _Res > >::~unique_ptr(), and std::unique_ptr< _Tp[], _Dp >::~unique_ptr().

## get_deleter() [4/5]

template<typename _Tp , typename _Dp >

deleter_type& std::unique_ptr< _Tp[], _Dp >::get_deleter | ( |  | ) |

inline noexcept

Return a reference to the stored deleter.

Definition at line 588 of file unique_ptr.h.

## get_deleter() [5/5]

template<typename _Del , typename _Tp , _Lock_policy _Lp>

_Del* std::get_deleter | ( | const __shared_ptr< _Tp, _Lp > & | __p | ) |

inline noexcept

20.7.2.2.10 shared_ptr get_deleter

Definition at line 76 of file bits/shared_ptr.h.

## make_shared()

template<typename _Tp , typename... _Args>

shared_ptr<_Tp> std::make_shared | ( | _Args &&... | __args | ) |

inline

Create an object that is owned by a shared_ptr.

Parameters

  __args | Arguments for the _Tp object's constructor.

Returns
  A shared_ptr that owns the newly created object.

Exceptions

  std::bad_alloc,or | an exception thrown from the constructor of _Tp.

Definition at line 703 of file bits/shared_ptr.h.

## make_unique() [1/3]

template<typename _Tp , typename... _Args>

_MakeUniq<_Tp>::__single_object std::make_unique | ( | _Args &&... | __args | ) |

inline

std::make_unique for single objects

Definition at line 820 of file unique_ptr.h.

## make_unique() [2/3]

template<typename _Tp , typename... _Args>

_MakeUniq<_Tp>::__invalid_type std::make_unique | ( | _Args && | ... | ) |

inline delete

Disable std::make_unique for arrays of known bound.

## make_unique() [3/3]

template<typename _Tp >

_MakeUniq<_Tp>::__array std::make_unique | ( | size_t | __num | ) |

inline

std::make_unique for arrays of unknown bound

Definition at line 826 of file unique_ptr.h.

## operator bool() [1/2]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

std::unique_ptr< _Tp, _Dp >::operator bool | ( |  | ) | const

inline explicit noexcept

Return `true` if the stored pointer is not null.

Definition at line 345 of file unique_ptr.h.

## operator bool() [2/2]

template<typename _Tp , typename _Dp >

std::unique_ptr< _Tp[], _Dp >::operator bool | ( |  | ) | const

inline explicit noexcept

Return `true` if the stored pointer is not null.

Definition at line 597 of file unique_ptr.h.

References std::unique_ptr< _Tp, _Dp >::get().

## operator()() [1/2]

template<typename _Tp >

void std::default_delete< _Tp >::operator() | ( | _Tp * | __ptr | ) | const

inline

Calls `delete` `__ptr`.

Definition at line 72 of file unique_ptr.h.

## operator()() [2/2]

template<typename _Tp >
template<typename _Up >

enable_if<is_convertible<_Up(*)[], _Tp(*)[]>::value>::type std::default_delete< _Tp[]>::operator() | ( | _Up * | __ptr | ) | const

inline

Calls `delete`[] `__ptr`.

Definition at line 108 of file unique_ptr.h.

## operator*()

template<typename _Tp , typename _Dp = default_delete<_Tp>>

add_lvalue_reference<element_type>::type std::unique_ptr< _Tp, _Dp >::operator* | ( |  | ) | const

inline

Dereference the stored pointer.

Definition at line 315 of file unique_ptr.h.

## operator->()

template<typename _Tp , typename _Dp = default_delete<_Tp>>

pointer std::unique_ptr< _Tp, _Dp >::operator-> | ( |  | ) | const

inline noexcept

Return the stored pointer.

Definition at line 323 of file unique_ptr.h.

## operator<<()

template<typename _Ch , typename _Tr , typename _Tp , _Lock_policy _Lp>

std::basic_ostream<_Ch, _Tr>& std::operator<< | ( | std::basic_ostream< _Ch, _Tr > & | __os,
|  | const __shared_ptr< _Tp, _Lp > & | __p
| ) |  |

inline

20.7.2.2.11 shared_ptr I/O

Definition at line 66 of file bits/shared_ptr.h.

## operator=() [1/6]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

unique_ptr& std::unique_ptr< _Tp, _Dp >::operator= | ( | nullptr_t |  | ) |

inline noexcept

Reset the unique_ptr to empty, invoking the deleter if necessary.

Definition at line 305 of file unique_ptr.h.

## operator=() [2/6]

template<typename _Tp , typename _Dp >

unique_ptr& std::unique_ptr< _Tp[], _Dp >::operator= | ( | nullptr_t |  | ) |

inline noexcept

Reset the unique_ptr to empty, invoking the deleter if necessary.

Definition at line 565 of file unique_ptr.h.

References std::unique_ptr< _Tp, _Dp >::reset().

## operator=() [3/6]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

unique_ptr& std::unique_ptr< _Tp, _Dp >::operator= | ( | unique_ptr< _Tp, _Dp > && | __u | ) |

inline noexcept

Move assignment operator.

Parameters

  __u | The object to transfer ownership from.

Invokes the deleter first if this object owns a pointer.

Definition at line 276 of file unique_ptr.h.

## operator=() [4/6]

template<typename _Tp , typename _Dp >

unique_ptr& std::unique_ptr< _Tp[], _Dp >::operator= | ( | unique_ptr< _Tp[], _Dp > && | __u | ) |

inline noexcept

Move assignment operator.

Parameters

  __u | The object to transfer ownership from.

Invokes the deleter first if this object owns a pointer.

Definition at line 536 of file unique_ptr.h.

References std::unique_ptr< _Tp, _Dp >::get_deleter(), and std::unique_ptr< _Tp, _Dp >::reset().

## operator=() [5/6]

template<typename _Tp , typename _Dp = default_delete<_Tp>>
template<typename _Up , typename _Ep >

enable_if< __and_< __safe_conversion_up<_Up, _Ep>, is_assignable<deleter_type&, _Ep&&> >::value, unique_ptr&>::type std::unique_ptr< _Tp, _Dp >::operator= | ( | unique_ptr< _Up, _Ep > && | __u | ) |

inline noexcept

Assignment from another type.

Parameters

  __u | The object to transfer ownership from, which owns a convertible pointer to a non-array object.

Invokes the deleter first if this object owns a pointer.

Definition at line 296 of file unique_ptr.h.

## operator=() [6/6]

template<typename _Tp , typename _Dp >
template<typename _Up , typename _Ep >

enable_if<__and_<__safe_conversion_up<_Up, _Ep>, is_assignable<deleter_type&, _Ep&&> >::value, unique_ptr&>::type std::unique_ptr< _Tp[], _Dp >::operator= | ( | unique_ptr< _Up, _Ep > && | __u | ) |

inline noexcept

Assignment from another type.

Parameters

  __u | The object to transfer ownership from, which owns a convertible pointer to an array object.

Invokes the deleter first if this object owns a pointer.

Definition at line 556 of file unique_ptr.h.

References std::unique_ptr< _Tp, _Dp >::get_deleter(), and std::unique_ptr< _Tp, _Dp >::reset().

## operator[]()

template<typename _Tp , typename _Dp >

std::add_lvalue_reference<element_type>::type std::unique_ptr< _Tp[], _Dp >::operator[] | ( | size_t | __i | ) | const

inline

Access an element of owned array.

Definition at line 575 of file unique_ptr.h.

## release() [1/2]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

pointer std::unique_ptr< _Tp, _Dp >::release | ( |  | ) |

inline noexcept

Release ownership of any stored pointer.

Definition at line 352 of file unique_ptr.h.

## release() [2/2]

template<typename _Tp , typename _Dp >

pointer std::unique_ptr< _Tp[], _Dp >::release | ( |  | ) |

inline noexcept

Release ownership of any stored pointer.

Definition at line 604 of file unique_ptr.h.

References std::unique_ptr< _Tp, _Dp >::get().

## reset() [1/2]

template<typename _Tp , typename _Dp >
template<typename _Up , typename = _Require< __or_<is_same<_Up, pointer>, __and_<is_same<pointer, element_type*>, is_pointer<_Up>, is_convertible< typename remove_pointer<_Up>::type(*)[], element_type(*)[] > > > >>

void std::unique_ptr< _Tp[], _Dp >::reset | ( | _Up | __p | ) |

inline noexcept

Replace the stored pointer.

Parameters

  __p | The new pointer to store.

The deleter will be invoked if a pointer is already owned.

Definition at line 630 of file unique_ptr.h.

References std::unique_ptr< _Tp, _Dp >::get_deleter(), and std::unique_ptr< _Tp, _Dp >::swap().

## reset() [2/2]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

void std::unique_ptr< _Tp, _Dp >::reset | ( | pointer | __p = `pointer()` | ) |

inline noexcept

Replace the stored pointer.

Parameters

  __p | The new pointer to store.

The deleter will be invoked if a pointer is already owned.

Definition at line 366 of file unique_ptr.h.

Referenced by std::unique_ptr< _Result< _Res > >::operator=(), and std::unique_ptr< _Tp[], _Dp >::operator=().

## swap() [1/2]

template<typename _Tp , typename _Dp = default_delete<_Tp>>

void std::unique_ptr< _Tp, _Dp >::swap | ( | unique_ptr< _Tp, _Dp > & | __u | ) |

inline noexcept

Exchange the pointer and deleter with another object.

Definition at line 376 of file unique_ptr.h.

Referenced by std::unique_ptr< _Result< _Res > >::reset(), std::unique_ptr< _Tp[], _Dp >::reset(), std::unique_ptr< _Result< _Res > >::swap(), and std::unique_ptr< _Tp[], _Dp >::swap().

## swap() [2/2]

template<typename _Tp , typename _Dp >

void std::unique_ptr< _Tp[], _Dp >::swap | ( | unique_ptr< _Tp[], _Dp > & | __u | ) |

inline noexcept

Exchange the pointer and deleter with another object.

Definition at line 646 of file unique_ptr.h.

References std::unique_ptr< _Tp, _Dp >::swap().

## Friends

## allocate_shared

template<typename _Tp >
template<typename _Yp , typename _Alloc , typename... _Args>

shared_ptr<_Yp> allocate_shared | ( | const _Alloc & | __a,
|  | _Args &&... | __args
| ) |  |

friend

Create an object that is owned by a shared_ptr.

Parameters

  __a | An allocator.
  __args | Arguments for the _Tp object's constructor.

Returns
  A shared_ptr that owns the newly created object.

Exceptions

  An | exception thrown from _Alloc::allocate or from the constructor of _Tp.

A copy of __a will be used to allocate memory for the shared_ptr and the new object.

Definition at line 688 of file bits/shared_ptr.h.