CKTIS / C++
std::is_nothrow_destructible — verificare la distruzione senza eccezioni
Un trait di <type_traits> che verifica in fase di compilazione se la distruzione è valida e non può propagare eccezioni. std::is_nothrow_destructible<T>::value e std::is_nothrow_destructible_v<T> espongono lo stesso risultato di tipo bool.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
#include <type_traits>
std::is_nothrow_destructible<T>::value
std::is_nothrow_destructible_v<T>std::is_nothrow_destructible<T> di <type_traits> è un template di classe che espone una costante membro ::value di tipo bool. std::is_nothrow_destructible_v<T> è un template di variabile che offre una forma abbreviata dello stesso risultato. Usali in static_assert o if constexpr per verificare i requisiti del codice generico senza eseguire un distruttore.
I tipi scalari come int danno true anche se non hanno un distruttore dichiarato né una specifica delle eccezioni per il distruttore. Per un tipo classe, il distruttore deve essere accessibile e non deve essere eliminato, e la sua specifica delle eccezioni non deve consentire la propagazione di eccezioni. Per gli array di dimensione nota si verifica il tipo degli elementi dopo aver rimosso tutte le dimensioni dell’array. I riferimenti danno true: la fine della durata di vita di un riferimento non distrugge l’oggetto a cui si riferisce. void, i tipi funzione e gli array di dimensione sconosciuta danno false.
Per un distruttore, la verifica riguarda la specifica delle eccezioni, non la correttezza del corpo. Anche un distruttore vuoto con noexcept(false) dà false. Se un’eccezione fuoriesce da un distruttore noexcept, viene chiamato std::terminate; quindi true non garantisce che il programma termini correttamente.
T deve essere un tipo completo, void con o senza qualificatori cv, oppure un array di dimensione sconosciuta. Non interrogare questo trait per una classe che è stata dichiarata ma non ancora definita.
Esempi
#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';
}
Risultato
true false
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.