Namespaces
Variants

std:: is_destructible, std:: is_trivially_destructible, std:: is_nothrow_destructible

From cppreference.net
C++
Metaprogramming library
Type traits
Type categories
(C++11)
(C++11) ( DR* )
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
(C++11) ( until C++20* )
(C++11) (deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Type trait constants
(C++11) (C++17) (C++11) (C++11)
Metafunctions
(C++17)
(C++17)
(C++17)
Supported operations
(C++11) (C++11) (C++11)
(C++11) (C++11) (C++11)
is_destructible is_trivially_destructible is_nothrow_destructible
(C++11) (C++11) (C++11)
(C++11)
(C++17) (C++17) (C++17) (C++17)

Relationships and property queries
Type modifications
Type transformations
(C++11) (deprecated in C++23)
(C++11) (deprecated in C++23)
(C++11)
(C++20)
(C++11) ( until C++20* ) (C++17)

Compile-time rational arithmetic
Compile-time integer sequences
(C++14)
Definido en el encabezado <type_traits>
template < class T >
struct is_destructible ;
(1) (desde C++11)
template < class T >
struct is_trivially_destructible ;
(2) (desde C++11)
template < class T >
struct is_nothrow_destructible ;
(3) (desde C++11)
1) Si T es un tipo de referencia, proporciona la constante miembro value igual a true .
Si T es (posiblemente calificado con cv) void , un tipo de función, o un array de límite desconocido, value es igual a false .
Si T es un tipo objeto, entonces, para el tipo U que es std:: remove_all_extents < T > :: type , si la expresión std:: declval < U & > ( ) .~U ( ) está bien formada en contexto no evaluado, value es igual a true . De lo contrario, value es igual a false .
2) Igual que (1) y adicionalmente std:: remove_all_extents < T > :: type es un tipo no-clase o un tipo clase con un destructor trivial .
3) Igual que (1) , pero el destructor es noexcept .

Si T no es un tipo completo, (posiblemente calificado cv) void , o un array de límite desconocido, el comportamiento es indefinido.

Si una instanciación de una plantilla anterior depende, directa o indirectamente, de un tipo incompleto, y esa instanciación podría producir un resultado diferente si ese tipo se completara hipotéticamente, el comportamiento no está definido.

Si el programa añade especializaciones para cualquiera de las plantillas descritas en esta página, el comportamiento es indefinido.

Contenidos

Plantillas de variables auxiliares

template < class T >
constexpr bool is_destructible_v = is_destructible < T > :: value ;
(desde C++17)
template < class T >
constexpr bool is_trivially_destructible_v = is_trivially_destructible < T > :: value ;
(desde C++17)
template < class T >
constexpr bool is_nothrow_destructible_v = is_nothrow_destructible < T > :: value ;
(desde C++17)

Heredado de std:: integral_constant

Constantes miembro

value
[static]
true si T es destructible, false en caso contrario
(constante miembro pública estática)

Funciones miembro

operator bool
convierte el objeto a bool , devuelve value
(función miembro pública)
operator()
(C++14)
devuelve value
(función miembro pública)

Tipos miembro

Tipo Definición
value_type bool
type std:: integral_constant < bool , value >

Notas

Debido a que el programa C++ termina si un destructor lanza una excepción durante el desenrollado de la pila (lo cual generalmente no se puede predecir), todos los destructores prácticos no lanzan excepciones incluso si no están declarados como noexcept. Todos los destructores encontrados en la biblioteca estándar de C++ no lanzan excepciones.

El almacenamiento ocupado por objetos trivialmente destructibles puede reutilizarse sin llamar al destructor.

Implementación posible

is_destructible (1) 
// C++20 required
template<typename t>
struct is_destructible
    : std::integral_constant<bool, requires(t object) { object.~t(); }>
{};
is_trivially_destructible (2) 
// Not real C++. Shall P2996 be approved, the following implementation will be available:
template<typename t>
struct is_trivially_destructible
     : std::integral_constant<bool, std::meta::type_is_trivially_destructible(^t)>
{};
is_nothrow_destructible (3) 
// C++20 required
template<typename t>
struct is_nothrow_destructible
    : std::integral_constant<bool, requires(t object) { {object.~t()} noexcept; }>
{};

Ejemplo

Ejecutar este código 
#include <iostream>
#include <string>
#include <type_traits>
struct Foo
{
    std::string str;
    ~Foo() noexcept {};
};
struct Bar
{
    ~Bar() = default;
};
static_assert(std::is_destructible<std::string>::value == true);
static_assert(std::is_trivially_destructible_v<Foo> == false);
static_assert(std::is_nothrow_destructible<Foo>() == true);
static_assert(std::is_trivially_destructible<Bar>{} == true);
int main() {}

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 2049 C++11 la especificación era incompletable debido a la estructura envolvente imaginaria completado

Véase también

(C++11) (C++11) (C++11)
verifica si un tipo tiene un constructor para argumentos específicos
(plantilla de clase)
(C++11)
verifica si un tipo tiene un destructor virtual
(plantilla de clase)
(C++20)
especifica que un objeto del tipo puede ser destruido
(concepto)
destructor libera recursos reclamados