Namespaces
Variants

std:: is_assignable, std:: is_trivially_assignable, std:: is_nothrow_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
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, class U >
struct is_assignable ;
(1) (seit C++11)
template < class T, class U >
struct is_trivially_assignable ;
(2) (seit C++11)
template < class T, class U >
struct is_nothrow_assignable ;
(3) (seit C++11)
1) Wenn der Ausdruck std:: declval < T > ( ) = std:: declval < U > ( ) in einem nicht ausgewerteten Kontext wohlgeformt ist, liefert die Member-Konstante value den Wert true . Andernfalls ist value gleich false . Zugriffsprüfungen werden durchgeführt, als ob sie aus einem Kontext stammten, der zu keinem der beiden Typen in Beziehung steht.
2) Gleich wie (1) , aber die Auswertung des Zuweisungsausdrucks wird keinen Vorgang aufrufen, der nicht trivial ist. Für die Zwecke dieser Überprüfung wird ein Aufruf von std::declval als trivial betrachtet und nicht als ODR-Nutzung von std::declval angesehen.
3) Gleich wie (1) , aber die Auswertung des Zuweisungsausdrucks ruft keine Operation auf, die nicht noexcept ist.

Wenn T oder U kein vollständiger Typ ist, (möglicherweise cv-qualifiziertes) 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, class U >
constexpr bool is_assignable_v = is_assignable < T, U > :: value ;
(seit C++17)
template < class T, class U >
constexpr bool is_trivially_assignable_v = is_trivially_assignable < T, U > :: value ;
(seit C++17)
template < class T, class U >
constexpr bool is_nothrow_assignable_v = is_nothrow_assignable < T, U > :: value ;
(seit C++17)

Geerbt von std:: integral_constant

Member-Konstanten

value
[static]
true falls T von U zuweisbar ist, false sonst
(ö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 >

Hinweise

Dieses Merkmal prüft nichts außerhalb des unmittelbaren Kontexts des Zuweisungsausdrucks: Wenn die Verwendung von T oder U Template-Spezialisierungen, die Generierung implizit definierter spezieller Elementfunktionen etc. auslösen würde und diese Fehler enthalten, kann die tatsächliche Zuweisung möglicherweise nicht kompiliert werden, selbst wenn std :: is_assignable < T,U > :: value kompiliert und zu true ausgewertet wird.

Beispiel

Diesen Code ausführen 
#include <iostream>
#include <string>
#include <type_traits>
struct Ex1 { int n; };
int main()
{
    std::cout << std::boolalpha
              << "int is assignable from int? "
              << std::is_assignable<int, int>::value << '\n' // 1 = 1; wouldn't compile
              << "int& is assignable from int? "
              << std::is_assignable<int&, int>::value << '\n' // int a; a = 1; works
              << "int is assignable from double? "
              << std::is_assignable<int, double>::value << '\n'
              << "int& is nothrow assignable from double? "
              << std::is_nothrow_assignable<int&, double>::value << '\n'
              << "string is assignable from double? "
              << std::is_assignable<std::string, double>::value << '\n'
              << "Ex1& is trivially assignable from const Ex1&? "
              << std::is_trivially_assignable<Ex1&, const Ex1&>::value << '\n';
}

Ausgabe: 

int is assignable from int? false
int& is assignable from int? true
int is assignable from double? false
int& is nothrow assignable from double? true
string is assignable from double? true
Ex1& is trivially assignable from const Ex1&? true

Siehe auch

(C++11) (C++11) (C++11)
prüft, ob ein Typ einen Kopierzuweisungsoperator besitzt
(Klassentemplate)
(C++11) (C++11) (C++11)
prüft, ob ein Typ einen Verschiebezuweisungsoperator besitzt
(Klassentemplate)
(C++20)
spezifiziert, dass ein Typ von einem anderen Typ zuweisbar ist
(Konzept)