std::is_default_constructible,std::is_trivially_default_constructible,std::is_nothrow_default_constructible (3) - Linux Manuals

std::is_default_constructible,std::is_trivially_default_constructible,std::is_nothrow_default_constructible: std::is_default_constructible,std::is_trivially_default_constructible,std::is_nothrow_default_constructible


std::is_default_constructible,std::is_trivially_default_constructible,std::is_nothrow_default_constructible - std::is_default_constructible,std::is_trivially_default_constructible,std::is_nothrow_default_constructible


Defined in header <type_traits>
template< class T > (1) (since C++11)
struct is_default_constructible;
template< class T > (2) (since C++11)
struct is_trivially_default_constructible;
template< class T > (3) (since C++11)
struct is_nothrow_default_constructible;

1) If std::is_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false.
2) If std::is_trivially_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false.
3) If std::is_nothrow_constructible<T>::value is true, provides the member constant value equal to true, otherwise value is false.
T shall be a complete type, (possibly cv-qualified) void, or an array of unknown bound. Otherwise, the behavior is undefined.
If an instantiation of a template above depends, directly or indirectly, on an incomplete type, and that instantiation could yield a different result if that type were hypothetically completed, the behavior is undefined.

Helper variable templates

template< class T > (since C++17)
inline constexpr bool is_default_constructible_v = is_default_constructible<T>::value;
template< class T > (since C++17)
inline constexpr bool is_trivially_default_constructible_v = is_trivially_default_constructible<T>::value;
template< class T > (since C++17)
inline constexpr bool is_nothrow_default_constructible_v = is_nothrow_default_constructible<T>::value;

Inherited from std::integral_constant

Member constants

value true if T is default-constructible , false otherwise
         (public static member constant)

Member functions

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

operator() returns value
              (public member function)

Member types

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

Possible implementation

  template< class T>
  struct is_default_constructible : std::is_constructible<T> {};

  template< class T>
  struct is_trivially_default_constructible : std::is_trivially_constructible<T> {};

  template< class T>
  struct is_nothrow_default_constructible : std::is_nothrow_constructible<T> {};


In many implementations, is_nothrow_default_constructible also checks if the destructor throws because it is effectively noexcept(T()). Same applies to is_trivially_default_constructible, which, in these implementations, also requires that the destructor is trivial: GCC_bug_51452 LWG_issue_2116.
std::is_default_constructible<T> does not test that T x; would compile; it attempts direct-initialization with an empty argument list (see std::is_constructible). Thus, std::is_default_constructible_v<const int> and std::is_default_constructible_v<const int[10]> are true.


// Run this code

  #include <iostream>
  #include <type_traits>

  struct Ex1 {
      std::string str; // member has a non-trivial default ctor
  struct Ex2 {
      int n;
      Ex2() = default; // trivial and non-throwing

  int main() {
      std::cout << std::boolalpha << "Ex1 is default-constructible? "
                << std::is_default_constructible<Ex1>::value << '\n'
                << "Ex1 is trivially default-constructible? "
                << std::is_trivially_default_constructible<Ex1>::value << '\n'
                << "Ex2 is trivially default-constructible? "
                << std::is_trivially_default_constructible<Ex2>::value << '\n'
                << "Ex2 is nothrow default-constructible? "
                << std::is_nothrow_default_constructible<Ex2>::value << '\n';


  Ex1 is default-constructible? true
  Ex1 is trivially default-constructible? false
  Ex2 is trivially default-constructible? true
  Ex2 is nothrow default-constructible? true

See also

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

is_nothrow_copy_constructible checks if a type has a copy constructor
                                (class template)

is_nothrow_move_constructible checks if a type can be constructed from an rvalue reference
                                (class template)