| 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
| (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() = default; | (1) | |
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(*)[].Parameters
| d | - | a deleter to copy from |
Exceptions
noexcept specification: noexceptNotes
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()
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.
Parameters
| ptr | - | an object or array to delete |
Exceptions
No exception guarantees.
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>());
}See also
| (C++11) | smart pointer with unique object ownership semantics (class template) |
Please login to continue.