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)
Definido en el encabezado <type_traits>
template < class T, class U >
struct is_assignable ;
(1) (desde C++11)
template < class T, class U >
struct is_trivially_assignable ;
(2) (desde C++11)
template < class T, class U >
struct is_nothrow_assignable ;
(3) (desde C++11)
1) Si la expresión std:: declval < T > ( ) = std:: declval < U > ( ) está bien formada en contexto no evaluado, proporciona la constante miembro value igual a true . De lo contrario, value es false . Las comprobaciones de acceso se realizan como si fuera desde un contexto no relacionado con ninguno de los dos tipos.
2) Igual que (1) , pero la evaluación de la expresión de asignación no llamará a ninguna operación que no sea trivial. Para los propósitos de esta verificación, una llamada a std::declval se considera trivial y no se considera un odr-use de std::declval .
3) Igual que (1) , pero la evaluación de la expresión de asignación no llamará a ninguna operación que no sea noexcept.

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 >
constexpr bool is_assignable_v = is_assignable < T, U > :: value ;
(desde C++17)
template < class T, class U >
constexpr bool is_trivially_assignable_v = is_trivially_assignable < T, U > :: value ;
(desde C++17)
template < class T, class U >
constexpr bool is_nothrow_assignable_v = is_nothrow_assignable < T, U > :: value ;
(desde C++17)

Heredado de std:: integral_constant

Constantes miembro

value
[static]
true si T es asignable desde 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 la expresión de asignación: si el uso de T o U activaría especializaciones de plantilla, generación de funciones miembro especiales implícitamente definidas, etc., y esas tienen errores, la asignación real podría no compilar incluso si std :: is_assignable < T,U > :: value compila y se evalúa como true .

Ejemplo

Ejecutar este código 
#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';
}

Salida: 

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

Véase también

(C++11) (C++11) (C++11)
verifica si un tipo tiene un operador de asignación de copia
(plantilla de clase)
(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 asignado desde otro tipo
(concepto)