std::default_delete - cppreference.com (original) (raw)

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

• 1 Member functions
• 2 std::default_delete::default_delete
  • 2.1 Parameters
  • 2.2 Notes
• 3 std::default_delete::operator()
  • 3.1 Parameters
  • 3.2 Exceptions
  • 3.3 Invoking over Incomplete Types
  • 3.4 Notes
  • 3.5 Example
  • 3.6 Defect reports
  • 3.7 See also

[edit] Member functions

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

std::default_delete::default_delete

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

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

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

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

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

[edit] Example

#include #include #include   int main() { // { // std::shared_ptr shared_bad(new int[10]); // } // the destructor calls delete, undefined behavior   { std::shared_ptr shared_good(new int[10], std::default_delete<int[]>()); } // OK: the destructor calls delete[]   { std::unique_ptr ptr(new int(5)); } // unique_ptr uses default_delete   { 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()); }

[edit] Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

[edit] See also

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