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

From Cppreference

Jump to: navigation, search

Defined in header `<type_traits>`

template< class T > struct is_destructible;	(1)	(C++11 feature)

template< class T > struct is_trivially_destructible;	(2)	(C++11 feature)

template< class T > struct is_nothrow_destructible;	(3)	(C++11 feature)

1) If an imaginary struct containing a member object of type T has a non-deleted destructor, provides the member constant value equal true. For any other type, value is false.

2) same as 1), but the destructor does not call any operation that is not trivial.

3) same as 1), but the destructor is noexcept.

Inherited from std::integral_constant

Member constants


`value`	true if `T` is destructible, false otherwise (public static member constant)

Member functions


`operator bool`	converts the object to bool, returns `value` (public member function)

Member types


Type	Definition

`value_type`	`bool`

`type`	std::integral_constant<bool, value>

[edit] Notes

Because the C++ program terminates if a destructor throws an exception during stack unwinding (which usually cannot be predicted), all practical destructors are non-throwing even if they are not declared noexcept. All destructors found in the C++ standard library are non-throwing.

[edit] Example

#include <iostream>
#include <string>
#include <type_traits>
struct Foo {
   std::string str;
   ~Foo() noexcept {};
};
struct Bar {
    ~Bar() = default;
};
int main() {
    std::cout << std::boolalpha
              << "std::string is destructible? "
              << std::is_destructible<std::string>::value << '\n'
              << "Foo is nothrow destructible? "
              << std::is_nothrow_destructible<Foo>::value << '\n'
              << "Bar is trivally destructible? "
              << std::is_trivially_destructible<Bar>::value << '\n';
}

Output:

std::string is destructible? true
Foo is nothrow destructible? true
Bar is trivally destructible? true

[edit] See also

is_constructible is_trivially_constructible is_nothrow_constructible (C++11)
(C++11)
(C++11)

checks if a type has a constructor for specific arguments
(class template)

has_virtual_destructor (C++11)

checks if a type has a virtual destructor
(class template)