Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help 
std::experi...::shared_ptr(3) C++ Standard Libarystd::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::experimen-
       tal::shared_ptr
						   (class template specializa-
       tion)

       Members and non-members identical to std::shared_ptr

Member functions
	  The	following   member   functions	 work	with   std::experimen-
       tal::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)			  spe-
       cializes	atomic
	  std::atomic_exchange(std::shared_ptr)				opera-
       tions for
	  std::atomic_exchange_explicit(std::shared_ptr)
       std::shared_ptr
	  std::atomic_compare_exchange_weak(std::shared_ptr)		(func-
       tion 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 name-
       space, 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 re-
       ferring to itself
	  (C++11)		  (class template)

Example
	   This	section	is incomplete
	   Reason: no example

http://cppreference.com		  2022.07.31	 std::experi...::shared_ptr(3)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=std::experimental::shared_ptr&sektion=3&manpath=FreeBSD+Ports+15.0>

home | help