Espacios de nombres
Variantes
Acciones

std::is_assignable, std::is_trivially_assignable, std::is_nothrow_assignable

De cppreference.com
< cpp‎ | types
 
 
Biblioteca de servicios
 
Apoyo de tipos
Tipos básicos
Tipos fundamentales
Tipos enteros de anchura fija (C++11)
Límites numéricos
Interfaz de C de límites numéricos
Información de tipo
en tiempo de ejecución
Rasgos de tipos
Categorías de tipos
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Propiedades de tipos
(C++11)
(C++11)
(C++14)
(C++11)
(C++11)(hasta C++20)
(C++11)(en desuso en C++20)
(C++11)
Constantes de rasgos de tipos
Metafunciones
(C++17)
Contexto de evaluación constante
Operaciones soportadas
is_assignableis_trivially_assignableis_nothrow_assignable
(C++11)(C++11)(C++11)
Relaciones y consultas de propiedades
Modificaciones de tipos
(C++11)(C++11)(C++11)
Transformaciones de tipos
(C++11)
(C++11)
(C++17)
(C++11)(hasta C++20)(C++17)
 
Definido en el archivo de 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 un contexto no evaluado, proporciona la constante miembro value igual a true. De lo contrario, value es false. Las comprobaciones de acceso se llevan a cabo como si fuera de un contexto no relacionado con ninguno de los 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. A efectos de esta comprobación, una llamada a std::declval se considera trivial y no se considera un uso ODR 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.

T y U deberá cada uno ser un tipo completo, (posiblemente calificado-cv) void, o un array de límite desconocido. De lo contrario, el comportamiento está indefinido.

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

El comportamiento de un programa que añade especializaciones para cualquiera de las plantillas definidas en esta página no está definido.

Contenido

[editar] Plantillas de variable auxiliares

template< class T, class U >
inline constexpr bool is_assignable_v = is_assignable<T, U>::value;
(desde C++17)
template< class T, class U >
inline constexpr bool is_trivially_assignable_v = is_trivially_assignable<T, U>::value;
(desde C++17)
template< class T, class U >
inline constexpr bool is_nothrow_assignable_v = is_nothrow_assignable<T, U>::value;
(desde C++17)

Heredado de std::integral_constant

Constantes miembro

value
[estático]
true si T es asignable desde U , de lo contrario false.
(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>

[editar] Notas

Este rasgo no comprueba nada fuera el contexto inmediato de la expresión de asignación: si el uso de T o U desencadenara especializaciones de plantilla, generación de funciones miembro especiales definidas implícitamente, etc., y esas tienen errores, la asignación real puede no compilarse incluso si std::is_assignable<T,U>::value compila y evalúa a true.

[editar] Ejemplo

#include <iostream>
#include <string>
#include <type_traits>
struct Ex1 { int n; };
int main() {
    std::cout << std::boolalpha
              << "int es asignable desde int? "
              << std::is_assignable<int, int>::value << '\n' // 1 = 1; no compilaría
              << "int& es asignable desde int? "
              << std::is_assignable<int&, int>::value << '\n' // int a; a = 1; works
              << "int es asignable desde double? "
              << std::is_assignable<int, double>::value << '\n'
              << "int& es nothrow asignable desde double? "
              << std::is_nothrow_assignable<int&, double>::value << '\n'
              << "string es asignable desde double? "
              << std::is_assignable<std::string, double>::value << '\n'
              << "Ex1& es trivialmente asignable desde const Ex1&? "
              << std::is_trivially_assignable<Ex1&, const Ex1&>::value << '\n';
}

Salida:

int es asignable desde int? false
int& es asignable desde int? true
int es asignable desde double? false
int& es nothrow asignable desde double? true
string es asignable desde double? true
Ex1& es trivialmente asignable desde const Ex1&? true

[editar] Véase también

Comprueba si un tipo tiene un operador de asignación de copia
Original:
checks if a type has a copy assignment operator
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(plantilla de clase) [editar]
Comprueba si un tipo tiene un operador de asignación de movimiento
Original:
checks if a type has a move assignment operator
The text has been machine-translated via Google Translate.
You can help to correct and verify the translation. Click here for instructions.

(plantilla de clase) [editar]