std::is_move_assignable,std::is_trivially_move_assignable,std::is_nothrow_move_assignable (3) - Linux Manuals

std::is_move_assignable,std::is_trivially_move_assignable,std::is_nothrow_move_assignable: std::is_move_assignable,std::is_trivially_move_assignable,std::is_nothrow_move_assignable


std::is_move_assignable,std::is_trivially_move_assignable,std::is_nothrow_move_assignable - std::is_move_assignable,std::is_trivially_move_assignable,std::is_nothrow_move_assignable


Defined in header <type_traits>
template< class T > (1) (since C++11)
struct is_move_assignable;
template< class T > (2) (since C++11)
struct is_trivially_move_assignable;
template< class T > (3) (since C++11)
struct is_nothrow_move_assignable;

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_assignable<T&, T&&>::value.
2) Same as 1), but uses std::is_trivially_assignable<T&, T&&>
3) Same as 1), but uses std::is_nothrow_assignable<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_assignable_v = is_move_assignable<T>::value;
template< class T > (since C++17)
inline constexpr bool is_trivially_move_assignable_v = is_trivially_move_assignable<T>::value;
template< class T > (since C++17)
inline constexpr bool is_nothrow_move_assignable_v = is_nothrow_move_assignable<T>::value;

Inherited from std::integral_constant

Member constants

value true if T is move-assignable, 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_assignable
      : std::is_assignable< typename std::add_lvalue_reference<T>::type,
                            typename std::add_rvalue_reference<T>::type> {};

  template< class T>
  struct is_trivially_move_assignable
      : std::is_trivially_assignable< typename std::add_lvalue_reference<T>::type,
                                      typename std::add_rvalue_reference<T>::type> {};

  template< class T>
  struct is_nothrow_move_assignable
      : std::is_nothrow_assignable< typename std::add_lvalue_reference<T>::type,
                                    typename std::add_rvalue_reference<T>::type> {};


The trait std::is_move_assignable is less strict than MoveAssignable because it does not check the type of the result of the assignment (which, for a MoveAssignable type, must be T&), nor the semantic requirement that the target's value after the assignment is equivalent to the source's value before the assignment.
The type does not have to implement a move_assignment_operator in order to satisfy this trait; see MoveAssignable for details.


// Run this code

  #include <iostream>
  #include <string>
  #include <type_traits>
  struct Foo { int n; };
  struct NoMove {
      // prevents implicit declaration of default move assignment operator
      // however, the class is still move-assignable because its
      // copy assignment operator can bind to an rvalue argument
      NoMove& operator=(const NoMove&) { return *this; }
  int main() {
      std::cout << std::boolalpha
                << "std::string is nothrow move-assignable? "
                << std::is_nothrow_move_assignable<std::string>::value << '\n'
                << "int[2] is move-assignable? "
                << std::is_move_assignable<int[2]>::value << '\n'
                << "Foo is trivally move-assignable? "
                << std::is_trivially_move_assignable<Foo>::value << '\n';

      std::cout << std::boolalpha
                << "NoMove is move-assignable? "
                << std::is_move_assignable<NoMove>::value << '\n'
                << "NoMove is nothrow move-assignable? "
                << std::is_nothrow_move_assignable<NoMove>::value << '\n';


  std::string is nothrow move-assignable? true
  int[2] is move-assignable? false
  Foo is trivially move-assignable? true
  NoMove is move-assignable? true
  NoMove is nothrow move-assignable? false

See also

is_nothrow_assignable checks if a type has a assignment operator for a specific argument
                             (class template)

is_nothrow_copy_assignable checks if a type has a copy assignment operator
                             (class template)