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

FreeBSD Manual Pages

  
 
  

home | help 
std::default_delete(3)	      C++ Standard Libary	std::default_delete(3)

NAME
       std::default_delete - std::default_delete

Synopsis
	  Defined in header <memory>
	  template< class T > struct default_delete;	  (1) (since C++11)
	  template< class T > struct default_delete<T[]>; (2) (since C++11)

	  std::default_delete  is  the	default	 destruction  policy  used  by
       std::unique_ptr when
	  no deleter is	specified. Specializations of default_delete are empty
       classes on
	  typical implementations, and used in the empty base class  optimiza-
       tion.

	  1) The non-specialized default_delete	uses delete to deallocate mem-
       ory for a single
	  object.
	  2)  A	 partial  specialization for array types that uses delete[] is
       also provided.

Member functions
	  constructor	constructs a default_delete object
			(public	member function)
	  operator()	deletes	the object or array
			(public	member function)

       std::default_delete::default_delete

	  constexpr default_delete() noexcept =	   (1)
	  default;
							   (since C++11)
	  template <class U>				   (until C++23)
	  default_delete( const	default_delete<U>&	   (member only	of
	  d ) noexcept;					   primary
							   default_delete
							   template)
							   (since C++23)
	  template <class U>				   (member only	of
	  constexpr default_delete( const		   primary
	  default_delete<U>& d ) noexcept;	   (2)	   default_delete
							   template)
									   (since
       C++11)
	  template<class						    U>
       (until C++23)
	  default_delete(						 const
       (member only of
	  default_delete<U[]>& d ) noexcept;				   de-
       fault_delete<T[]>
						       (3)
       specialization)
	  template<class						    U>
       (since C++23)
	  constexpr		       default_delete(			 const
       (member only of
	  default_delete<U[]>& d ) noexcept;				   de-
       fault_delete<T[]>
									   spe-
       cialization)

	  1) Constructs	a std::default_delete object.
	  2) Constructs	a std::default_delete<T> object	from another  std::de-
       fault_delete
	  object.  This	 constructor will only participate in overload resolu-
       tion if U* is
	  implicitly convertible to T*.
	  3) Constructs	a std::default_delete<T[]> object from another
	  std::default_delete<U[]> object. This	constructor will only partici-
       pate in overload
	  resolution if	U(*)[] is implicitly convertible to T(*)[].

Parameters
	  d - a	deleter	to copy	from

Notes
	  The converting constructor  template	of  std::default_delete	 makes
       possible	the
	  implicit     conversion     from     std::unique_ptr<Derived>	    to
       std::unique_ptr<Base>.

       std::default_delete::operator()

				      (since C++11)
	  void operator()(T*	      (until C++23)
	  ptr) const;		      (member only of primary
				      default_delete
				      template)
	  constexpr void	      (since C++23)
	  operator()(T*	ptr)	      (member only of primary
	  const;		      default_delete
			      (1)     template)
							      (since C++11)
	  template <class U>				      (until C++23)
	  void operator()(U*				      (member only of
	  ptr)	     const;						   de-
       fault_delete<T[]>
				  (2)			      specialization)
	  template <class U>				      (since C++23)
	  constexpr void				      (member only of
	  operator()(U*	       ptr)					   de-
       fault_delete<T[]>
	  const;					      specialization)

	  1) Calls delete on ptr
	  2) Calls delete[] on ptr. This function  will	 only  participate  in
       overload	resolution
	  if U(*)[] is implicitly convertible to T(*)[].

	  In any case, if U is an incomplete type, the program is ill-formed.

Parameters
	  ptr -	an object or array to delete

Exceptions
	  No exception guarantees.

	 Invoking over Incomplete Types

	  At  the point	in the code the	operator() is called, the type must be
       complete. In
	  some implementations a static_assert is used to make	sure  this  is
       the case. The
	  reason  for this requirement is that calling delete on an incomplete
       type is
	  undefined behavior in	C++ if the complete class type has a  nontriv-
       ial destructor or
	  a  deallocation  function,  as  the  compiler	 has no	way of knowing
       whether such
	  functions exist and must be invoked.

Notes
	  Feature-test macro: __cpp_lib_constexpr_memory ((C++23) constexpr)

Example
       // Run this code

	#include <memory>
	#include <vector>
	#include <algorithm>

	int main()
	{
	//  {
	//	std::shared_ptr<int> shared_bad(new int[10]);
	//  } // the destructor	calls delete, undefined	behavior

	    {
		std::shared_ptr<int>   shared_good(new	  int[10],    std::de-
       fault_delete<int[]>());
	    } // the destructor	calls delete[],	ok

	    {
		std::unique_ptr<int> ptr(new int(5));
	    } // unique_ptr<int> uses default_delete<int>

	    {
		std::unique_ptr<int[]> ptr(new int[10]);
	    } // unique_ptr<int[]> uses	default_delete<int[]>

	    // default_delete can be used anywhere a delete functor is needed
	    std::vector<int*> v;
	    for(int n =	0; n < 100; ++n)
		v.push_back(new	int(n));
	    std::for_each(v.begin(), v.end(), std::default_delete<int>());
	}

	 Defect	reports

	  The following	behavior-changing defect reports were applied retroac-
       tively to
	  previously published C++ standards.

	     DR	      Applied	 to		    Behavior	as   published
       Correct behavior
	  LWG  2118  C++11	 member	  functions   of   default_delete<T[]>
       accept
			      rejected qualification conversions

See also
	  unique_ptr smart pointer with	unique object ownership	semantics
	  (C++11)    (class template)

http://cppreference.com		  2022.07.31		std::default_delete(3)

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

home | help