Namensräume
Varianten
Aktionen

std::is_destructible, std::is_trivially_destructible, std::is_nothrow_destructible

Von cppreference.com
< cpp‎ | types
 
C++
 
Metaprogrammierungsbibliothek
Typmerkmale
Typkategorien
(C++11)
(C++11)(DR*)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11) 
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Typeneigenschaften
(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)(bis C++20*)
(C++11)(veraltet in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Typmerkmalskonstanten
(C++11)(C++17)(C++11)(C++11)
Metafunktionen
(C++17)
(C++17)
(C++17)
Unterstützte Operationen
(C++11)(C++11)(C++11)
(C++11)(C++11)(C++11)
is_destructibleis_trivially_destructibleis_nothrow_destructible
(C++11)(C++11)(C++11)
(C++11)
(C++17)(C++17)(C++17)(C++17)

Beziehungen und Eigenschaftsabfragen
Typmodifikationen
(C++11)(C++11)(C++11)
(C++11)(C++11)(C++11)
(C++11)
(C++11)
Typentransformationen
(C++11)(veraltet in C++23)
(C++11)(veraltet in C++23)
(C++11)
(C++20)
(C++11)(bis C++20*)(C++17)

(C++11)
(C++11)
(C++20)
(C++11)
(C++20)
(C++11)
(C++17)
Rationale Arithmetik zur Compilezeit
Ganzzahlsequenzen zur Compilezeit
(C++14)
 
Definiert in der Kopfdatei <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, enthält es das Member-Konstante value, das gleich true ist.
Wenn T (möglicherweise cv-qualifiziertes) void, ein Funktionstyp oder ein Array unbekannter Bindung ist, ist value gleich false.
Wenn T ein Objekttyp ist, dann für den Typ U, der std::remove_all_extents<T>::type ist, wenn der Ausdruck std::declval<U&>().~U() in einem nicht ausgewerteten Kontext gut formiert ist, ist value gleich true. Andernfalls ist value gleich false.
2) Wie in (1) und zusätzlich ist std::remove_all_extents<T>::type entweder ein Nicht-Klassen-Typ oder ein Klassentyp mit einem trivialen Destruktor.
3) Wie in (1), aber der Destruktor ist noexcept.

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

Wenn eine Instanziierung einer Vorlage davon 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 eine der auf dieser Seite beschriebenen Vorlagen hinzufügt, ist das Verhalten undefiniert.

Inhalt

[edit] 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)
[Bearbeiten]

Abgeleitet von std::integral_constant

Member-Konstanten

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

Memberfunktionen

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

Membertypen

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

[edit] Anmerkungen

Da das C++-Programm abbricht, wenn ein Destruktor während des Stack-Unwindings eine Ausnahme auslöst (was normalerweise nicht vorhergesagt werden kann), sind alle praktischen Destruktoren nicht-werfend, auch wenn sie nicht als noexcept deklariert sind. Alle im C++-Standard-Bibliothek gefundenen Destruktoren sind nicht-werfend.

Der von trivial destruierbaren Objekten belegte Speicher kann wiederverwendet werden, ohne den Destruktor aufzurufen.

[edit] 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; }>
{};

[edit] Beispiel

Führen Sie diesen Code aus
#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() {}

[edit] Fehlerberichte

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

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 2049 C++11 Die Spezifikation war wegen der imaginären Wrapping-Struktur nicht vollständig. vollständig gemacht

[edit] Siehe auch

(C++11)(C++11)(C++11)
 prüft, ob ein Typ einen Konstruktor für spezifische Argumente hat
(Klassenvorlage) [bearbeiten]
(C++11)
 prüft, ob ein Typ einen virtuellen Destruktor hat
(Klassenvorlage) [bearbeiten]
(C++20)
 spezifiziert, dass ein Objekt des Typs zerstört werden kann
(Konzept) [bearbeiten]
Destruktor gibt beanspruchte Ressourcen frei[edit]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/types/is_destructible&oldid=176474"