Namespaces
Variants

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

From cppreference.net
C++
Metaprogramming library
Type traits
Type categories
(C++11)
(C++11) ( DR* )
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Type properties
(C++11)
(C++11)
(C++11)
(C++11)
(C++14)
(C++11)
(C++17)
(C++23)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
(C++11) ( until C++20* )
(C++11) (deprecated in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Type trait constants
(C++11) (C++17) (C++11) (C++11)
Metafunctions
(C++17)
(C++17)
(C++17)
Supported operations
(C++11) (C++11) (C++11)
is_move_assignable is_trivially_move_assignable is_nothrow_move_assignable
(C++11) (C++11) (C++11)
(C++11) (C++11) (C++11)
(C++11)
(C++17) (C++17) (C++17) (C++17)

Relationships and property queries
Type modifications
Type transformations
(C++11) (deprecated in C++23)
(C++11) (deprecated in C++23)
(C++11)
(C++20)
(C++11) ( until C++20* ) (C++17)

Compile-time rational arithmetic
Compile-time integer sequences
(C++14)
Definiert im Header <type_traits>
template < class T >
struct is_move_assignable ;
(1) (seit C++11)
template < class T >
struct is_trivially_move_assignable ;
(2) (seit C++11)
template < class T >
struct is_nothrow_move_assignable ;
(3) (seit C++11)
Typ-Trait Wert der Member-Konstante value
T ist ein referenzierbarer Typ T ist kein referenzierbarer Typ
(1) std:: is_assignable < T & , T && > :: value false
(2) std:: is_trivially_assignable < T & , T && > :: value
(3) std:: is_nothrow_assignable < T & , T && > :: value

Wenn T kein vollständiger Typ ist, (möglicherweise cv-qualifiziert) void , oder ein Array unbekannter Größe, ist das Verhalten undefiniert.

Wenn eine Instanziierung einer Vorlage oben direkt oder indirekt von einem unvollständigen Typ abhängt und diese Instanziierung ein anderes Ergebnis liefern könnte, wenn dieser Typ hypothetisch vervollständigt würde, ist das Verhalten undefiniert.

Wenn das Programm Spezialisierungen für irgendwelche der auf dieser Seite beschriebenen Templates hinzufügt, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Hilfsvariablen-Templates

template < class T >

inline constexpr bool is_move_assignable_v =

is_move_assignable < T > :: value ;
(seit C++17)
template < class T >

inline constexpr bool is_trivially_move_assignable_v =

is_trivially_move_assignable < T > :: value ;
(seit C++17)
template < class T >

inline constexpr bool is_nothrow_move_assignable_v =

is_nothrow_move_assignable < T > :: value ;
(seit C++17)

Geerbt von std:: integral_constant

Member-Konstanten

value
[static]
true wenn T move-zuweisbar ist, false andernfalls
(öffentliche statische Member-Konstante)

Member-Funktionen

operator bool
konvertiert das Objekt zu bool , gibt value zurück
(öffentliche Member-Funktion)
operator()
(C++14)
gibt value zurück
(öffentliche Member-Funktion)

Member-Typen

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

Mögliche Implementierung 

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

Hinweise

Das Trait std::is_move_assignable ist weniger streng als MoveAssignable , da es nicht den Typ des Zuweisungsergebnisses überprüft (der für einen MoveAssignable -Typ T& sein muss), noch die semantische Anforderung, dass der Wert des Ziels nach der Zuweisung äquivalent zum Wert der Quelle vor der Zuweisung ist.

Der Typ muss keinen Move-Zuweisungsoperator implementieren, um dieses Merkmal zu erfüllen; siehe MoveAssignable für Details.

Beispiel

Diesen Code ausführen 
#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';
}

Ausgabe: 

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

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrektes Verhalten
LWG 2196 C++11 das Verhalten war unklar, falls T && nicht gebildet werden kann der erzeugte Wert ist false in diesem Fall

Siehe auch

(C++11) (C++11) (C++11)
prüft, ob ein Typ einen Zuweisungsoperator für einen bestimmten Argumenttyp besitzt
(Klassentemplate)
(C++11) (C++11) (C++11)
prüft, ob ein Typ einen Kopierzuweisungsoperator besitzt
(Klassentemplate)