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 optimization.

	1)  The  non-specialized default_delete uses delete to deallocate memory
     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 = default;		 (1)
	Primary template specializations
	template<  class  U  >					     (2)  (since
     C++11)
	default_delete( const default_delete<U>& d ) noexcept;	      (constexpr
     since C++23)
	Array specializations
	template<  class  U  >					     (3)  (since
     C++11)
	default_delete( const default_delete<U[]>& d ) noexcept;      (constexpr
     since C++23)

	1) Constructs a std::default_delete object.
	2)  Constructs	a  std::default_delete<T>  object  from another std::de-
     fault_delete
	object.
	This overload participates in overload resolution only if U* is  implic-
     itly
	convertible to T*.
	3) Constructs a std::default_delete<T[]> object from another
	std::default_delete<U[]> object.
	This  overload participates in overload resolution only if U(*)[] is im-
     plicitly
	convertible to T(*)[].

Parameters
	d - a deleter to copy from

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

     std::default_delete::operator()

	Primary template specializations
	void operator()( T* ptr ) const; (1) (since C++11)
					     (constexpr since C++23)
	Array specializations
	template< class U >		 (2) (since C++11)
	void operator()( U* ptr ) const;     (constexpr since C++23)

	1) Calls delete on ptr.
	2) Calls delete[] on ptr.
	This overload participates in overload resolution only if U(*)[] is  im-
     plicitly
	convertible to T(*)[].
	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 com-
     plete. 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  nontrivial
     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	    Value    Std		 Feature
	__cpp_lib_constexpr_memory 202202L (C++23) constexpr constructor and op-
     erator()

Example
     // Run this code

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

      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[]>());
	  } // OK: the destructor calls delete[]

	  {
	      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		    Cor-
     rect behavior
	LWG 2118 C++11	    member functions of the array specializations    ac-
     cept
			    rejected qualification conversions

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

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