std::experimental::shared_ptr(3)

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