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)
Definido en el encabezado <type_traits>
template < class T, class U >
struct is_swappable_with ;
(1) (desde C++17)
template < class T >
struct is_swappable ;
(2) (desde C++17)
template < class T, class U >
struct is_nothrow_swappable_with ;
(3) (desde C++17)
template < class T >
struct is_nothrow_swappable ;
(4) (desde C++17)
1) Si las expresiones swap ( std:: declval < T > ( ) , std:: declval < U > ( ) ) y swap ( std:: declval < U > ( ) , std:: declval < T > ( ) ) están ambas bien formadas en contexto no evaluado después de using std:: swap ; (ver Swappable ), proporciona la constante miembro value igual a true . De lo contrario, value es false .
Access checks se realizan como si fuera desde un contexto no relacionado con ninguno de los tipos.
3) Igual que (1) , pero se sabe que las evaluaciones de ambas expresiones de (1) no lanzan excepciones.
Rasgo de tipo El valor de la constante miembro value
T es un tipo referenciable T no es un tipo referenciable
(2) std :: is_swappable_with < T & , T & > :: value false
(4) std :: is_nothrow_swappable_with < T & , T & > :: value

Si T o U no es un tipo completo, (posiblemente calificado con cv) void , o un array de límite desconocido, el comportamiento es indefinido.

Si una instanciación de una plantilla anterior depende, directa o indirectamente, de un tipo incompleto, y esa instanciación podría producir un resultado diferente si ese tipo se completara hipotéticamente, el comportamiento no está definido.

Si el programa añade especializaciones para cualquiera de las plantillas descritas en esta página, el comportamiento no está definido.

Contenidos

Plantillas de variables auxiliares

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

inline constexpr bool is_nothrow_swappable_with_v =

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

inline constexpr bool is_nothrow_swappable_v =

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

Heredado de std:: integral_constant

Constantes miembro

value
[static]
true si T es intercambiable con U , false en caso contrario
(constante miembro pública estática)

Funciones miembro

operator bool
convierte el objeto a bool , devuelve value
(función miembro pública)
operator()
(C++14)
devuelve value
(función miembro pública)

Tipos miembro

Tipo Definición
value_type bool
type std:: integral_constant < bool , value >

Notas

Este rasgo no verifica nada fuera del contexto inmediato de las expresiones de intercambio: si el uso de T o U activaría especializaciones de plantilla, generación de funciones miembro especiales definidas implícitamente, etc., y esas tienen errores, el intercambio real podría no compilar incluso si std :: is_swappable_with < T, U > :: value se compila y evalúa como true .

Ejemplo

Esta sección está incompleta
Razón: sin ejemplo

Véase también

intercambia los valores de dos objetos
(plantilla de función)
(C++11) (C++11) (C++11)
verifica si un tipo tiene un operador de asignación de movimiento
(plantilla de clase)
(C++20)
especifica que un tipo puede ser intercambiado o que dos tipos pueden intercambiarse entre sí
(concepto)