funciones<type_traits>

is_assignable
is_copy_assignable
is_copy_constructible
is_default_constructible
is_move_assignable
is_move_constructible
is_nothrow_move_assignable
is_nothrow_swappable
is_nothrow_swappable_with
is_swappable
is_swappable_with
is_trivially_copy_assignable
is_trivially_move_assignable
is_trivially_move_constructible

is_assignable

Comprueba si un valor de tipo Form se puede asignar a un tipo To.

template <class To, class From>
struct is_assignable;

Parámetros

Para
El tipo del objeto que recibe la asignación.

From
El tipo del objeto que proporciona el valor.

Comentarios

La expresión no evaluada declval<To>() = declval<From>() debe tener un formato correcto. Tanto From y To deben ser tipos completos, void o matrices de límite desconocido.

is_copy_assignable

Comprueba si el tipo se puede copiar en la asignación.

template <class Ty>
struct is_copy_assignable;

Parámetros

Ty
Tipo que se va a consultar.

Comentarios

Una instancia del predicado de tipo contiene true si el tipo Ty es una clase que tiene un operador de asignación de copia; en caso contrario, contiene false. Equivalente a is_assignable<Ty&, const Ty&>.

is_copy_constructible

Comprueba si el tipo tiene un constructor de copia.

template <class Ty>
struct is_copy_constructible;

Parámetros

Ty
Tipo que se va a consultar.

Comentarios

Una instancia del predicado de tipo es true si el tipo Ty es una clase que tiene un constructor de copia; en caso contrario, es false.

Ejemplo

#include <type_traits>
#include <iostream>

struct Copyable
{
    int val;
};

struct NotCopyable
{
   NotCopyable(const NotCopyable&) = delete;
   int val;

};

int main()
{
    std::cout << "is_copy_constructible<Copyable> == " << std::boolalpha
        << std::is_copy_constructible<Copyable>::value << std::endl;
    std::cout << "is_copy_constructible<NotCopyable> == " << std::boolalpha
        << std::is_copy_constructible<NotCopyable>::value << std::endl;

    return (0);
}

is_copy_constructible<Copyable> == true
is_copy_constructible<NotCopyable > == false

is_default_constructible

Comprueba si un tipo tiene un constructor predeterminado.

template <class Ty>
struct is_default_constructible;

Parámetros

T
Tipo que se va a consultar.

Comentarios

Una instancia del predicado de tipo es true si el tipo T es una clase que tiene un constructor predeterminado; en caso contrario, es false. Es equivalente al elemento is_constructible<T>del predicado. El tipo T debe ser un tipo completo, void o una matriz de límite desconocido.

Ejemplo

#include <type_traits>
#include <iostream>

struct Simple
{
    Simple() : val(0) {}
    int val;
};

struct Simple2
{
    Simple2(int v) : val(v) {}
    int val;
};

int main()
{
    std::cout << "is_default_constructible<Simple> == " << std::boolalpha
        << std::is_default_constructible<Simple>::value << std::endl;
    std::cout << "is_default_constructible<Simple2> == " << std::boolalpha
        << std::is_default_constructible<Simple2>::value << std::endl;

    return (0);
}

is_default_constructible<Simple> == true
is_default_constructible<Simple2> == false

is_move_assignable

Comprueba si el tipo se puede asignar mediante movimiento.

template <class T>
struct is_move_assignable;

Parámetros

T
Tipo que se va a consultar.

Comentarios

Un tipo se puede asignar mediante movimiento si una referencia a un valor R al tipo se puede asignar a una referencia al tipo. El predicado de tipo es equivalente a is_assignable<T&, T&&>. Los tipos que se pueden asignar mediante movimiento incluyen los tipos escalares a los que se puede hacer referencia y los tipos de clase que tienen operadores de asignación de movimiento generados por el compilador o definidos por el usuario.

is_move_constructible

Comprueba si el tipo tiene un constructor de movimiento.

template <class T>
struct is_move_constructible;

Parámetros

T
El tipo que se debe evaluar

Comentarios

Predicado de tipo que da como resultado True si el tipo T se puede construir mediante una operación de movimiento. Este predicado es equivalente a is_constructible<T, T&&>.

is_nothrow_move_assignable

Comprueba si el tipo tiene un operador de asignación de movimiento nothrow.

template <class Ty>
struct is_nothrow_move_assignable;

Parámetros

Ty
Tipo que se va a consultar.

Comentarios

Una instancia del predicado de tipo es true si el tipo Ty tiene un operador de asignación de movimiento nothrow; en caso contrario, es false.

is_nothrow_swappable

template <class T> struct is_nothrow_swappable;

is_nothrow_swappable_with

template <class T, class U> struct is_nothrow_swappable_with;

is_swappable

template <class T> struct is_swappable;

is_swappable_with

template <class T, class U> struct is_swappable_with;

is_trivially_copy_assignable

Comprueba si el tipo tiene un operador de asignación de copia trivial.

template <class Ty>
struct is_trivially_copy_assignable;

Parámetros

T
Tipo que se va a consultar.

Comentarios

Una instancia del predicado de tipo contiene true si el tipo T es una clase que tiene un operador de asignación de copias trivial; en caso contrario, contiene false.

Un constructor de asignación para una clase T es trivial si se proporciona implícitamente, la clase T no tiene ninguna función virtual, la clase T no tiene ninguna base virtual, las clases de todos los miembros de datos no estáticos de tipo de clase tienen operadores de asignación triviales y las clases de todos los miembros de datos no estáticos de la matriz de tipo de clase tienen operadores de asignación triviales.

is_trivially_move_assignable

Comprueba si el tipo tiene un operador de asignación de movimiento trivial.

template <class Ty>
struct is_trivially_move_assignable;

Parámetros

Ty
Tipo que se va a consultar.

Comentarios

Una instancia del predicado de tipo contiene true si el tipo Ty es una clase que tiene un operador de asignación de movimiento trivial; en caso contrario, contiene false.

Un operador de asignación de movimiento para una clase Ty es trivial si:

se proporciona de forma implícita

la clase Ty no tiene ninguna función virtual

la clase Ty no tiene ninguna base virtual

las clases de todos los miembros de datos no estáticos del tipo de clase tienen operadores de asignación de movimiento triviales

las clases de todos los miembros de datos no estáticos de la matriz de tipo de clase tienen operadores de asignación de movimiento triviales

is_trivially_move_constructible

Comprueba si el tipo tiene un constructor de movimiento trivial.

template <class Ty>
struct is_trivially_move_constructible;

Parámetros

Ty
Tipo que se va a consultar.

Comentarios

Una instancia del predicado de tipo es true si el tipo Ty es una clase que tiene un constructor de movimiento trivial; en caso contrario, es false.

Un constructor de movimiento de una clase de tipo Ty es trivial si:

se declara de forma implícita

sus tipos de parámetro son equivalentes a los de una declaración implícita

la clase Ty no tiene ninguna función virtual

la clase Ty no tiene ninguna base virtual

la clase no tiene ningún miembro de datos no estáticos volátil

todas las bases directas de la clase de tipo Ty tienen constructores de movimiento trivial

las clases de todos los miembros de datos no estáticos del tipo de clase tienen constructores de movimiento triviales

las clases de todos los miembros de datos no estáticos de la matriz de tipo de clase tienen constructores de movimiento triviales

Consulte también

<type_traits>