std::default_delete
From cppreference.com
C++
Feature test macros (C++20)
Concepts library (C++20)
Metaprogramming library (C++11)
Ranges library (C++20)
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Memory management library
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
Garbage collector support (until C++23)
(exposition only*)
(C++11)
(C++23)
(C++11)
(C++17)
(C++11)
(C++11)
(C++20)
(C++20)
(C++17)
(C++11)
(C++17)
(C++20)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(C++17)
(until C++20*)
(until C++20*)
(until C++20*)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)(until C++23)
(C++11)
(C++11)
(C++17)
(C++20)
(C++17)
(C++11)
(C++11)
(C++11)
(until C++17*)
(C++11)
(C++17)
(C++26)
(C++26)
(C++11)
(C++11)
default_delete
(C++11)
(C++23)
(C++23)
(C++11)
(C++20)
(C++11)
(C++11)
(C++20)
(C++26)
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.
Contents
[edit] Member functions
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) default_delete( const default_delete<U>& d ) noexcept;
(constexpr since C++23)
Array specializations
template< class U >
default_delete( const default_delete<U[]>& d ) noexcept;
(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::default_delete object. This overload participates in overload resolution only if
U* is implicitly 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 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) 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 implicitly 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.
[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
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::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 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] 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 |