Namensräume
Varianten
Aktionen

std::is_copy_assignable, std::is_trivially_copy_assignable, std::is_nothrow_copy_assignable

Von cppreference.com
< cpp‎ | types
 
C++
 
Metaprogrammierungsbibliothek
Typmerkmale
Typkategorien
(C++11)
(C++11)(DR*)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11) 
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Typeneigenschaften
(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)(bis C++20*)
(C++11)(veraltet in C++20)
(C++11)
(C++11)
(C++20)
(C++20)
(C++23)
(C++17)
Typmerkmalskonstanten
(C++11)(C++17)(C++11)(C++11)
Metafunktionen
(C++17)
(C++17)
(C++17)
Unterstützte Operationen
is_copy_assignableis_trivially_copy_assignableis_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)

Beziehungen und Eigenschaftsabfragen
Typmodifikationen
(C++11)(C++11)(C++11)
(C++11)(C++11)(C++11)
(C++11)
(C++11)
Typentransformationen
(C++11)(veraltet in C++23)
(C++11)(veraltet in C++23)
(C++11)
(C++20)
(C++11)(bis C++20*)(C++17)

(C++11)
(C++11)
(C++20)
(C++11)
(C++20)
(C++11)
(C++17)
Rationale Arithmetik zur Compilezeit
Ganzzahlsequenzen zur Compilezeit
(C++14)
 
Definiert in der Kopfdatei <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  Der 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 davon 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 eine der auf dieser Seite beschriebenen Vorlagen hinzufügt, ist das Verhalten undefiniert.

Inhalt

[bearbeiten] Hilfsvariablentemplates

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)
[Bearbeiten]

Abgeleitet von std::integral_constant

Member-Konstanten

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

Memberfunktionen

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

Membertypen

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

[bearbeiten] 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> {};

[bearbeiten] Hinweise

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

[bearbeiten] Beispiel

Führen Sie diesen Code aus
#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

[bearbeiten] Fehlerberichte

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

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

[bearbeiten] Siehe auch

(C++11)(C++11)(C++11)
 prüft, ob ein Typ einen Zuweisungsoperator für ein bestimmtes Argument hat
(Klassenvorlage) [bearbeiten]
(C++11)(C++11)(C++11)
 prüft, ob ein Typ einen Verschiebezuweisungsoperator hat
(Klassenvorlage) [bearbeiten]
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/types/is_copy_assignable&oldid=177620"