Namespaces
Variants

std:: is_copy_assignable, std:: is_trivially_copy_assignable, std:: is_nothrow_copy_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
is_copy_assignable is_trivially_copy_assignable is_nothrow_copy_assignable
(C++11) (C++11) (C++11)
(C++11) (C++11) (C++11)
(C++11) (C++11) (C++11)
(C++11)
(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 >
struct is_copy_assignable ;
(1) (desde C++11)
template < class T >
struct is_trivially_copy_assignable ;
(2) (desde C++11)
template < class T >
struct is_nothrow_copy_assignable ;
(3) (desde C++11)
Rasgo de tipo El valor de la constante miembro value
T es un tipo referenciable T no es un tipo referenciable
(1) std:: is_assignable < T & , const T & > :: value false
(2) std:: is_trivially_assignable < T & , const T & > :: value
(3) std:: is_nothrow_assignable < T & , const T & > :: value

Si T no es un tipo completo, (posiblemente calificado 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 >

inline constexpr bool is_copy_assignable_v =

is_copy_assignable < T > :: value ;
(desde C++17)
template < class T >

inline constexpr bool is_trivially_copy_assignable_v =

is_trivially_copy_assignable < T > :: value ;
(desde C++17)
template < class T >

inline constexpr bool is_nothrow_copy_assignable_v =

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

Heredado de std:: integral_constant

Constantes miembro

value
[static]
true si T es asignable por copia, 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 >

Implementación posible 

template<class T>
struct is_copy_assignable
    : std::is_assignable<typename std::add_lvalue_reference<T>::type,
                         typename std::add_lvalue_reference<const T>::type> {};
template<class T>
struct is_trivially_copy_assignable
    : std::is_trivially_assignable<typename std::add_lvalue_reference<T>::type,
                                   typename std::add_lvalue_reference<const T>::type> {};
template<class T>
struct is_nothrow_copy_assignable
    : std::is_nothrow_assignable<typename std::add_lvalue_reference<T>::type,
                                 typename std::add_lvalue_reference<const T>::type> {};

Notas

El rasgo std::is_copy_assignable es menos estricto que CopyAssignable porque no verifica el tipo del resultado de la asignación (que, para un tipo CopyAssignable , debe ser un lvalue de tipo T ) y no verifica el requisito semántico de que la expresión del argumento permanezca sin cambios. Tampoco verifica que T satisfaga MoveAssignable , lo cual es requerido para todos los tipos CopyAssignable .

Ejemplo

Ejecutar este código 
#include <iostream>
#include <type_traits>
#include <utility>
struct Foo { int n; };
int main()
{
    std::cout << std::boolalpha
              << "Foo is trivially copy-assignable? "
              << std::is_trivially_copy_assignable<Foo>::value << '\n'
              << "int[2] is copy-assignable? "
              << std::is_copy_assignable<int[2]>::value << '\n'
              << "int is nothrow copy-assignable? "
              << std::is_nothrow_copy_assignable<int>::value << '\n';
}

Salida: 

Foo is trivially copy-assignable? true
int[2] is copy-assignable? false
int is nothrow copy-assignable? true

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares publicados anteriormente de C++.

DR Se aplica a Comportamiento publicado Comportamiento correcto
LWG 2196 C++11 el comportamiento no estaba claro si const T & no puede formarse el valor producido es false en este caso

Véase también

(C++11) (C++11) (C++11)
verifica si un tipo tiene un operador de asignación para un argumento específico
(plantilla de clase)
(C++11) (C++11) (C++11)
verifica si un tipo tiene un operador de asignación de movimiento
(plantilla de clase)