std::default_delete
From cppreference.com
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.
Contents |
[edit] 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.
[edit] 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>()); }
[edit] See also
(C++11)
|
smart pointer with unique object ownership semantics (class template) |