home | help 
std::experi...::shared_ptr(3)  C++ Standard Libary std::experi...::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 object
		      (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  name-
     space, and work
	with std::experimental::shared_ptr rather than std::shared_ptr, but oth-
     erwise
	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<<(std::shared_ptr)   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)			special-
     izes 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)
	(removed in C++26)

       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 refer-
     ring to itself
	(C++11) 		(class template)

Example
	 This section is incomplete
	 Reason: no example

Categories:
	  * Noindexed pages
	  * Todo no example

http://cppreference.com 	   2024.06.10	   std::experi...::shared_ptr(3)
home | help