Install Now
std::shared_ptr< _Tp > - A smart pointer with reference-counted copy semantics.
Contents
Constructor & Destructor Documentation
template<typename_Tp>constexprstd::shared_ptr<_Tp>::shared_ptr()[inline],[constexpr],[noexcept]
Construct an empty shared_ptr.
Postcondition
use_count()==0 && get()==0
template<typename_Tp>std::shared_ptr<_Tp>::shared_ptr(constshared_ptr<_Tp>&)[default],[noexcept]
Copy constructor.
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
Exceptionsstd::bad_alloc,in which case delete __p is called.
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
Exceptionsstd::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)
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
Exceptionsstd::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)
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
Exceptionsstd::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)
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
Exceptionsstd::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)
template<typename_Tp>template<typename_Yp>std::shared_ptr<_Tp>::shared_ptr(constshared_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. The complete object will remain valid while any shared_ptr owns it, even if they don't store
a pointer to the complete object.
shared_ptr<pair<int,int>> pii(new pair<int,int>());
shared_ptr<int> pi(pii, &pii->first);
assert(pii.use_count() == 2);
template<typename_Tp>template<typename_Yp>std::shared_ptr<_Tp>::shared_ptr(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 && !__r.use_count() && !__r.get()
Since
C++17
This can be used to construct a shared_ptr to a sub-object of an object managed by an existing
shared_ptr. The complete object will remain valid while any shared_ptr owns it, even if they don't store
a pointer to the complete object.
shared_ptr<pair<int,int>> pii(new pair<int,int>());
shared_ptr<int> pi1(pii, &pii->first);
assert(pii.use_count() == 2);
shared_ptr<int> pi2(std::move(pii), &pii->second);
assert(pii.use_count() == 0);
template<typename_Tp>template<typename_Yp,typename=_Constructible<constshared_ptr<_Yp>&>>std::shared_ptr<_Tp>::shared_ptr(constshared_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()
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.
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.
template<typename_Tp>template<typename_Yp,typename=_Constructible<constweak_ptr<_Yp>&>>std::shared_ptr<_Tp>::shared_ptr(constweak_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()
Exceptionsbad_weak_ptr when __r.expired(), in which case the constructor has no effect.
template<typename_Tp>constexprstd::shared_ptr<_Tp>::shared_ptr(nullptr_t)[inline],[constexpr],[noexcept]
Construct an empty shared_ptr.
Postcondition
use_count() == 0 && get() == nullptr
Detailed Description
template<typename_Tp>
class std::shared_ptr< _Tp >"A smart pointer with reference-counted copy semantics.
Since
C++11
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.
Member Function Documentation
template<typename_Tp,_Lock_policy_Lp>element_type*std::__shared_ptr<_Tp,_Lp>::get()const[inline],[noexcept],[inherited]
Return the stored pointer.
template<typename_Tp,_Lock_policy_Lp>std::__shared_ptr<_Tp,_Lp>::operatorbool()const[inline],[explicit],[noexcept],[inherited]
Return true if the stored pointer is not null.
template<typename_Tp,_Lock_policy_Lp>template<typename_Tp1>boolstd::__shared_ptr<_Tp,_Lp>::owner_before(__shared_ptr<_Tp1,_Lp>const&__rhs)const[inline],[noexcept],[inherited]
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.
template<typename_Tp,_Lock_policy_Lp>template<typename_Tp1>boolstd::__shared_ptr<_Tp,_Lp>::owner_before(__weak_ptr<_Tp1,_Lp>const&__rhs)const[inline],[noexcept],[inherited]
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.
template<typename_Tp,_Lock_policy_Lp>voidstd::__shared_ptr<_Tp,_Lp>::swap(__shared_ptr<_Tp,_Lp>&__other)[inline],[noexcept],[inherited]
Exchange both the owned pointer and the stored pointer.
template<typename_Tp,_Lock_policy_Lp>boolstd::__shared_ptr<_Tp,_Lp>::unique()const[inline],[noexcept],[inherited]
Return true if use_count() == 1.
template<typename_Tp,_Lock_policy_Lp>longstd::__shared_ptr<_Tp,_Lp>::use_count()const[inline],[noexcept],[inherited]
If *this owns a pointer, return the number of owners, otherwise zero.
Member Typedef Documentation
template<typename_Tp>usingstd::shared_ptr<_Tp>::element_type=typename__shared_ptr<_Tp>::element_type
The type pointed to by the stored pointer, remove_extent_t<_Tp>
template<typename_Tp>usingstd::shared_ptr<_Tp>::weak_type=weak_ptr<_Tp>
The corresponding weak_ptr type for this shared_ptr.
Since
C++17
Name
std::shared_ptr< _Tp > - A smart pointer with reference-counted copy semantics.
Synopsis
#include <memory>
Inherits std::__shared_ptr< _Tp, _Lp >.
PublicTypesusingelement_type = typename __shared_ptr< _Tp >::element_type
The type pointed to by the stored pointer, remove_extent_t<_Tp>
usingweak_type = weak_ptr< _Tp >
The corresponding weak_ptr type for this shared_ptr.
PublicMemberFunctions
constexpr shared_ptr () noexcept
Construct an empty shared_ptr.
template<typename_Yp , typename = _Constructible<_Yp*>> shared_ptr (_Yp *__p)
Construct a shared_ptr that owns the pointer __p.
template<typename_Yp , typename_Deleter , typename = _Constructible<_Yp*, _Deleter>> shared_ptr (_Yp
*__p, _Deleter __d)
Construct a shared_ptr that owns the pointer __p and the deleter __d.
template<typename_Yp , typename_Deleter , typename _Alloc , typename = _Constructible<_Yp*, _Deleter,
_Alloc>> shared_ptr (_Yp *__p, _Deleter __d, _Alloc __a)
Construct a shared_ptr that owns the pointer __p and the deleter __d.
template<typename_Yp , typename = _Constructible<auto_ptr<_Yp>>> shared_ptr (auto_ptr< _Yp > &&__r)
shared_ptr (const shared_ptr &) noexcept=default
Copy constructor.
template<typename_Yp , typename = _Constructible<const shared_ptr<_Yp>&>> shared_ptr (const shared_ptr<
_Yp > &__r) noexcept
If __r is empty, constructs an empty shared_ptr; otherwise construct a shared_ptr that shares
ownership with __r.
template<typename_Yp > shared_ptr (const shared_ptr< _Yp > &__r, element_type *__p) noexcept
Constructs a shared_ptr instance that stores __p and shares ownership with __r.
template<typename_Yp , typename = _Constructible<const weak_ptr<_Yp>&>> shared_ptr (const weak_ptr< _Yp
> &__r)
Constructs a shared_ptr that shares ownership with __r and stores a copy of the pointer stored in
__r.
template<typename_Deleter > shared_ptr (nullptr_t __p, _Deleter __d)
Construct a shared_ptr that owns a null pointer and the deleter __d.
template<typename_Deleter , typename _Alloc > shared_ptr (nullptr_t __p, _Deleter __d, _Alloc __a)
Construct a shared_ptr that owns a null pointer and the deleter __d.
constexpr shared_ptr (nullptr_t) noexcept
Construct an empty shared_ptr.
shared_ptr (shared_ptr &&__r) noexcept
Move-constructs a shared_ptr instance from __r.
template<typename_Yp , typename = _Constructible<shared_ptr<_Yp>>> shared_ptr (shared_ptr< _Yp > &&__r)
noexcept
Move-constructs a shared_ptr instance from __r.
template<typename_Yp > shared_ptr (shared_ptr< _Yp > &&__r, element_type *__p) noexcept
Constructs a shared_ptr instance that stores __p and shares ownership with __r.
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
Return the stored pointer.
operatorbool () const noexcept
Return true if the stored pointer is not null.
element_type & operator* () const noexcept
element_type * operator-> () const noexcept
template<typename_Yp > _Assignable< auto_ptr< _Yp > > operator= (auto_ptr< _Yp > &&__r)
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)
voidreset () 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)
voidswap (__shared_ptr< _Tp, _Lp > &__other) noexcept
Exchange both the owned pointer and the stored pointer.
bool unique () const noexcept
Return true if use_count() == 1.
long use_count () const noexcept
If *this owns a pointer, return the number of owners, otherwise zero.
template<typename_Tp1 > bool owner_before (__shared_ptr< _Tp1, _Lp > const &__rhs) const noexcept
Define an ordering based on ownership.
template<typename_Tp1 > bool owner_before (__weak_ptr< _Tp1, _Lp > const &__rhs) const noexcept
Define an ordering based on ownership.
Friends
template<typename_Yp , typename _Alloc > shared_ptr< _BoundedArray< _Yp > > allocate_shared (const
_Alloc &)
template<typename_Yp , typename _Alloc , typename... _Args> shared_ptr< _NonArray< _Yp > >
allocate_shared (const _Alloc &, _Args &&...)
template<typename_Yp , typename _Alloc > shared_ptr< _BoundedArray< _Yp > > allocate_shared (const
_Alloc &, const remove_extent_t< _Yp > &)
template<typename_Yp , typename _Alloc > shared_ptr< _UnboundedArray< _Yp > > allocate_shared (const
_Alloc &, size_t)
template<typename_Yp , typename _Alloc > shared_ptr< _UnboundedArray< _Yp > > allocate_shared (const
_Alloc &, size_t, const remove_extent_t< _Yp > &)
template<typename_Yp , typename _Alloc > shared_ptr< _NotUnboundedArray< _Yp > >
allocate_shared_for_overwrite (const _Alloc &)
template<typename_Yp , typename _Alloc > shared_ptr< _UnboundedArray< _Yp > >
allocate_shared_for_overwrite (const _Alloc &, size_t)
template<typename_Yp > shared_ptr< _BoundedArray< _Yp > > make_shared ()
template<typename_Yp , typename... _Args> shared_ptr< _NonArray< _Yp > > make_shared (_Args &&...)
template<typename_Yp > shared_ptr< _BoundedArray< _Yp > > make_shared (const remove_extent_t< _Yp > &)
template<typename_Yp > shared_ptr< _UnboundedArray< _Yp > > make_shared (size_t)
template<typename_Yp > shared_ptr< _UnboundedArray< _Yp > > make_shared (size_t, const remove_extent_t<
_Yp > &)
template<typename_Yp > shared_ptr< _NotUnboundedArray< _Yp > > make_shared_for_overwrite ()
template<typename_Yp > shared_ptr< _UnboundedArray< _Yp > > make_shared_for_overwrite (size_t)
classweak_ptr<_Tp>RelatedSymbols
(Note that these are not member symbols.)
template<typename_Del , typename _Tp > _Del * get_deleter (const shared_ptr< _Tp > &__p) noexcept
20.7.2.2.10 shared_ptr get_deleter
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)
Write the stored pointer to an ostream.
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
shared_ptr comparison with nullptr
template<typename _Tp > bool operator== (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
shared_ptr comparison with nullptr
template<typename _Tp , typename _Up > bool operator!= (const shared_ptr< _Tp > &__a, const
shared_ptr< _Up > &__b) noexcept
Inequality operator for shared_ptr objects, compares the stored pointers.
template<typename _Tp > bool operator!= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
shared_ptr comparison with nullptr
template<typename _Tp > bool operator!= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
shared_ptr comparison with nullptr
template<typename _Tp , typename _Up > bool operator< (const shared_ptr< _Tp > &__a, const
shared_ptr< _Up > &__b) noexcept
Relational operator for shared_ptr objects, compares the stored pointers.
template<typename _Tp > bool operator< (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
shared_ptr comparison with nullptr
template<typename _Tp > bool operator< (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
shared_ptr comparison with nullptr
template<typename _Tp , typename _Up > bool operator<= (const shared_ptr< _Tp > &__a, const
shared_ptr< _Up > &__b) noexcept
Relational operator for shared_ptr objects, compares the stored pointers.
template<typename _Tp > bool operator<= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
shared_ptr comparison with nullptr
template<typename _Tp > bool operator<= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
shared_ptr comparison with nullptr
template<typename _Tp , typename _Up > bool operator> (const shared_ptr< _Tp > &__a, const
shared_ptr< _Up > &__b) noexcept
Relational operator for shared_ptr objects, compares the stored pointers.
template<typename _Tp > bool operator> (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
shared_ptr comparison with nullptr
template<typename _Tp > bool operator> (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
shared_ptr comparison with nullptr
template<typename _Tp , typename _Up > bool operator>= (const shared_ptr< _Tp > &__a, const
shared_ptr< _Up > &__b) noexcept
Relational operator for shared_ptr objects, compares the stored pointers.
template<typename _Tp > bool operator>= (const shared_ptr< _Tp > &__a, nullptr_t) noexcept
shared_ptr comparison with nullptr
template<typename _Tp > bool operator>= (nullptr_t, const shared_ptr< _Tp > &__a) noexcept
shared_ptr comparison with nullptr
template<typename _Tp > voidswap (shared_ptr< _Tp > &__a, shared_ptr< _Tp > &__b) noexcept
Swap overload for shared_ptr.
template<typename _Tp , typename _Up > shared_ptr< _Tp > static_pointer_cast (const shared_ptr< _Up >
&__r) noexcept
Convert type of shared_ptr, via static_cast
template<typename _Tp , typename _Up > shared_ptr< _Tp > const_pointer_cast (const shared_ptr< _Up >
&__r) noexcept
Convert type of shared_ptr, via const_cast
template<typename _Tp , typename _Up > shared_ptr< _Tp > dynamic_pointer_cast (const shared_ptr< _Up
> &__r) noexcept
Convert type of shared_ptr, via dynamic_cast
template<typename _Tp , typename _Up > shared_ptr< _Tp > reinterpret_pointer_cast (const shared_ptr<
_Up > &__r) noexcept
Convert type of shared_ptr, via reinterpret_cast
template<typename _Tp , typename _Up > shared_ptr< _Tp > static_pointer_cast (shared_ptr< _Up >
&&__r) noexcept
Convert type of shared_ptr rvalue, via static_cast
template<typename _Tp , typename _Up > shared_ptr< _Tp > const_pointer_cast (shared_ptr< _Up > &&__r)
noexcept
Convert type of shared_ptr rvalue, via const_cast
template<typename _Tp , typename _Up > shared_ptr< _Tp > dynamic_pointer_cast (shared_ptr< _Up >
&&__r) noexcept
Convert type of shared_ptr rvalue, via dynamic_cast
template<typename _Tp , typename _Up > shared_ptr< _Tp > reinterpret_pointer_cast (shared_ptr< _Up >
&&__r) noexcept
Convert type of shared_ptr rvalue, via reinterpret_cast
template<typename _Tp , typename _Alloc , typename... _Args> shared_ptr< _NonArray< _Tp > >
allocate_shared (const _Alloc &__a, _Args &&... __args)
Create an object that is owned by a shared_ptr.
template<typename _Tp , typename... _Args> shared_ptr< _NonArray< _Tp > > make_shared (_Args &&...
__args)
Create an object that is owned by a shared_ptr.
template<typename _Tp , typename _Alloc > shared_ptr< _UnboundedArray< _Tp > > allocate_shared (const
_Alloc &__a, size_t __n)
Create an object that is owned by a shared_ptr.
template<typename _Tp , typename _Alloc > shared_ptr< _BoundedArray< _Tp > > allocate_shared (const
_Alloc &__a)
Create an object that is owned by a shared_ptr.
PNG Icons
