std::shared_ptr
| 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 and its memory deallocated when either of the following happens:
- the last remaining
shared_ptrowning the object is destroyed.
- the last remaining
shared_ptrowning the object is assigned another pointer via operator= or reset().
The object is destroyed using delete-expression or a custom deleter that is supplied to shared_ptr during construction.
A shared_ptr can share ownership of an object while storing a pointer to another object. This feature can be used to point to member objects while owning the object they belong to. The stored pointer is the one accessed by get(), the dereference and the comparison operators. The managed pointer is the one passed to the deleter when use count reaches zero.
A shared_ptr may also own no objects, in which case it is called empty (an empty shared_ptr may have a non-null stored pointer if the aliasing constructor was used to create it)
shared_ptr meets the requirements of CopyConstructible and CopyAssignable.
All member functions (including copy constructor and copy assignment) can be called by multiple threads on different instances of shared_ptr without additional synchronization even if these instances are copies and share ownership of the same object. If multiple threads of execution access the same shared_ptr without synchronization and any of those accesses uses a non-const member function of shared_ptr then a data race will occur; the shared_ptr overloads of atomic functions can be used to prevent the data race.
Contents |
[edit] Member types
| Member type | Definition |
| element_type | T |
[edit] Member functions
constructs new shared_ptr (public member function) |
|
destructs the owned object if no more shared_ptrs link to it (public member function) |
|
assigns the shared_ptr (public member function) |
|
Modifiers |
|
| replaces the managed object (public member function) |
|
| swaps the managed objects (public member function) |
|
Observers |
|
| returns a pointer to the managed object (public member function) |
|
| dereferences pointer to the managed object (public member function) |
|
returns the number of shared_ptr objects referring to the same managed object (public member function) |
|
checks whether the managed object is managed only by the current shared_ptr instance (public member function) |
|
| checks if there is associated managed object (public member function) |
|
| provides owner-based ordering of shared pointers (public member function) |
|
[edit] Non-member functions
| creates a shared pointer that manages a new object (function template) |
|
| creates a shared pointer that manages a new object allocated using an allocator (function template) |
|
| applies static_cast, dynamic_cast or const_cast to the type of the managed object (function template) |
|
| returns the deleter of specified type, if owned (function template) |
|
compares with another shared_ptr or with nullptr (function template) |
|
| outputs the value of the managed pointer to an output stream (function template) |
|
| (C++11)
|
specializes the std::swap algorithm (function template) |
| specializes atomic operations (function template) |
[edit] Helper classes
| (C++11)
|
hash support for std::shared_ptr (class template specialization) |
[edit] Notes
The ownership of an object can only be shared with another shared_ptr by copy constructing or copy assigning its value to another shared_ptr. Constructing a new shared_ptr using the raw underlying pointer owned by another shared_ptr leads to undefined behavior.
std::shared_ptr may be used with an incomplete type T, but T must be complete at the point in code where the constructor from a raw pointer or the reset(T*) member function is called (note that std::unique_ptr may be constructed from a raw pointer to an incomplete type).
[edit] Implementation notes
In a typical implementation, std::shared_ptr holds only two pointers:
- the stored pointer (one retured by get())
- a pointer to control block
The control block is a dynamically-allocated object that holds:
- either a pointer to the managed object or the managed object itself
- the deleter (type-erased)
- the allocator (type-erased)
- the number of
shared_ptrs that own the managed object - 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 memory for both the control block and the managed object is created with a single allocation. The managed object is constructed in-place in a data member of the control block. When shared_ptr is created via one of the shared_ptr constructors, the managed object and the control block must be allocated separately. In this case, the control block stores a pointer to the managed object.
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. If that counter reaches zero, the control block calls the destructor of the managed object. The control block does not deallocate itself until the std::weak_ptr counter reaches zero as well.
To satisfy thread safety requirements, the reference counters are typically incremented and decremented using an equivalent of std::atomic::fetch_add with std::memory_order_relaxed.