# std::default_delete

> C++ Atlas: `cppatlas.com/w/cpp/memory/default_delete` | Source: https://en.cppreference.com/w/cpp/memory/default_delete | Domain: Memory management | Standards: C++11, C++23

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.

## Official Specification Summary (cppreference)

```cpp
// 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.

#### 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

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

```cpp
// 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.

#### 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.

#### Notes

| Feature-test macro | Value | Std | Feature |
| --- | --- | --- | --- |
| `__cpp_lib_constexpr_memory` | `202202L` | (C++23) | `constexpr` constructor and `operator()` |

#### Example

```cpp
#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>());
}
```

#### 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 |

#### See also

- [`unique_ptr`](https://en.cppreference.com/w/cpp/memory/unique_ptr) (C++11): smart pointer with unique object ownership semantics (class template)

---
Attribution: content from https://en.cppreference.com/w/cpp/memory/default_delete (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.