std::default_delete
| Definido en el archivo de encabezado <memory>
|
||
template< class T > struct default_delete; |
(1) | (desde C++11) |
template< class T > struct default_delete<T[]>; |
(2) | (desde C++11) |
std::default_delete es la política de destrucción por defecto utilizada por std::unique_ptr cuando no se especifica ningún eliminador. Las especializaciones de default_delete son clases vacías en implementaciones típicas y se usan en la optimización de clase base vacía.
default_delete no especializadas utilizan delete para desasignar memoria para un solo objeto.delete[].Funciones miembro
Construye un objeto default_delete. (función miembro pública) | |
| Elimina el objeto o array. (función miembro pública) |
std::default_delete::default_delete
<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> constexpr default_delete() noexcept = default; |
(1) | |
| (2) | ||
template <class U> default_delete( const default_delete<U>& d ) noexcept; |
(desde C++11) (hasta C++23) (Miembro solo de la plantilla primaria default_delete) |
|
template <class U> constexpr default_delete( const default_delete<U>& d ) noexcept; |
(desde C++23) (Miembro solo de la plantilla primaria default_delete) |
|
| (3) | ||
template<class U> default_delete( const default_delete<U[]>& d ) noexcept; |
(desde C++11) (hasta C++23) (Miembro solo de la especialización default_delete<T[]>) |
|
template<class U> constexpr default_delete( const default_delete<U[]>& d ) noexcept; |
(desde C++23) (Miembro solo de la especialización default_delete<T[]>) |
|
std::default_delete.std::default_delete<T> a partir de otro objeto std::default_delete. Este constructor solo participará en la resolución de sobrecarga si U* es implícitamente convertible a T*.std::default_delete<T[]> a partir de otro objeto std::default_delete<U[]> object. Este constructor solo participará en la resolución de sobrecarga si U(*)[] es implícitamente convertible a T(*)[].Parámetros
| d | - | Un eliminador del que copiar. |
Notas
La plantilla del constructor de conversión de std::default_delete hace posible la conversión implícita de std::unique_ptr<Derived> a std::unique_ptr<Base>.
std::default_delete::operator()
<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>| (1) | ||
void operator()(T* ptr) const; |
(desde C++11) (hasta C++23) (Miembro solo de la plantilla primaria default_delete) |
|
constexpr void operator()(T* ptr) const; |
(desde C++23) (Miembro solo de la plantilla primaria default_delete) |
|
| (2) | ||
template <class U> void operator()(U* ptr) const; |
(desde C++11) (hasta C++23) (Miembro solo de la especialización default_delete<T[]>) |
|
template <class U> constexpr void operator()(U* ptr) const; |
(desde C++23) (Miembro solo de la especialización default_delete<T[]>) |
|
delete en ptrdelete[] en ptr. Esta función solo participará en la resolución de sobrecarga si U(*)[] es implícitamente convertible a T(*)[]. En cualquier caso, si U es de tipo incompleto, el programa está mal formado.
Parámetros
| ptr | - | Un objeto o array a eliminar. |
Excepciones
Sin garantías de excepciones.
Invocar sobre tipos incompletos
En el punto del código en el que se llama a operator(), el tipo debe estar completo. En algunas implementaciones se usa static_assert para asegurarse de que este sea el caso. El motivo de este requisito es que llamar a delete en un tipo incompleto es un comportamiento no definido en C++ si el tipo clase completo tiene un destructor no trivial o una función de desasignación de memoria, ya que el compilador no tiene forma de saber si tales funciones existen y deben ser invocadas.
Notas
| Macro de Prueba de característica |
|---|
__cpp_lib_constexpr_memory
|
((C++23) constexpr)
Ejemplo
#include <memory>
#include <vector>
#include <algorithm>
int main()
{
// {
// std::shared_ptr<int> shared_bad(new int[10]);
// } // el destructor llama a delete, comportamiento no definido
{
std::shared_ptr<int> shared_good(new int[10], std::default_delete<int[]>());
} // el destructor llama a delete[], está bien.
{
std::unique_ptr<int> ptr(new int(5));
} // unique_ptr<int> utiliza a default_delete<int>
{
std::unique_ptr<int[]> ptr(new int[10]);
} // unique_ptr<int[]> utiliza a default_delete<int[]>
// default_delete puede usarse en cualquier lugar donde se necesite un objeto función delete
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>());
}
Informes de defectos
Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.
| ID | Aplicado a | Comportamiento según lo publicado | Comportamiento correcto |
|---|---|---|---|
| LWG 2118 | C++11 | Las funciones miembro de default_delete<T[]> rechazaban las conversiones de calificación.
|
Las aceptan. |
Véase también
(C++11) |
Puntero inteligente con semántica de posesión de objeto única. (plantilla de clase) |