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)
Definiert im Header <type_traits>
template < class T >
struct is_destructible ;
(1) (seit C++11)
template < class T >
struct is_trivially_destructible ;
(2) (seit C++11)
template < class T >
struct is_nothrow_destructible ;
(3) (seit C++11)
1) Wenn T ein Referenztyp ist, stellt die Member-Konstante value gleich true bereit.
Falls T (möglicherweise cv-qualifiziert) void , ein Funktionstyp oder ein Array unbekannter Größe ist, value entspricht false .
Falls T ein Objekttyp ist, dann gilt für den Typ U , der std:: remove_all_extents < T > :: type entspricht: Wenn der Ausdruck std:: declval < U & > ( ) .~U ( ) in einem nicht ausgewerteten Kontext wohlgeformt ist, value entspricht true . Andernfalls entspricht value false .
2) Gleich wie (1) und zusätzlich ist std:: remove_all_extents < T > :: type entweder ein Nicht-Klassentyp oder ein Klassentyp mit einem trivialen Destruktor .
3) Gleich wie (1) , aber der Destruktor ist noexcept .

Wenn T kein vollständiger Typ, (möglicherweise cv-qualifiziert) void , oder ein Array unbekannter Größe ist, ist das Verhalten undefiniert.

Wenn eine Instanziierung einer Vorlage oben direkt oder indirekt von einem unvollständigen Typ abhängt und diese Instanziierung ein anderes Ergebnis liefern könnte, wenn dieser Typ hypothetisch vervollständigt würde, ist das Verhalten undefiniert.

Wenn das Programm Spezialisierungen für irgendwelche der auf dieser Seite beschriebenen Templates hinzufügt, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Hilfsvariablen-Templates

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

Geerbt von std:: integral_constant

Member-Konstanten

value
[static]
true falls T destruierbar ist, false andernfalls
(öffentliche statische Member-Konstante)

Member-Funktionen

operator bool
konvertiert das Objekt zu bool , gibt value zurück
(öffentliche Member-Funktion)
operator()
(C++14)
gibt value zurück
(öffentliche Member-Funktion)

Member-Typen

Typ Definition
value_type bool
type std:: integral_constant < bool , value >

Hinweise

Da das C++-Programm abbricht, wenn ein Destruktor während des Stack-Unwindings eine Exception wirft (was in der Regel nicht vorhergesagt werden kann), sind alle praktischen Destruktoren nicht-werfend, selbst wenn sie nicht als noexcept deklariert sind. Alle in der C++-Standardbibliothek vorhandenen Destruktoren sind nicht-werfend.

Der von trivial zerstörbaren Objekten belegte Speicher kann wiederverwendet werden ohne den Destruktor aufzurufen.

Mögliche Implementierung

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; }>
{};

Beispiel

Diesen Code ausführen 
#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() {}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 2049 C++11 die Spezifikation war aufgrund der imaginären Wrapper-Struktur nicht vollständig ausführbar vollständig gemacht

Siehe auch

(C++11) (C++11) (C++11)
prüft, ob ein Typ einen Konstruktor für bestimmte Argumente besitzt
(Klassentemplate)
(C++11)
prüft, ob ein Typ einen virtuellen Destruktor besitzt
(Klassentemplate)
(C++20)
spezifiziert, dass ein Objekt des Typs zerstört werden kann
(Konzept)
destructor gibt beanspruchte Ressourcen frei