std::default_delete

 

C++

Language

Standard library headers

Concepts

Utilities library

Strings library

Containers library

Algorithms library

Iterators library

Numerics library

Input/output library

Localizations library

Regular expressions library (C++11)

Atomic operations library (C++11)

Thread support library (C++11)

Technical Specifications

 

Utilities library

Type support (basic types, RTTI, type traits)

Dynamic memory management

Error handling

Program utilities

Variadic functions

Date and time

Function objects

initializer_list (C++11)

bitset

hash (C++11)

Relational operators

rel_ops::operator!=rel_ops::operator>rel_ops::operator<=rel_ops::operator>=

Pairs and tuples

pair

tuple (C++11)

piecewise_construct_t (C++11)

piecewise_construct (C++11)

integer_sequence (C++14)

Swap, forward and move

swap

exchange (C++14)

forward (C++11)

move (C++11)

move_if_noexcept (C++11)

Type operations

declval (C++11)

as_const (C++17)

 

Dynamic memory management

Smart pointers
unique_ptr (C++11)
shared_ptr (C++11)
weak_ptr (C++11)
auto_ptr (until C++17)
owner_less (C++11)
enable_shared_from_this (C++11)
bad_weak_ptr (C++11)
default_delete (C++11)
Allocators
allocator
allocator_traits (C++11)
allocator_arg_t (C++11)
allocator_arg (C++11)
uses_allocator (C++11)
scoped_allocator_adaptor (C++11)
Uninitialized storage
uninitialized_copy
uninitialized_copy_n (C++11)
uninitialized_fill
uninitialized_fill_n
raw_storage_iterator
get_temporary_buffer
return_temporary_buffer
Garbage collection support
declare_reachable (C++11)
undeclare_reachable (C++11)
declare_no_pointers (C++11)
undeclare_no_pointers (C++11)
pointer_safety (C++11)
get_pointer_safety (C++11)
Miscellaneous
pointer_traits (C++11)
addressof (C++11)
align (C++11)
C Library
malloc calloc	realloc free
Low level memory management

 

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.

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:  

noexcept

  

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

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

Run this code

#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

unique_ptr (C++11)

smart pointer with unique object ownership semantics (class template)