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 , 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 _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr	std::unique_ptr< _Tp, _Dp >::unique_ptr () noexcept

template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
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 _Del = deleter_type, typename = _Require<__safe_conversion_raw<_Up>, is_move_constructible<_Del>>>
	std::unique_ptr< _Tp[], _Dp >::unique_ptr (_Up __p, __enable_if_t<!is_lvalue_reference< _Del >::value, _Del && > __d) noexcept

template<typename _Up , typename _Del = deleter_type, typename = _Require<__safe_conversion_raw<_Up>, is_copy_constructible<_Del>>>
	std::unique_ptr< _Tp[], _Dp >::unique_ptr (_Up __p, const deleter_type &__d) noexcept

template<typename _Up , typename _Del = deleter_type, typename _DelUnref = typename remove_reference<_Del>::type, typename = _Require<__safe_conversion_raw<_Up>>>
	std::unique_ptr< _Tp[], _Dp >::unique_ptr (_Up, __enable_if_t< is_lvalue_reference< _Del >::value, _DelUnref && >)=delete

	std::unique_ptr< _Tp, _Dp >::unique_ptr (const unique_ptr &)=delete

	std::unique_ptr< _Tp[], _Dp >::unique_ptr (const unique_ptr &)=delete

template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr	std::unique_ptr< _Tp, _Dp >::unique_ptr (nullptr_t) noexcept

template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
constexpr	std::unique_ptr< _Tp[], _Dp >::unique_ptr (nullptr_t) noexcept

template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>
	std::unique_ptr< _Tp, _Dp >::unique_ptr (pointer __p) noexcept

template<typename _Del = deleter_type, typename = _Require<is_move_constructible<_Del>>>
	std::unique_ptr< _Tp, _Dp >::unique_ptr (pointer __p, __enable_if_t<!is_lvalue_reference< _Del >::value, _Del && > __d) noexcept

template<typename _Del = deleter_type, typename = _Require<is_copy_constructible<_Del>>>
	std::unique_ptr< _Tp, _Dp >::unique_ptr (pointer __p, const deleter_type &__d) noexcept

template<typename _Del = deleter_type, typename _DelUnref = typename remove_reference<_Del>::type>
	std::unique_ptr< _Tp, _Dp >::unique_ptr (pointer, __enable_if_t< is_lvalue_reference< _Del >::value, _DelUnref && >)=delete

	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

