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)
Défini dans l'en-tête <type_traits>
template < class T >
struct is_destructible ;
(1) (depuis C++11)
template < class T >
struct is_trivially_destructible ;
(2) (depuis C++11)
template < class T >
struct is_nothrow_destructible ;
(3) (depuis C++11)
1) Si T est un type référence, fournit la constante membre value égale à true .
Si T est (éventuellement qualifié cv) void , un type fonction, ou un tableau de taille inconnue, value est égal à false .
Si T est un type objet, alors, pour le type U qui est std:: remove_all_extents < T > :: type , si l'expression std:: declval < U & > ( ) .~U ( ) est bien formée dans un contexte non évalué, value vaut true . Sinon, value vaut false .
2) Identique à (1) et en plus std:: remove_all_extents < T > :: type est soit un type non-classe soit un type classe avec un destructeur trivial .
3) Identique à (1) , mais le destructeur est noexcept .

Si T n'est pas un type complet, (éventuellement qualifié cv) void , ou un tableau de limite inconnue, le comportement est indéfini.

Si une instanciation d'un template ci-dessus dépend, directement ou indirectement, d'un type incomplet, et que cette instanciation pourrait produire un résultat différent si ce type était hypothétiquement complété, le comportement est indéfini.

Si le programme ajoute des spécialisations pour l'un des modèles décrits sur cette page, le comportement est indéfini.

Table des matières

Modèles de variables auxiliaires

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

Hérité de std:: integral_constant

Constantes membres

value
[static]
true si T est destructible, false sinon
(constante membre publique statique)

Fonctions membres

operator bool
convertit l'objet en bool , retourne value
(fonction membre publique)
operator()
(C++14)
retourne value
(fonction membre publique)

Types membres

Type Définition
value_type bool
type std:: integral_constant < bool , value >

Notes

Parce que le programme C++ se termine si un destructeur lève une exception pendant le déroulement de la pile (ce qui ne peut généralement pas être prédit), tous les destructeurs pratiques sont non-lanceurs même s'ils ne sont pas déclarés noexcept. Tous les destructeurs trouvés dans la bibliothèque standard C++ sont non-lanceurs.

L'espace de stockage occupé par les objets trivialement destructibles peut être réutilisé sans appeler le destructeur.

Implémentation possible

is_destructible (1) 
// C++20 requis
template<typename t>
struct is_destructible
    : std::integral_constant<bool, requires(t object) { object.~t(); }>
{};
is_trivially_destructible (2) 
// Pas du vrai C++. Si P2996 est approuvé, l'implémentation suivante sera disponible :
template<typename t>
struct is_trivially_destructible
     : std::integral_constant<bool, std::meta::type_is_trivially_destructible(^t)>
{};
is_nothrow_destructible (3) 
// C++20 requis
template<typename t>
struct is_nothrow_destructible
    : std::integral_constant<bool, requires(t object) { {object.~t()} noexcept; }>
{};

Exemple

Exécuter ce code 
#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() {}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR S'applique à Comportement publié Comportement corrigé
LWG 2049 C++11 la spécification était irréalisable à cause de la structure d'encapsulation imaginaire rendue réalisable

Voir aussi

(C++11) (C++11) (C++11)
vérifie si un type a un constructeur pour des arguments spécifiques
(modèle de classe)
(C++11)
vérifie si un type a un destructeur virtuel
(modèle de classe)
(C++20)
spécifie qu'un objet du type peut être détruit
(concept)
destructor libère les ressources réclamées