Namespaces
Variants

std:: is_swappable_with, std:: is_swappable, std:: is_nothrow_swappable_with, std:: is_nothrow_swappable

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)
(C++11) (C++11) (C++11)
(C++11) (C++11) (C++11)
(C++11)
is_swappable_with is_swappable is_nothrow_swappable_with is_nothrow_swappable
(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, class U >
struct is_swappable_with ;
(1) (seit C++17)
template < class T >
struct is_swappable ;
(2) (seit C++17)
template < class T, class U >
struct is_nothrow_swappable_with ;
(3) (seit C++17)
template < class T >
struct is_nothrow_swappable ;
(4) (seit C++17)
1) Wenn die Ausdrücke swap ( std:: declval < T > ( ) , std:: declval < U > ( ) ) und swap ( std:: declval < U > ( ) , std:: declval < T > ( ) ) beide wohlgeformt in einem nicht ausgewerteten Kontext nach using std:: swap ; sind (siehe Swappable ), liefert die Member-Konstante value den Wert true . Andernfalls ist value false .
Access checks werden durchgeführt, als ob von einem Kontext, der zu keinem der beiden Typen gehört.
3) Gleich wie (1) , aber die Auswertungen beider Ausdrücke aus (1) sind bekannt, dass sie keine Ausnahmen werfen.
Typ-Trait Wert der Member-Konstante value
T ist ein referenzierbarer Typ T ist kein referenzierbarer Typ
(2) std :: is_swappable_with < T & , T & > :: value false
(4) std :: is_nothrow_swappable_with < T & , T & > :: value

Wenn T oder U 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, class U >
inline constexpr bool is_swappable_with_v = is_swappable_with < T, U > :: value ;
(seit C++17)
template < class T >
inline constexpr bool is_swappable_v = is_swappable < T > :: value ;
(seit C++17)
template < class T, class U >

inline constexpr bool is_nothrow_swappable_with_v =

is_nothrow_swappable_with < T, U > :: value ;
(seit C++17)
template < class T >

inline constexpr bool is_nothrow_swappable_v =

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

Geerbt von std:: integral_constant

Member-Konstanten

value
[static]
true falls T mit U austauschbar 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 >

Hinweise

Dieses Merkmal überprüft nichts außerhalb des unmittelbaren Kontexts der Swap-Ausdrücke: Wenn die Verwendung von T oder U Template-Spezialisierungen, die Erzeugung implizit definierter spezieller Member-Funktionen etc. auslösen würde und diese Fehler enthalten, könnte der tatsächliche Swap selbst dann nicht kompilieren, wenn std :: is_swappable_with < T, U > :: value kompiliert und zu true ausgewertet wird.

Beispiel

Dieser Abschnitt ist unvollständig
Grund: Kein Beispiel

Siehe auch

tauscht die Werte zweier Objekte
(Funktions-Template)
(C++11) (C++11) (C++11)
prüft, ob ein Typ einen Move-Zuweisungsoperator hat
(Klassen-Template)
(C++20)
spezifiziert, dass ein Typ getauscht werden kann oder dass zwei Typen miteinander getauscht werden können
(Konzept)