std::shared_ptr

 

C++

Language

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!= rel_ops::operator> rel_ops::operator<= rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

Swap, forward and move

swap

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

declval (C++11)

 

Dynamic memory management

Low level memory management
Allocators
allocator
allocator_traits (C++11)
allocator_arg_t (C++11)
allocator_arg (C++11)
uses_allocator (C++11)
scoped_allocator_adaptor (C++11)
Uninitialized storage
uninitialized_copy
uninitialized_copy_n (C++11)
uninitialized_fill
uninitialized_fill_n
raw_storage_iterator
get_temporary_buffer
return_temporary_buffer
Smart pointers
unique_ptr (C++11)
shared_ptr (C++11)
weak_ptr (C++11)
auto_ptr (deprecated)
owner_less (C++11)
enable_shared_from_this (C++11)
bad_weak_ptr (C++11)
default_delete (C++11)
Garbage collection support
declare_reachable (C++11)
undeclare_reachable (C++11)
declare_no_pointers (C++11)
undeclare_no_pointers (C++11)
pointer_safety (C++11)
get_pointer_safety (C++11)
Miscellaneous
pointer_traits (C++11)
addressof (C++11)
align (C++11)
C Library
malloc calloc	realloc free

 

std::shared_ptr

Member functions

shared_ptr::shared_ptr

shared_ptr::~shared_ptr

shared_ptr::operator=

Modifiers

shared_ptr::reset

shared_ptr::swap

Observers

shared_ptr::get

shared_ptr::operator* shared_ptr::operator->

shared_ptr::use_count

shared_ptr::unique

shared_ptr::operator bool

shared_ptr::owner_before

Non-member functions

std::swap

make_shared

allocate_shared

static_pointer_cast dynamic_pointer_cast const_pointer_cast

get_deleter

operator== operator|= operator< operator<= operator> operator>=

operator<<

atomic_is_lock_free atomic_load atomic_load_explicit atomic_store atomic_store_explicit atomic_exchange atomic_exchange_explicit

std::hash

 

Defined in header <memory>
template< class T > class shared_ptr;		(since C++11)

std::shared_ptr is a smart pointer that retains shared ownership of an object through a pointer. Several shared_ptr objects may own the same object; the object is destroyed when the last remaining shared_ptr pointing to it is destroyed or reset. The object is destroyed using delete-expression or a custom deleter that is supplied to shared_ptr during construction.

A shared_ptr may also own no objects, in which case it is called empty.

shared_ptr meets the requirements of CopyConstructible and CopyAssignable.

Member types

Member type	Definition
element_type	T

Member functions

(constructor)	constructs new shared_ptr (public member function)
(destructor)	destructs the owned object if no more shared_ptrs link to it (public member function)
operator=	assigns the shared_ptr (public member function)
Modifiers
reset	replaces the managed object (public member function)
swap	swaps the managed objects (public member function)
Observers
get	returns a pointer to the managed object (public member function)
operator* operator->	dereferences pointer to the managed object (public member function)
use_count	returns the number of shared_ptr objects referring to the same managed object (public member function)
unique	checks whether the managed object is managed only by the current shared_ptr instance (public member function)
operator bool	checks if there is associated managed object (public member function)
owner_before	provides owner-based ordering of shared pointers (public member function)

Non-member functions

make_shared	creates a shared pointer that manages a new object (function template)
allocate_shared	creates a shared pointer that manages a new object allocated using an allocator (function template)
static_pointer_cast dynamic_pointer_cast const_pointer_cast	applies static_cast, dynamic_cast or const_cast to the type of the managed object (function template)
get_deleter	returns the deleter of specified type, if owned (function template)
operator== operator!= operator< operator<= operator> operator>=	compares with another shared_ptr or with nullptr (function template)
operator<<	outputs the value of the managed pointer to an output stream (function template)
std::swap(std::shared_ptr) (C++11)	specializes the std::swap algorithm (function template)

std::atomic_is_lock_free(std::shared_ptr) std::atomic_load(std::shared_ptr) std::atomic_load_explicit(std::shared_ptr) std::atomic_store(std::shared_ptr) std::atomic_store_explicit(std::shared_ptr) std::atomic_exchange(std::shared_ptr) std::atomic_exchange_explicit(std::shared_ptr) std::atomic_compare_exchange_weak(std::shared_ptr) std::atomic_compare_exchange_strong(std::shared_ptr) std::atomic_compare_exchange_weak_explicit(std::shared_ptr) std::atomic_compare_exchange_strong_explicit(std::shared_ptr)

specializes atomic operations (function template)

Helper classes

std::hash<std::shared_ptr> (C++11)	hash support for std::shared_ptr (class template specialization)

Implementation notes

In a typical implementation, std::shared_ptr holds a pointer to the referenced object and a pointer to control block, which is a dynamically-allocated object that holds a pointer to the managed object, the deleter, the allocator, the number of shared_ptrs that own the managed object, and the number of weak_ptrs that refer to the managed object. When shared_ptr is created by calling std::make_shared or std::allocate_shared, the control block holds the managed object directly, as a data member. The pointer held by the shared_ptr directly is the one returned by get(), while the pointer/object held by the control block is the one that will be deleted when the number of shared owners reaches zero: these pointers are not necessarily equal. The destructor of shared_ptr decrements the number of shared owners of the control block, and if that reaches zero, the control block calls the destructor of the managed object, but the control block does not deallocate itself until the std::weak_ptr counter reaches zero as well.