std::is_copy_constructible,std::is_trivially_copy_constructible,std::is_nothrow_copy_constructible (3) - Linux Manuals

std::is_copy_constructible,std::is_trivially_copy_constructible,std::is_nothrow_copy_constructible: std::is_copy_constructible,std::is_trivially_copy_constructible,std::is_nothrow_copy_constructible


std::is_copy_constructible,std::is_trivially_copy_constructible,std::is_nothrow_copy_constructible - std::is_copy_constructible,std::is_trivially_copy_constructible,std::is_nothrow_copy_constructible


Defined in header <type_traits>
template< class T > (1) (since C++11)
struct is_copy_constructible;
template< class T > (2) (since C++11)
struct is_trivially_copy_constructible;
template< class T > (3) (since C++11)
struct is_nothrow_copy_constructible;

1) If T is not a referenceable type (i.e., possibly cv-qualified void or a function type with a cv-qualifier-seq or a ref-qualifier), provides a member constant value equal to false. Otherwise, provides a member constant value equal to std::is_constructible<T, const T&>::value.
2) Same as (1), but uses std::is_trivially_constructible<T, const T&>.
3) Same as (1), but uses std::is_nothrow_constructible<T, const T&>.
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_copy_constructible_v = is_copy_constructible<T>::value;
template< class T > (since C++17)
inline constexpr bool is_trivially_copy_constructible_v = is_trivially_copy_constructible<T>::value;
template< class T > (since C++17)
inline constexpr bool is_nothrow_copy_constructible_v = is_nothrow_copy_constructible<T>::value;

Inherited from std::integral_constant

Member constants

value true if T is copy-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_copy_constructible :
      std::is_constructible<T, typename std::add_lvalue_reference<
          typename std::add_const<T>::type>::type>> {};

  template<class T>
  struct is_trivially_copy_constructible :
      std::is_trivially_constructible<T, typename std::add_lvalue_reference<
          typename std::add_const<T>::type>::type>> {};

  template<class T>
  struct is_nothrow_copy_constructible :
      std::is_nothrow_constructible<T, typename std::add_lvalue_reference<
          typename std::add_const<T>::type>::type>> {};


In many implementations, is_nothrow_copy_constructible also checks if the destructor throws because it is effectively noexcept(T(arg)). Same applies to is_trivially_copy_constructible, which, in these implementations, also requires that the destructor is trivial: GCC_bug_51452 LWG_issue_2116.


// Run this code

  #include <iostream>
  #include <type_traits>

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

  int main() {
      std::cout << std::boolalpha << "Ex1 is copy-constructible? "
                << std::is_copy_constructible<Ex1>::value << '\n'
                << "Ex1 is trivially copy-constructible? "
                << std::is_trivially_copy_constructible<Ex1>::value << '\n'
                << "Ex2 is trivially copy-constructible? "
                << std::is_trivially_copy_constructible<Ex2>::value << '\n'
                << "Ex2 is nothrow copy-constructible? "
                << std::is_nothrow_copy_constructible<Ex2>::value << '\n';


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

See also

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

is_nothrow_default_constructible checks if a type has a default constructor
                                   (class template)

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