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)
Défini dans l'en-tête <type_traits>
template < class T, class U >
struct is_swappable_with ;
(1) (depuis C++17)
template < class T >
struct is_swappable ;
(2) (depuis C++17)
template < class T, class U >
struct is_nothrow_swappable_with ;
(3) (depuis C++17)
template < class T >
struct is_nothrow_swappable ;
(4) (depuis C++17)
1) Si les expressions swap ( std:: declval < T > ( ) , std:: declval < U > ( ) ) et swap ( std:: declval < U > ( ) , std:: declval < T > ( ) ) sont toutes deux bien formées dans un contexte non évalué après using std:: swap ; (voir Swappable ), fournit la constante membre value égale à true . Sinon, value est false .
Access checks sont effectués comme s'ils provenaient d'un contexte sans rapport avec l'un ou l'autre type.
3) Identique à (1) , mais les évaluations des deux expressions de (1) sont connues pour ne pas lever d'exceptions.
Caractéristique de type Valeur de la constante membre value
T est un type référençable T n'est pas un type référençable
(2) std :: is_swappable_with < T & , T & > :: value false
(4) std :: is_nothrow_swappable_with < T & , T & > :: value

Si T ou U n'est pas un type complet, (éventuellement qualifié cv) void , ou un tableau de limite inconnue, le comportement est indéfini.

Si l'instanciation d'un template ci-dessus dépend, directement ou indirectement, d'un type incomplet, et que cette instanciation pourrait produire un résultat différent si ce type était hypothétiquement complété, le comportement est indéfini.

Si le programme ajoute des spécialisations pour l'un des modèles décrits sur cette page, le comportement est indéfini.

Table des matières

Modèles de variables d'assistance

template < class T, class U >
inline constexpr bool is_swappable_with_v = is_swappable_with < T, U > :: value ;
(depuis C++17)
template < class T >
inline constexpr bool is_swappable_v = is_swappable < T > :: value ;
(depuis C++17)
template < class T, class U >

inline constexpr bool is_nothrow_swappable_with_v =

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

inline constexpr bool is_nothrow_swappable_v =

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

Hérité de std:: integral_constant

Constantes membres

value
[static]
true si T est échangeable avec U , false sinon
(constante membre publique statique)

Fonctions membres

operator bool
convertit l'objet en bool , retourne value
(fonction membre publique)
operator()
(C++14)
retourne value
(fonction membre publique)

Types membres

Type Définition
value_type bool
type std:: integral_constant < bool , value >

Notes

Ce trait ne vérifie rien en dehors du contexte immédiat des expressions d'échange : si l'utilisation de T ou U déclenchait des spécialisations de templates, la génération de fonctions membres spéciales implicitement définies, etc., et que celles-ci contiennent des erreurs, l'échange réel pourrait ne pas compiler même si std :: is_swappable_with < T, U > :: value se compile et s'évalue à true .

Exemple

Cette section est incomplète
Raison : aucun exemple

Voir aussi

échange les valeurs de deux objets
(modèle de fonction)
(C++11) (C++11) (C++11)
vérifie si un type a un opérateur d'affectation par déplacement
(modèle de classe)
(C++20)
spécifie qu'un type peut être échangé ou que deux types peuvent être échangés l'un avec l'autre
(concept)