std::is_move_constructible,std::is_trivially_move_constructible,std::is_nothrow_move_constructible (3) - Linux Man Pages

std::is_move_constructible,std::is_trivially_move_constructible,std::is_nothrow_move_constructible: std::is_move_constructible,std::is_trivially_move_constructible,std::is_nothrow_move_constructible


std::is_move_constructible,std::is_trivially_move_constructible,std::is_nothrow_move_constructible - std::is_move_constructible,std::is_trivially_move_constructible,std::is_nothrow_move_constructible


Defined in header <type_traits>
template< class T > (1) (since C++11)
struct is_move_constructible;
template< class T > (2) (since C++11)
struct is_trivially_move_constructible;
template< class T > (3) (since C++11)
struct is_nothrow_move_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, T&&>::value.
2) Same as (1), but uses std::is_trivially_constructible<T, T&&>.
3) Same as (1), but uses std::is_nothrow_constructible<T, 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_move_constructible_v = is_move_constructible<T>::value;
template< class T > (since C++17)
inline constexpr bool is_trivially_move_constructible_v = is_trivially_move_constructible<T>::value;
template< class T > (since C++17)
inline constexpr bool is_nothrow_move_constructible_v = is_nothrow_move_constructible<T>::value;

Inherited from std::integral_constant

Member constants

value true if T is move-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_move_constructible :
        std::is_constructible<T, typename std::add_rvalue_reference<T>::type> {};

  template<class T>
  struct is_trivially_move_constructible :
       std::is_trivially_constructible<T, typename std::add_rvalue_reference<T>::type> {};

  template<class T>
  struct is_nothrow_move_constructible :
       std::is_nothrow_constructible<T, typename std::add_rvalue_reference<T>::type> {};


Types without a move constructor, but with a copy constructor that accepts const T& arguments, satisfy std::is_move_constructible.
Move constructors are usually noexcept, since otherwise they are unusable in any code that provides strong exception guarantee.
In many implementations, is_nothrow_move_constructible also checks if the destructor throws because it is effectively noexcept(T(arg)). Same applies to is_trivially_move_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 but non-throwing move ctor
  struct Ex2 {
      int n;
      Ex2(Ex2&&) = default; // trivial and non-throwing
  struct NoMove {
      // prevents implicit declaration of default move constructor
      // however, the class is still move-constructible because its
      // copy constructor can bind to an rvalue argument
      NoMove(const NoMove&) {}

  int main() {
      std::cout << std::boolalpha << "Ex1 is move-constructible? "
                << std::is_move_constructible<Ex1>::value << '\n'
                << "Ex1 is trivially move-constructible? "
                << std::is_trivially_move_constructible<Ex1>::value << '\n'
                << "Ex1 is nothrow move-constructible? "
                << std::is_nothrow_move_constructible<Ex1>::value << '\n'
                << "Ex2 is trivially move-constructible? "
                << std::is_trivially_move_constructible<Ex2>::value << '\n'
                << "Ex2 is nothrow move-constructible? "
                << std::is_nothrow_move_constructible<Ex2>::value << '\n';

      std::cout << std::boolalpha
                << "NoMove is move-constructible? "
                << std::is_move_constructible<NoMove>::value << '\n'
                << "NoMove is nothrow move-constructible? "
                << std::is_nothrow_move_constructible<NoMove>::value << '\n';


  Ex1 is move-constructible? true
  Ex1 is trivially move-constructible? false
  Ex1 is nothrow move-constructible? true
  Ex2 is trivially move-constructible? true
  Ex2 is nothrow move-constructible? true
  NoMove is move-constructible? true
  NoMove is nothrow move-constructible? false

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_copy_constructible checks if a type has a copy constructor
                                   (class template)

move obtains an rvalue reference
                                   (function template)

move_if_noexcept obtains an rvalue reference if the move constructor does not throw
                                   (function template)