Inherits std::__shared_ptr< _Tp, _Lp >.

Public Types
using	element_type = typename __shared_ptr< _Tp >::element_type

Public Member Functions
constexpr	shared_ptr () noexcept

template<typename _Yp , typename = _Constructible<_Yp*>>
	shared_ptr (_Yp *__p)

template<typename _Yp , typename _Deleter , typename = _Constructible<_Yp*, _Deleter>>
	shared_ptr (_Yp *__p, _Deleter __d)

template<typename _Yp , typename _Deleter , typename _Alloc , typename = _Constructible<_Yp*, _Deleter, _Alloc>>
	shared_ptr (_Yp *__p, _Deleter __d, _Alloc __a)

	shared_ptr (const shared_ptr &) noexcept=default

template<typename _Yp , typename = _Constructible<const shared_ptr<_Yp>&>>
	shared_ptr (const shared_ptr< _Yp > &__r) noexcept

template<typename _Yp >
	shared_ptr (const shared_ptr< _Yp > &__r, element_type *__p) noexcept

template<typename _Yp , typename = _Constructible<const weak_ptr<_Yp>&>>
	shared_ptr (const weak_ptr< _Yp > &__r)

template<typename _Deleter >
	shared_ptr (nullptr_t __p, _Deleter __d)

template<typename _Deleter , typename _Alloc >
	shared_ptr (nullptr_t __p, _Deleter __d, _Alloc __a)

constexpr	shared_ptr (nullptr_t) noexcept

	shared_ptr (shared_ptr &&__r) noexcept

template<typename _Yp , typename = _Constructible<shared_ptr<_Yp>>>
	shared_ptr (shared_ptr< _Yp > &&__r) noexcept

template<typename _Tp1 , typename >
	shared_ptr (std::auto_ptr< _Tp1 > &&__r)

template<typename _Yp , typename _Del , typename = _Constructible<unique_ptr<_Yp, _Del>>>
	shared_ptr (unique_ptr< _Yp, _Del > &&__r)

element_type *	get () const noexcept

	operator bool () const

shared_ptr &	operator= (const shared_ptr &) noexcept=default

template<typename _Yp >
_Assignable< const shared_ptr< _Yp > & >	operator= (const shared_ptr< _Yp > &__r) noexcept

shared_ptr &	operator= (shared_ptr &&__r) noexcept

template<class _Yp >
_Assignable< shared_ptr< _Yp > >	operator= (shared_ptr< _Yp > &&__r) noexcept

template<typename _Yp , typename _Del >
_Assignable< unique_ptr< _Yp, _Del > >	operator= (unique_ptr< _Yp, _Del > &&__r)

void	reset () noexcept

template<typename _Yp >
_SafeConv< _Yp >	reset (_Yp *__p)

template<typename _Yp , typename _Deleter >
_SafeConv< _Yp >	reset (_Yp *__p, _Deleter __d)

template<typename _Yp , typename _Deleter , typename _Alloc >
_SafeConv< _Yp >	reset (_Yp *__p, _Deleter __d, _Alloc __a)

void	swap (__shared_ptr< _Tp, _Lp > &__other) noexcept

bool	unique () const noexcept

long	use_count () const noexcept

Friends
template<typename _Yp , typename _Alloc , typename... _Args>
shared_ptr< _Yp >	allocate_shared (const _Alloc &__a, _Args &&... __args)

class	weak_ptr< _Tp >

Related Functions
(Note that these are not member functions.)
template<typename _Del , typename _Tp >
_Del *	get_deleter (const shared_ptr< _Tp > &__p) noexcept

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

template<typename _Tp >
void	swap (shared_ptr< _Tp > &__a, shared_ptr< _Tp > &__b) noexcept

template<typename _Tp , typename _Up >
shared_ptr< _Tp >	static_pointer_cast (const shared_ptr< _Up > &__r) noexcept

template<typename _Tp , typename _Up >
shared_ptr< _Tp >	const_pointer_cast (const shared_ptr< _Up > &__r) noexcept

template<typename _Tp , typename _Up >
shared_ptr< _Tp >	dynamic_pointer_cast (const shared_ptr< _Up > &__r) noexcept

template<typename _Tp , typename _Alloc , typename... _Args>
shared_ptr< _Tp >	allocate_shared (const _Alloc &__a, _Args &&... __args)

template<typename _Tp , typename... _Args>
shared_ptr< _Tp >	make_shared (_Args &&... __args)


