< cpp‎ | memory
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.


[edit] Member functions

constructs a default_delete object
(public member function) [edit]
deletes the object or array
(public member function) [edit]


constexpr default_delete() = default;
template <class U>
default_delete( const default_delete<U>& d );
(2) (member only of generic default_delete template)
template<class U>
default_delete( const default_delete<U[]>& d);
(3) (since C++17)
(member only 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


noexcept specification:  


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>
void operator()(U* ptr) const;
(2) (member only of default_delete<T[]> template specialization, but defined as deleted prior to C++17)
1) Calls delete (primary template) or delete[] (array specialization) on ptr
2) Defined as deleted
(until C++17)
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(*)[].
(since C++17)

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


ptr - an object or array to delete


No exception guarantees.

[edit] Example

#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>());

[edit] See also

smart pointer with unique object ownership semantics
(class template) [edit]