template<typename _Del , typename _Tp >
_Del *	std::get_deleter (const shared_ptr< _Tp > &__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 >
_GLIBCXX_NODISCARD bool	std::operator!= (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator!= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
_GLIBCXX_NODISCARD bool	std::operator!= (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD bool	std::operator!= (const unique_ptr< _Tp, _Dp > &__x, nullptr_t) noexcept

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator!= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD 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 >
_GLIBCXX_NODISCARD bool	std::operator< (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator< (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
_GLIBCXX_NODISCARD bool	std::operator< (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD bool	std::operator< (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator< (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD 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 >
_GLIBCXX_NODISCARD bool	std::operator<= (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator<= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
_GLIBCXX_NODISCARD bool	std::operator<= (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD bool	std::operator<= (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator<= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD 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 >
_GLIBCXX_NODISCARD bool	std::operator== (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator== (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
_GLIBCXX_NODISCARD bool	std::operator== (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD bool	std::operator== (const unique_ptr< _Tp, _Dp > &__x, nullptr_t) noexcept

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator== (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD bool	std::operator== (nullptr_t, const unique_ptr< _Tp, _Dp > &__x) noexcept

template<typename _Tp , typename _Up >
_GLIBCXX_NODISCARD bool	std::operator> (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator> (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
_GLIBCXX_NODISCARD bool	std::operator> (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD bool	std::operator> (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator> (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD bool	std::operator> (nullptr_t, const unique_ptr< _Tp, _Dp > &__x)

template<typename _Tp , typename _Up >
_GLIBCXX_NODISCARD bool	std::operator>= (const shared_ptr< _Tp > &__a, const shared_ptr< _Up > &__b) noexcept

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator>= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept

template<typename _Tp , typename _Dp , typename _Up , typename _Ep >
_GLIBCXX_NODISCARD bool	std::operator>= (const unique_ptr< _Tp, _Dp > &__x, const unique_ptr< _Up, _Ep > &__y)

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD bool	std::operator>= (const unique_ptr< _Tp, _Dp > &__x, nullptr_t)

template<typename _Tp >
_GLIBCXX_NODISCARD bool	std::operator>= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept

template<typename _Tp , typename _Dp >
_GLIBCXX_NODISCARD 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

void	std::__uniq_ptr_impl< _Tp, _Dp >::swap (__uniq_ptr_impl &__rhs) 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 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 ( )

constexprdefaultnoexcept

Default constructor.

◆ default_delete() [2/4]

template<typename _Tp >

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

constexprdefaultnoexcept

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 > & )

inlinenoexcept

Converting constructor.

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

Definition at line 71 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[]> & )

inlinenoexcept

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 106 of file unique_ptr.h.

◆ shared_ptr() [1/12]

template<typename _Tp >

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

inlineconstexprnoexcept

Construct an empty shared_ptr.

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

Definition at line 127 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 )

inlineexplicit

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 139 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 156 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 193 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 )

inlinenoexcept

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 246 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
	)

inlinenoexcept

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 234 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 )

inlineexplicit

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 275 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 173 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 212 of file bits/shared_ptr.h.

◆ shared_ptr() [10/12]

template<typename _Tp >

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

inlineconstexprnoexcept

Construct an empty shared_ptr.

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

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

◆ shared_ptr() [11/12]

template<typename _Tp >

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

inlinenoexcept

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 254 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 )

inlinenoexcept

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 263 of file bits/shared_ptr.h.

◆ unique_ptr() [1/13]

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

template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>

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

inlineconstexprnoexcept

Default constructor, creates a unique_ptr that owns nothing.

Definition at line 199 of file unique_ptr.h.

◆ unique_ptr() [2/13]

template<typename _Tp , typename _Dp >

template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>

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

inlineconstexprnoexcept

Default constructor, creates a unique_ptr that owns nothing.

Definition at line 476 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 )

inlineexplicitnoexcept

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 493 of file unique_ptr.h.

◆ unique_ptr() [4/13]

template<typename _Tp , typename _Dp >

template<typename _Up , typename _Del = deleter_type, typename = _Require<__safe_conversion_raw<_Up>, is_move_constructible<_Del>>>

std::unique_ptr< _Tp[], _Dp >::unique_ptr	(	_Up	__p,
		__enable_if_t<!is_lvalue_reference< _Del >::value, _Del && >	__d
	)

inlinenoexcept

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 522 of file unique_ptr.h.

◆ unique_ptr() [5/13]

template<typename _Tp , typename _Dp >

template<typename _Up , typename _Del = deleter_type, typename = _Require<__safe_conversion_raw<_Up>, is_copy_constructible<_Del>>>

std::unique_ptr< _Tp[], _Dp >::unique_ptr	(	_Up	__p,
		const deleter_type &	__d
	)

inlinenoexcept

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 508 of file unique_ptr.h.

◆ unique_ptr() [6/13]

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

template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>

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

inlineconstexprnoexcept

Creates a unique_ptr that owns nothing.

Definition at line 250 of file unique_ptr.h.

◆ unique_ptr() [7/13]

template<typename _Tp , typename _Dp >

template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>

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

inlineconstexprnoexcept

Creates a unique_ptr that owns nothing.

Definition at line 541 of file unique_ptr.h.

◆ unique_ptr() [8/13]

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

template<typename _Del = _Dp, typename = _DeleterConstraint<_Del>>

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

inlineexplicitnoexcept

Takes ownership of a pointer.

Parameters

__p	A pointer to an object of `element_type`

The deleter will be value-initialized.

Definition at line 211 of file unique_ptr.h.

◆ unique_ptr() [9/13]

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

template<typename _Del = deleter_type, typename = _Require<is_move_constructible<_Del>>>

std::unique_ptr< _Tp, _Dp >::unique_ptr	(	pointer	__p,
		__enable_if_t<!is_lvalue_reference< _Del >::value, _Del && >	__d
	)

inlinenoexcept

Takes ownership of a pointer.

Parameters

__p	A pointer to an object of `element_type`
__d	An rvalue reference to a (non-reference) deleter.

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

Definition at line 236 of file unique_ptr.h.

◆ unique_ptr() [10/13]

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

template<typename _Del = deleter_type, typename = _Require<is_copy_constructible<_Del>>>

std::unique_ptr< _Tp, _Dp >::unique_ptr	(	pointer	__p,
		const deleter_type &	__d
	)

inlinenoexcept

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 224 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 )

inlinenoexcept

Move constructor.

Definition at line 257 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 )

inlinenoexcept

Move constructor.

Definition at line 536 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 )

inlinenoexcept

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 271 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 555 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 ( )

inlinenoexcept

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

Definition at line 286 of file unique_ptr.h.

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

◆ 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 699 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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.

◆ 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 ( void ) const

inlinenoexcept

Return the stored pointer.

Definition at line 360 of file unique_ptr.h.

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

◆ get() [2/2]

template<typename _Tp , typename _Dp >

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

inlinenoexcept

Return the stored pointer.

Definition at line 619 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

inlinenoexcept

Return a reference to the stored deleter.

Definition at line 370 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

inlinenoexcept

Return a reference to the stored deleter.

Definition at line 629 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 ( )

inlinenoexcept

Return a reference to the stored deleter.

Definition at line 365 of file unique_ptr.h.

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

◆ get_deleter() [4/5]

template<typename _Tp , typename _Dp >

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

inlinenoexcept

Return a reference to the stored deleter.

Definition at line 624 of file unique_ptr.h.

◆ get_deleter() [5/5]

template<typename _Del , typename _Tp >

_Del* std::get_deleter ( const shared_ptr< _Tp > & __p )

inlinenoexcept

20.7.2.2.10 shared_ptr get_deleter

Definition at line 87 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 714 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 856 of file unique_ptr.h.

◆ make_unique() [2/3]

template<typename _Tp , typename... _Args>

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

inlinedelete

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 862 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

inlineexplicitnoexcept

Return true if the stored pointer is not null.

Definition at line 374 of file unique_ptr.h.

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

◆ operator bool() [2/2]

template<typename _Tp , typename _Dp >

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

inlineexplicitnoexcept

Return true if the stored pointer is not null.

Definition at line 633 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 75 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 111 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 344 of file unique_ptr.h.

◆ operator->()

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

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

inlinenoexcept

Return the stored pointer.

Definition at line 352 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 1 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 )

inlinenoexcept

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

Definition at line 334 of file unique_ptr.h.

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

◆ operator=() [2/6]

template<typename _Tp , typename _Dp >

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

inlinenoexcept

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

Definition at line 601 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 )

inlinenoexcept

Move assignment operator.

Parameters

__u	The object to transfer ownership from.

Invokes the deleter first if this object owns a pointer.

Definition at line 305 of file unique_ptr.h.

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

◆ operator=() [4/6]

template<typename _Tp , typename _Dp >

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

inlinenoexcept

Move assignment operator.

Parameters

__u	The object to transfer ownership from.

Invokes the deleter first if this object owns a pointer.

Definition at line 572 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 )

inlinenoexcept

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 325 of file unique_ptr.h.

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

◆ 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 )

inlinenoexcept

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 592 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 611 of file unique_ptr.h.

◆ release() [1/2]

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

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

inlinenoexcept

Release ownership of any stored pointer.

Definition at line 381 of file unique_ptr.h.

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

◆ release() [2/2]

template<typename _Tp , typename _Dp >

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

inlinenoexcept

Release ownership of any stored pointer.

Definition at line 640 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 )

inlinenoexcept

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 666 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() )

inlinenoexcept

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 395 of file unique_ptr.h.

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

Referenced by std::unique_ptr< _Tp, _Dp >::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 )

inlinenoexcept

Exchange the pointer and deleter with another object.

Definition at line 407 of file unique_ptr.h.

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

◆ swap() [2/2]

template<typename _Tp , typename _Dp >

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

inlinenoexcept

Exchange the pointer and deleter with another object.

Definition at line 682 of file unique_ptr.h.

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 699 of file bits/shared_ptr.h.

Classes

Macros

Typedefs

Functions

Friends

Detailed Description

Function Documentation

◆ default_delete() [1/4]

◆ default_delete() [2/4]

◆ default_delete() [3/4]

◆ default_delete() [4/4]

◆ shared_ptr() [1/12]

◆ shared_ptr() [2/12]

◆ shared_ptr() [3/12]

◆ shared_ptr() [4/12]

◆ shared_ptr() [5/12]

◆ shared_ptr() [6/12]

◆ shared_ptr() [7/12]

◆ shared_ptr() [8/12]

◆ shared_ptr() [9/12]

◆ shared_ptr() [10/12]

◆ shared_ptr() [11/12]

◆ shared_ptr() [12/12]

◆ unique_ptr() [1/13]

◆ unique_ptr() [2/13]

◆ unique_ptr() [3/13]

◆ unique_ptr() [4/13]

◆ unique_ptr() [5/13]

◆ unique_ptr() [6/13]

◆ unique_ptr() [7/13]

◆ unique_ptr() [8/13]

◆ unique_ptr() [9/13]

◆ unique_ptr() [10/13]

◆ unique_ptr() [11/13]

◆ unique_ptr() [12/13]

◆ unique_ptr() [13/13]

◆ ~unique_ptr() [1/2]

◆ ~unique_ptr() [2/2]

◆ allocate_shared()

◆ atomic_compare_exchange_strong() [1/2]

◆ atomic_compare_exchange_strong() [2/2]

◆ atomic_compare_exchange_strong_explicit() [1/2]

◆ atomic_compare_exchange_strong_explicit() [2/2]

◆ atomic_compare_exchange_weak() [1/2]

◆ atomic_compare_exchange_weak() [2/2]

◆ atomic_compare_exchange_weak_explicit() [1/2]

◆ atomic_compare_exchange_weak_explicit() [2/2]

◆ atomic_exchange() [1/2]

◆ atomic_exchange() [2/2]

◆ atomic_exchange_explicit() [1/2]

◆ atomic_exchange_explicit() [2/2]

◆ atomic_is_lock_free() [1/2]

◆ atomic_is_lock_free() [2/2]

◆ atomic_load() [1/2]

◆ atomic_load() [2/2]

◆ atomic_load_explicit() [1/2]

◆ atomic_load_explicit() [2/2]

◆ atomic_store() [1/2]

◆ atomic_store() [2/2]

◆ atomic_store_explicit() [1/2]

◆ atomic_store_explicit() [2/2]

◆ get() [1/2]

◆ get() [2/2]

◆ get_deleter() [1/5]

◆ get_deleter() [2/5]

◆ get_deleter() [3/5]

◆ get_deleter() [4/5]

◆ get_deleter() [5/5]

◆ make_shared()

◆ make_unique() [1/3]

◆ make_unique() [2/3]

◆ make_unique() [3/3]

◆ operator bool() [1/2]

◆ operator bool() [2/2]

◆ operator()() [1/2]

◆ operator()() [2/2]

◆ operator*()

◆ operator->()

◆ operator<<()

◆ operator=() [1/6]