CKTIS / C++
std::is_nothrow_destructible — controleren op niet-werpende vernietiging
Een trait uit <type_traits> die tijdens het compileren controleert of vernietiging geldig is en er daarbij geen exception naar buiten kan komen. std::is_nothrow_destructible<T>::value en std::is_nothrow_destructible_v<T> geven hetzelfde resultaat van het type bool.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
#include <type_traits>
std::is_nothrow_destructible<T>::value
std::is_nothrow_destructible_v<T>std::is_nothrow_destructible<T> uit <type_traits> is een klassentemplate met een constante bool-member ::value. std::is_nothrow_destructible_v<T> is een variabeletemplate als verkorte vorm van hetzelfde resultaat. Gebruik ze in static_assert of if constexpr om vereisten van generieke code te controleren zonder een destructor uit te voeren.
Scalaire typen zoals int geven true, hoewel ze geen gedeclareerde destructor en dus ook geen exceptionspecificatie voor een destructor hebben. Bij een klassetype moet de destructor toegankelijk en niet verwijderd zijn, en mag zijn exceptionspecificatie geen exceptions laten ontsnappen. Bij arrays met bekende grootte wordt het elementtype gecontroleerd nadat alle arraydimensies zijn verwijderd. Referenties geven true: het einde van de levensduur van een referentie vernietigt het object waarnaar die verwijst niet. void, functietypen en arrays met onbekende grootte geven false.
Bij een destructor gaat deze controle over de exceptionspecificatie, niet over de juistheid van de destructorbody. Een lege destructor met noexcept(false) geeft nog steeds false. Als een exception ontsnapt uit een noexcept-destructor, wordt std::terminate aangeroepen; true garandeert dus niet dat het programma succesvol eindigt.
T moet een compleet type zijn, void met of zonder cv-kwalificatie, of een array met onbekende grootte. Gebruik deze trait niet voor een klasse die wel gedeclareerd maar nog niet gedefinieerd is.
Voorbeelden
#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';
}
Resultaat
true false
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.