Namespaces
Variants
Views
Actions

std::default_delete

From cppreference.com
< cpp‎ | memory
 
 
Utilities library
Language support
Type support (basic types, RTTI)
Library feature-test macros (C++20)
Dynamic memory management
Program utilities
Coroutine support (C++20)
Variadic functions
Debugging support
(C++26)
Three-way comparison
(C++20)
(C++20)(C++20)(C++20)
(C++20)(C++20)(C++20)
General utilities
Date and time
Function objects
Formatting library (C++20)
(C++11)
Relational operators (deprecated in C++20)
Integer comparison functions
(C++20)(C++20)(C++20)   
(C++20)
Swap and type operations
(C++14)
(C++11)
(C++11)
(C++11)
(C++17)
Common vocabulary types
(C++11)
(C++17)
(C++17)
(C++17)
(C++11)
(C++17)
(C++23)
Elementary string conversions
(C++17)
(C++17)

 
Dynamic memory management
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Allocators
Garbage collection support
(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)



 
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.

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

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

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

#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

[edit] See also

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