template<typename _Tp , _Lock_policy _Lp>
bool	atomic_is_lock_free (const __shared_ptr< _Tp, _Lp > *__p)

template<typename _Tp >
shared_ptr< _Tp >	atomic_load_explicit (const shared_ptr< _Tp > *__p, memory_order)

template<typename _Tp >
void	atomic_store_explicit (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r, memory_order)

template<typename _Tp >
shared_ptr< _Tp >	atomic_exchange_explicit (shared_ptr< _Tp > *__p, shared_ptr< _Tp > __r, memory_order)

template<typename _Tp >
bool	atomic_compare_exchange_strong_explicit (shared_ptr< _Tp > __p, shared_ptr< _Tp > __v, shared_ptr< _Tp > __w, memory_order, memory_order)

Detailed Description

template<typename _Tp>
class std::shared_ptr< _Tp >

A smart pointer with reference-counted copy semantics.

A shared_ptr object is either empty or owns a pointer passed to the constructor. Copies of a shared_ptr share ownership of the same pointer. When the last shared_ptr that owns the pointer is destroyed or reset, the owned pointer is freed (either by delete or by invoking a custom deleter that was passed to the constructor).

A shared_ptr also stores another pointer, which is usually (but not always) the same pointer as it owns. The stored pointer can be retrieved by calling the get() member function.

The equality and relational operators for shared_ptr only compare the stored pointer returned by get(), not the owned pointer. To test whether two shared_ptr objects share ownership of the same pointer see std::shared_ptr::owner_before and std::owner_less.

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

Member Function Documentation

◆ get()

template<typename _Tp , _Lock_policy _Lp>

element_type* std::__shared_ptr< _Tp, _Lp >::get ( ) const

inlinenoexceptinherited

Return the stored pointer.

Definition at line 1324 of file shared_ptr_base.h.

◆ operator bool()

template<typename _Tp , _Lock_policy _Lp>

std::__shared_ptr< _Tp, _Lp >::operator bool ( ) const

inlineexplicitinherited

Return true if the stored pointer is not null.

Definition at line 1328 of file shared_ptr_base.h.

◆ owner_before() [1/2]

template<typename _Tp , _Lock_policy _Lp>

template<typename _Tp1 >

bool std::__shared_ptr< _Tp, _Lp >::owner_before ( __shared_ptr< _Tp1, _Lp > const & __rhs ) const

inlinenoexceptinherited

Define an ordering based on ownership.

This function defines a strict weak ordering between two shared_ptr or weak_ptr objects, such that one object is less than the other unless they share ownership of the same pointer, or are both empty.

Definition at line 1358 of file shared_ptr_base.h.

◆ owner_before() [2/2]

template<typename _Tp , _Lock_policy _Lp>

template<typename _Tp1 >

bool std::__shared_ptr< _Tp, _Lp >::owner_before ( __weak_ptr< _Tp1, _Lp > const & __rhs ) const

inlinenoexceptinherited

Define an ordering based on ownership.

This function defines a strict weak ordering between two shared_ptr or weak_ptr objects, such that one object is less than the other unless they share ownership of the same pointer, or are both empty.

Definition at line 1363 of file shared_ptr_base.h.

◆ swap()

template<typename _Tp , _Lock_policy _Lp>

void std::__shared_ptr< _Tp, _Lp >::swap ( __shared_ptr< _Tp, _Lp > & __other )

inlinenoexceptinherited

Exchange both the owned pointer and the stored pointer.

Definition at line 1343 of file shared_ptr_base.h.

◆ unique()

template<typename _Tp , _Lock_policy _Lp>

bool std::__shared_ptr< _Tp, _Lp >::unique ( ) const

inlinenoexceptinherited

Return true if use_count() == 1.

Definition at line 1333 of file shared_ptr_base.h.

◆ use_count()

template<typename _Tp , _Lock_policy _Lp>

long std::__shared_ptr< _Tp, _Lp >::use_count ( ) const

inlinenoexceptinherited

If *this owns a pointer, return the number of owners, otherwise zero.

Definition at line 1338 of file shared_ptr_base.h.

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

Public Types

Public Member Functions

Friends

Related Functions

Detailed Description

template<typename _Tp> class std::shared_ptr< _Tp >

Member Function Documentation

◆ get()

◆ operator bool()

◆ owner_before() [1/2]

◆ owner_before() [2/2]

◆ swap()

◆ unique()

◆ use_count()

template<typename _Tp>
class std::shared_ptr< _Tp >