◐ Shell
clean mode source ↗

std::default_delete - cppreference.com

De cppreference.com

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.

1) Las plantillas de clase default_delete no especializadas utilizan delete para desasignar memoria para un solo objeto.

2) También se proporciona una especialización parcial para tipos array que utilizan delete[].

Funciones miembro

std::default_delete::default_delete

</tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </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[]>)

1) Construye un objeto std::default_delete.

2) Construye un objeto 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*.

3) Construye un objeto 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 class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </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[]>)

1) Llama a delete en ptr

2) Llama a delete[] 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

Puntero inteligente con semántica de posesión de objeto única.
(plantilla de clase) [editar]