NAME

std::experimental::shared_ptr - std::experimental::shared_ptr

Synopsis

Defined in header <experimental/memory>
template< class T > class shared_ptr; (library fundamentals TS)

std::experimental::shared_ptr is a modified version of std::shared_ptr that adds
support for arrays.

Member types

Member type Definition
element_type std::remove_extent_t<T>

Member functions

constructor constructs new shared_ptr
(public member function)

Observers

get returns the stored pointer
(public member function)
operator* dereferences the stored pointer
operator-> (public member function)
operator[] provides index access to the array
(public member function)

Non-member functions

static_pointer_cast applies static_cast, dynamic_cast, const_cast, or
dynamic_pointer_cast reinterpret_cast to the stored pointer
const_pointer_cast (function template)
reinterpret_pointer_cast

Helper classes

hash support for
std::hash<std::experimental::shared_ptr> std::experimental::shared_ptr
(class template specialization)

Members and non-members identical to std::shared_ptr

Member functions

The following member functions work with std::experimental::shared_ptr instead of
std::shared_ptr and std::experimental::weak_ptr instead of std::weak_ptr. The
behavior is otherwise identical.

destructor destructs the owned object if no more shared_ptrs link to it
(public member function of std::shared_ptr<T>)
operator= assigns the shared_ptr
(public member function of std::shared_ptr<T>)

Modifiers

reset replaces the managed object
(public member function of std::shared_ptr<T>)
swap swaps the managed objects
(public member function of std::shared_ptr<T>)

Observers

returns the number of shared_ptr objects referring to the same managed
use_count object
(public member function of std::shared_ptr<T>)
unique checks whether the managed object is managed only by the current
(until C++20) shared_ptr instance
(public member function of std::shared_ptr<T>)
operator bool checks if the stored pointer is not null
(public member function of std::shared_ptr<T>)
owner_before provides owner-based ordering of shared pointers
(public member function of std::shared_ptr<T>)

Non-member functions

These non-member functions are declared in the std::experimental namespace, and work
with std::experimental::shared_ptr rather than std::shared_ptr, but otherwise
behaves identically to the corresponding C++14 function.

make_shared creates a shared pointer that manages a new object
make_shared_for_overwrite (function template)
(C++20)
allocate_shared creates a shared pointer that manages a new object
allocate_shared_for_overwrite allocated using an allocator
(C++20) (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
operator<=> (function template)
(removed in C++20)
(removed in C++20)
(removed in C++20)
(removed in C++20)
(removed in C++20)
(C++20)
outputs the value of the stored pointer to an output
operator<< stream
(function template)
std::swap(std::shared_ptr) specializes the std::swap algorithm
(C++11) (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) specializes atomic
std::atomic_exchange(std::shared_ptr) operations for
std::atomic_exchange_explicit(std::shared_ptr) std::shared_ptr
std::atomic_compare_exchange_weak(std::shared_ptr) (function template)
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)
(deprecated in C++20)

Helper class templates

These class templates are declared in the std::experimental namespace, and work with
std::experimental::shared_ptr and std::experimental::weak_ptr rather than
std::shared_ptr and std::weak_ptr, but otherwise behaves identically to the
corresponding C++14 class template.

owner_less provides mixed-type owner-based ordering of shared and weak
(C++11) pointers
(class template)
enable_shared_from_this allows an object to create a shared_ptr referring to itself
(C++11) (class template)

Example

This section is incomplete
Reason: no example