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. Specializations of default_delete are empty classes on typical implementations, and used in the empty base class optimization.
default_delete uses delete to deallocate memory for a single object.Contents |
[edit]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 > default_delete(const default_delete<U>& d )noexcept; | (2) | (since C++11) (constexpr since C++23) |
Array specializations | ||
template<class U > default_delete(const default_delete<U[]>& d )noexcept; | (3) | (since C++11) (constexpr since C++23) |
std::default_delete object.std::default_delete<T> object from another std::default_delete object.U* is implicitly convertible to T*.std::default_delete<T[]> object from another std::default_delete<U[]> object.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()
Primary template specializations | ||
void operator()( T* ptr )const; | (1) | (since C++11) (constexpr since C++23) |
Array specializations | ||
template<class U > void operator()( U* ptr )const; | (2) | (since C++11) (constexpr since C++23) |
U(*)[] is implicitly convertible to T(*)[].U is an incomplete type, the program is ill-formed.Parameters
| ptr | - | an object or array to delete |
Exceptions
No exception guarantees.
[edit]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.
[edit]Notes
| Feature-test macro | Value | Std | Feature |
|---|---|---|---|
__cpp_lib_constexpr_memory | 202202L | (C++23) | constexpr constructor and operator() |
[edit]Example
#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::default_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 neededstd::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]Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
| DR | Applied to | Behavior as published | Correct behavior |
|---|---|---|---|
| LWG 2118 | C++11 | member functions of the array specializations rejected qualification conversions | accept |
[edit]See also
(C++11) | smart pointer with unique object ownership semantics (class template) |
