Namespaces
Variants

std:: is_copy_assignable, std:: is_trivially_copy_assignable, std:: is_nothrow_copy_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
is_copy_assignable is_trivially_copy_assignable is_nothrow_copy_assignable
(C++11) (C++11) (C++11)
(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_copy_assignable ;
(1) (seit C++11)
template < class T >
struct is_trivially_copy_assignable ;
(2) (seit C++11)
template < class T >
struct is_nothrow_copy_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 & , const T & > :: value false
(2) std:: is_trivially_assignable < T & , const T & > :: value
(3) std:: is_nothrow_assignable < T & , const 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 irgendeine der auf dieser Seite beschriebenen Templates hinzufügt, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Hilfsvariablen-Templates

template < class T >

inline constexpr bool is_copy_assignable_v =

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

inline constexpr bool is_trivially_copy_assignable_v =

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

inline constexpr bool is_nothrow_copy_assignable_v =

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

Geerbt von std:: integral_constant

Member-Konstanten

value
[static]
true falls T kopierzuweisbar 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_copy_assignable
    : std::is_assignable<typename std::add_lvalue_reference<T>::type,
                         typename std::add_lvalue_reference<const T>::type> {};
template<class T>
struct is_trivially_copy_assignable
    : std::is_trivially_assignable<typename std::add_lvalue_reference<T>::type,
                                   typename std::add_lvalue_reference<const T>::type> {};
template<class T>
struct is_nothrow_copy_assignable
    : std::is_nothrow_assignable<typename std::add_lvalue_reference<T>::type,
                                 typename std::add_lvalue_reference<const T>::type> {};
**Hinweis:** Der gesamte Code innerhalb der ` 
`-Tags wurde gemäß den Anweisungen nicht übersetzt, da es sich um C++-Code handelt. Die HTML-Struktur und Attribute bleiben ebenfalls unverändert.

Hinweise

Das Trait std::is_copy_assignable ist weniger streng als CopyAssignable , da es nicht den Typ des Ergebnisses der Zuweisung überprüft (welcher für einen CopyAssignable -Typ ein L-Wert vom Typ T sein muss) und nicht die semantische Anforderung prüft, dass der Argumentausdruck unverändert bleibt. Es prüft auch nicht, dass T MoveAssignable erfüllt, was für alle CopyAssignable -Typen erforderlich ist.

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <type_traits>
#include <utility>
struct Foo { int n; };
int main()
{
    std::cout << std::boolalpha
              << "Foo is trivially copy-assignable? "
              << std::is_trivially_copy_assignable<Foo>::value << '\n'
              << "int[2] is copy-assignable? "
              << std::is_copy_assignable<int[2]>::value << '\n'
              << "int is nothrow copy-assignable? "
              << std::is_nothrow_copy_assignable<int>::value << '\n';
}

Ausgabe: 

Foo is trivially copy-assignable? true
int[2] is copy-assignable? false
int is nothrow copy-assignable? true

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 const T & nicht gebildet werden kann der produzierte 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 Move-Zuweisungsoperator besitzt
(Klassentemplate)