std::default_delete (3) - Linux Manuals

std::default_delete: std::default_delete


std::default_delete - std::default_delete


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

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


constexpr default_delete() noexcept = default; (1)
template <class U> (2) (member only of primary default_delete template)
default_delete( const default_delete<U>& d ) noexcept;
template<class U> (3) (since C++17)
default_delete( const default_delete<U[]>& d) noexcept; (member only of the array default_delete specialization)

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


d - a deleter to copy from


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


void operator()(T* ptr) const; (1) (as of C++17, no longer a member of the default_delete<T[]> template specialization)
template <class U> (2) (member only of default_delete<T[]> template specialization, but defined as deleted prior to C++17)
void operator()(U* ptr) const;

1) Calls delete (primary template) or delete[] (array specialization) on ptr (until C++17)
2) Defined as deleted
1) Calls delete on ptr (since C++17)
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.


ptr - an object or array to delete


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 nontrivial destructor or a deallocation function, as the compiler has no way of knowing whether such functions exist and must be invoked.


// 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::default_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>());

See also

unique_ptr smart pointer with unique object ownership semantics
           (class template)