CKTIS / C++
std::is_nothrow_destructible — vérifier une destruction sans exception
Un trait de <type_traits> qui vérifie à la compilation si la destruction est valide et ne peut pas propager d’exception. std::is_nothrow_destructible<T>::value et std::is_nothrow_destructible_v<T> donnent le même résultat de type bool.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <type_traits>
std::is_nothrow_destructible<T>::value
std::is_nothrow_destructible_v<T>std::is_nothrow_destructible<T> de <type_traits> est un modèle de classe qui expose une constante membre ::value de type bool. std::is_nothrow_destructible_v<T> est un modèle de variable qui fournit une écriture abrégée du même résultat. Utilisez-les dans static_assert ou if constexpr pour vérifier les exigences du code générique sans exécuter de destructeur.
Les types scalaires comme int donnent true bien qu’ils n’aient ni destructeur déclaré ni spécification d’exception de destructeur. Pour un type classe, le destructeur doit être accessible, ne doit pas être supprimé et sa spécification d’exception ne doit pas permettre la propagation d’une exception. Pour les tableaux de taille connue, le trait vérifie le type des éléments après suppression de toutes les dimensions du tableau. Les références donnent true : la fin de la durée de vie d’une référence ne détruit pas l’objet référencé. void, les types fonction et les tableaux de taille inconnue donnent false.
Pour un destructeur, ce trait vérifie la spécification d’exception, pas la validité de son corps. Un destructeur vide avec noexcept(false) donne tout de même false. Si une exception s’échappe d’un destructeur noexcept, std::terminate est appelé ; true ne garantit donc pas que le programme se termine normalement.
T doit être un type complet, void avec ou sans qualificatifs cv, ou un tableau de taille inconnue. N’interrogez pas ce trait pour une classe qui n’a pas encore été définie et dont seule la déclaration est visible.
Exemples
#include <iostream>
#include <type_traits>
struct Safe {
~Safe() noexcept {}
};
struct Risky {
~Risky() noexcept(false) {}
};
static_assert(std::is_nothrow_destructible<Safe>::value);
static_assert(!std::is_nothrow_destructible_v<Risky>);
static_assert(std::is_nothrow_destructible_v<Risky&>);
static_assert(!std::is_nothrow_destructible_v<void>);
int main() {
std::cout << std::boolalpha
<< std::is_nothrow_destructible<Safe>::value << '\n'
<< std::is_nothrow_destructible_v<Risky> << '\n';
}
Résultat
true false
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.