Defined in header
template< class T > class shared_ptr;
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.
shared_ptr may also own no objects, in which case it is called empty.
In a typical implementation, std::shared_ptr holds only two pointers:
- a pointer to the managed object
- 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
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 Template:rlpf, 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.