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

Si T no es un tipo completo, (posiblemente calificado cv) void , o un array de límite desconocido, el comportamiento es indefinido.

Si una instanciación de una plantilla anterior depende, directa o indirectamente, de un tipo incompleto, y esa instanciación podría producir un resultado diferente si ese tipo se completara hipotéticamente, el comportamiento no está definido.

Si el programa añade especializaciones para cualquiera de las plantillas descritas en esta página, el comportamiento no está definido.

Plantillas de variables auxiliares

Implementación posible

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> {};

Notas

El rasgo std::is_move_assignable es menos estricto que MoveAssignable porque no verifica el tipo del resultado de la asignación (que, para un tipo MoveAssignable , debe ser T& ), ni el requisito semántico de que el valor del destino después de la asignación sea equivalente al valor del origen antes de la asignación.

El tipo no necesita implementar un operador de asignación de movimiento para satisfacer este rasgo; consulte MoveAssignable para más detalles.

Ejemplo

#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 trivially move-assignable? "
              << std::is_trivially_move_assignable<Foo>::value << '\n'
              << "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

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

Véase también