Espacios de nombres
Variantes
Acciones

Archivo de encabezado de la biblioteca estándar <type_traits>

De cppreference.com
< cpp‎ | header
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Archivos de encabezado de la biblioteca estándar
 

Este archivo de encabezado es parte de la biblioteca de soporte de tipos.

Contenido

Clases

Clases asistentes
(C++11)
 Constante en tiempo de compilación del tipo especificado con el valor especificado.
(plantilla de clase) [editar]
true_type std::integral_constant<bool, true>
false_type std::integral_constant<bool, false>
Categorías de tipo primarias
(C++11)
 Comprueba si un tipo es void
(plantilla de clase) [editar]
(C++14)
 Comprueba si un tipo es std::nullptr_t
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo T es entero.
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo T es de punto flotante
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo array
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo enumeración
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo unión
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo clase (pero no un tipo unión).
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo función
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo puntero
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es una referencia lvalue.
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es una referencia rvalue.
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un puntero a un objeto miembro no estático
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un puntero a una función miembro no estática
(plantilla de clase) [editar]
Categorías de tipo compuestas
(C++11)
 Comprueba si un tipo es un tipo fundamental
(plantilla de clase) [editar]
(C++11)
Comprueba si un tipo es de tipo aritmético
Original:
checks if a type is arithmetic type
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]
(C++11)
Comprueba si un tipo es de tipo escalar
Original:
checks if a type is scalar type
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]
(C++11)
 Comprueba si un tipo es un tipo objeto
(plantilla de clase) [editar]
(C++11)
Comprueba si un tipo es de tipo compuesto
Original:
checks if a type is compound type
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]
(C++11)
 Comprueba si un tipo es o bien una referencia lvalue o una referencia rvalue
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un puntero a una función miembro no estática o a un objeto miembro no estático.
(plantilla de clase) [editar]
Propiedades de tipos
(C++11)
 Comprueba si un tipo está calificado con el calificador const
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo está calificado con el calificador volatile
(plantilla de clase) [editar]
(C++11)
Comprueba si un tipo es trivial
Original:
checks if a type is trivial
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]
(C++11)
 Comprueba si un tipo es trivialmente copiable.
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo de diseño estándar.
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo simple (POD).
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo literal.
(plantilla de clase) [editar]
(C++17)
 Comprueba si cada bit en la representación de objeto del tipo contribuye a su valor.
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo de clase que no es una unión y no tiene datos.
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es tipo clase polimórfico
(plantilla de clase) [editar]
(C++11)
Comprueba si un tipo es el tipo de clase abstracta
Original:
checks if a type is abstract class type
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]
(C++14)
 Comprueba si un tipo es un tipo de clase final.
(plantilla de clase) [editar]
(C++17)
 Comprueba si un tipo es un tipo de agregado.
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es un tipo aritmético con signo.
(plantilla de clase) [editar]
(C++11)
Comprueba si un tipo es el tipo de aritmética sin signo
Original:
checks if a type is unsigned arithmetic type
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]
(C++20)
 Comprueba si un tipo es un tipo de array de límite conocido.
(plantilla de clase) [editar]
(C++20)
 Comprueba si un tipo es un tipo de array de límite desconocido.
(plantilla de clase) [editar]
Operaciones soportadas
(C++11)(C++11)(C++11)
Comprueba si un tipo tiene un constructor de argumentos concretos
Original:
checks if a type has a constructor for specific arguments
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]
(C++11)(C++11)(C++11)
Comprueba si un tipo tiene un constructor por defecto
Original:
checks if a type has a default constructor
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]
(C++11)(C++11)(C++11)
Comprueba si un tipo tiene un constructor de copia
Original:
checks if a type has a copy constructor
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]
(C++11)(C++11)(C++11)
Comprueba si un tipo tiene un constructor de movimiento
Original:
checks if a type has a move constructor
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]
(C++11)(C++11)(C++11)
Comprueba si un tipo tiene un operador de asignación para un argumento específico
Original:
checks if a type has a assignment operator for a specific argument
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]
(C++11)(C++11)(C++11)
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]
(C++11)(C++11)(C++11)
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]
(C++11)(C++11)(C++11)
 Comprueba si un tipo tiene un destructor no eliminado (e.g., = delete).
(plantilla de clase) [editar]
(C++11)
Comprueba si un tipo tiene un destructor virtual
Original:
checks if a type has a virtual destructor
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]
(C++17)(C++17)(C++17)(C++17)
 Comprueba si objetos de un tipo pueden intercambiarse con objetos del mismo tipo o diferente tipo.
(plantilla de clase) [editar]
(C++23)
 Comprueba si una referencia está vinculada a un temporal en la inicialización por copia.
(plantilla de clase) [editar]
(C++23)
 Comprueba si una referencia está vinculada a un temporal en la inicialización directa.
(plantilla de clase) [editar]
Consultas de propiedades
(C++11)
 Obtiene los requisitos de alineación del tipo
(plantilla de clase) [editar]
(C++11)
 Obtiene el número de dimensiones de un tipo array
(plantilla de clase) [editar]
(C++11)
 Obtiene el tamaño de un tipo array a lo largo de una dimensión especificada
(plantilla de clase) [editar]
Relaciones de tipos
(C++11)
 Comprueba si dos tipos son los mismos
(plantilla de clase) [editar]
(C++11)
 Comprueba si un tipo es derivado de otro tipo
(plantilla de clase) [editar]
(C++11)(C++20)
 Comprueba si un tipo puede convertirse a otro tipo.
(plantilla de clase) [editar]
(C++20)
 Comprueba si dos tipos tienen diseño compatible.
(plantilla de clase) [editar]
(C++20)
 Comprueba si un tipo es una base (inicial) interconvertible-por-puntero a otro tipo.
(plantilla de clase) [editar]
(C++17)
 Comprueba si un tipo puede invocarse (como si lo fuera por std::invoke) con el número de argumentos dado.
(plantilla de clase) [editar]
Especificadores const y de volatilidad
(C++11)(C++11)(C++11)
 Elimina los especificadores const y/o volatile del tipo dado.
(plantilla de clase) [editar]
(C++11)(C++11)(C++11)
 Agrega los especificadores const y/o volatile al tipo dado
(plantilla de clase) [editar]
Referencias
(C++11)
 Elimina la referencia de un tipo dado.
(plantilla de clase) [editar]
(C++11)(C++11)
 Añade referencia lvalue o rvalue al tipo dado.
(plantilla de clase) [editar]
Punteros
(C++11)
 Elimina el puntero del tipo dado
(plantilla de clase) [editar]
(C++11)
 Agrega puntero al tipo dado
(plantilla de clase) [editar]
Modificadores de signo
(C++11)
 Hace al tipo entero dado con signo
(plantilla de clase) [editar]
(C++11)
 Hace al tipo entero dado sin signo
(plantilla de clase) [editar]
Arrays
(C++11)
 Elimina una dimensión del tipo array dado
(plantilla de clase) [editar]
(C++11)
 Elimina todas las dimensiones del tipo array dado
(plantilla de clase) [editar]
Transformaciones misceláneas
(C++11)
 Define el tipo adecuado para su uso como almacenamiento sin inicializar para tipos de un tamaño dado
(plantilla de clase) [editar]
(C++11)
 Define el tipo adecuado para su uso como almacenamiento sin inicializar para todos los tipos dados
(plantilla de clase) [editar]
(C++11)
 Aplica transformaciones de tipo como se cuando pasa un argumento de función por valor
(plantilla de clase) [editar]
(C++20)
 Combina std::remove_cv y std::remove_reference.
(plantilla de clase) [editar]
(C++11)
 Condicionalmente elimina una sobrecarga de función o especialización de plantilla de la resolución de sobrecargas.
(plantilla de clase) [editar]
(C++11)
 Escoge un tipo u otro basado un tipo Booleano en tiempo de compilación
(plantilla de clase) [editar]
(C++11)
 Deduce el tipo del resultado de una expresión aritmética mixta
(plantilla de clase) [editar]
(C++11)
 Obtiene el tipo subyacente entero para un tipo enumeración dado
(plantilla de clase) [editar]
(C++11)
 Deduce el tipo de retorno de una expresión de llamada a la función.
(plantilla de clase) [editar]
(C++17)
 Plantilla de alias void variádica.
(plantilla de alias) [editar]
Operaciones sobre los rasgos
(C++17)
 Metafunción variádica de AND lógico.
(plantilla de clase) [editar]
(C++17)
 Metafunción variádica de OR lógico.
(plantilla de clase) [editar]
(C++17)
 Metafunción NOT lógico.
(plantilla de clase) [editar]

Funciones

Relaciones de miembros
(C++20)
 Comprueba si los objetos de un tipo son interconvertibles-por-puntero con el subobjeto especificado de ese tipo.
(plantilla de función) [editar]
(C++20)
 Comprueba si dos miembros especificados se corresponden mutuamente en la subsecuencia inicial común de dos tipos especificados.
(plantilla de función) [editar]
Contexto de evaluación constante
(C++20)
 Detecta si la llamada ocurre dentro de un contexto evaluado constante.
(función) [editar]


[editar] Sinopsis

namespace std {
  // clase asistente:
  template <class T, T v> struct integral_constant;
  template <bool B>
  using bool_constant = integral_constant<bool, B>;
  using true_type = bool_constant<true>;
  using false_type = bool_constant<false>;
 
  // categorías de tipo primarias:
  template <class T> struct is_void;
  template <class T> struct is_null_pointer;
  template <class T> struct is_integral;
  template <class T> struct is_floating_point;
  template <class T> struct is_array;
  template <class T> struct is_pointer;
  template <class T> struct is_lvalue_reference;
  template <class T> struct is_rvalue_reference;
  template <class T> struct is_member_object_pointer;
  template <class T> struct is_member_function_pointer;
  template <class T> struct is_enum;
  template <class T> struct is_union;
  template <class T> struct is_class;
  template <class T> struct is_function;
 
  // categorías de tipo compuestas:
  template <class T> struct is_reference;
  template <class T> struct is_arithmetic;
  template <class T> struct is_fundamental;
  template <class T> struct is_object;
  template <class T> struct is_scalar;
  template <class T> struct is_compound;
  template <class T> struct is_member_pointer;
 
  // propiedades de tipos:
  template <class T> struct is_const;
  template <class T> struct is_volatile;
  template <class T> struct is_trivial;
  template <class T> struct is_trivially_copyable;
  template <class T> struct is_standard_layout;
  template <class T> struct is_pod;
  template <class T> struct is_empty;
  template <class T> struct is_polymorphic;
  template <class T> struct is_abstract;
  template <class T> struct is_final;
  template <class T> struct is_aggregate;
  template <class T> struct is_signed;
  template <class T> struct is_unsigned;
  template <class T> struct is_bounded_array;
  template <class T> struct is_unbounded_array;
  template <class T, class... Args> struct is_constructible;
  template <class T> struct is_default_constructible;
  template <class T> struct is_copy_constructible;
  template <class T> struct is_move_constructible;
  template <class T, class U> struct is_assignable;
  template <class T> struct is_copy_assignable;
  template <class T> struct is_move_assignable;
  template <class T, class U> struct is_swappable_with;
  template <class T> struct is_swappable;
  template <class T> struct is_destructible;
  template <class T, class... Args> struct is_trivially_constructible;
  template <class T> struct is_trivially_default_constructible;
  template <class T> struct is_trivially_copy_constructible;
  template <class T> struct is_trivially_move_constructible;
  template <class T, class U> struct is_trivially_assignable;
  template <class T> struct is_trivially_copy_assignable;
  template <class T> struct is_trivially_move_assignable;
  template <class T> struct is_trivially_destructible;
  template <class T, class... Args> struct is_nothrow_constructible;
  template <class T> struct is_nothrow_default_constructible;
  template <class T> struct is_nothrow_copy_constructible;
  template <class T> struct is_nothrow_move_constructible;
  template <class T, class U> struct is_nothrow_assignable;
  template <class T> struct is_nothrow_copy_assignable;
  template <class T> struct is_nothrow_move_assignable;
  template <class T, class U> struct is_nothrow_swappable_with;
  template <class T> struct is_nothrow_swappable;
  template <class T> struct is_nothrow_destructible;
  template <class T> struct has_virtual_destructor;
  template <class T> struct has_unique_object_representations;
 
  // consultas de propiedades de tipos:
  template <class T> struct alignment_of;
  template <class T> struct rank;
  template <class T, unsigned I = 0> struct extent;
 
  // relaciones de tipos:
  template <class T, class U> struct is_same;
  template <class Base, class Derived> struct is_base_of;
  template <class From, class To> struct is_convertible;
  template <class From, class To> struct is_nothrow_convertible;
  template<class T, class U> struct is_layout_compatible;
  template<class Base, class Derived> struct is_pointer_interconvertible_base_of;
  template <class Fn, class... ArgTypes> struct is_invocable;
  template <class R, class Fn, class... ArgTypes> struct is_invocable_r;
  template <class Fn, class... ArgTypes> struct is_nothrow_invocable;
  template <class R, class Fn, class... ArgTypes> struct is_nothrow_invocable_r;
 
  // modificaciones const-volatile:
  template <class T> struct remove_const;
  template <class T> struct remove_volatile;
  template <class T> struct remove_cv;
  template <class T> struct add_const;
  template <class T> struct add_volatile;
  template <class T> struct add_cv;
  template <class T>
  using remove_const_t = typename remove_const<T>::type;
  template <class T>
  using remove_volatile_t = typename remove_volatile<T>::type;
  template <class T>
  using remove_cv_t = typename remove_cv<T>::type;
  template <class T>
  using add_const_t = typename add_const<T>::type;
  template <class T>
  using add_volatile_t = typename add_volatile<T>::type;
  template <class T>
  using add_cv_t = typename add_cv<T>::type;
 
  // modificaciones de referencia:
  template <class T> struct remove_reference;
  template <class T> struct add_lvalue_reference;
  template <class T> struct add_rvalue_reference;
  template <class T>
  using remove_reference_t = typename remove_reference<T>::type;
  template <class T>
  using add_lvalue_reference_t = typename add_lvalue_reference<T>::type;
  template <class T>
  using add_rvalue_reference_t = typename add_rvalue_reference<T>::type;
 
  // modificaciones de signo:
  template <class T> struct make_signed;
  template <class T> struct make_unsigned;
  template <class T>
  using make_signed_t = typename make_signed<T>::type;
  template <class T>
  using make_unsigned_t = typename make_unsigned<T>::type;
 
  // modificaciones de array:
  template <class T> struct remove_extent;
  template <class T> struct remove_all_extents;
  template <class T>
  using remove_extent_t = typename remove_extent<T>::type;
  template <class T>
  using remove_all_extents_t = typename remove_all_extents<T>::type;
 
  // modificaciones de puntero:
  template <class T> struct remove_pointer;
  template <class T> struct add_pointer;
  template <class T>
  using remove_pointer_t = typename remove_pointer<T>::type;
  template <class T>
  using add_pointer_t = typename add_pointer<T>::type;
 
  // otras transformaciones:
  template <size_t Len,
  size_t Align = /*alineamiento por defecto*/ > 
  struct aligned_storage;
  template <size_t Len, class... Types> struct aligned_union;
  template <class T> struct decay;
  template <class T> struct remove_cvref;
  template <bool, class T = void> struct enable_if;
  template <bool, class T, class F> struct conditional;
  template <class... T> struct common_type;
  template <class T> struct underlying_type;
  template <class> class result_of; // no definido
  template <class F, class... ArgTypes> class result_of<F(ArgTypes...)>;
  template <class F, class... ArgTypes> class invoke_result;
  template <size_t Len,
  size_t Align = /*alineamiento por defecto*/ > 
  using aligned_storage_t = typename aligned_storage<Len, Align>::type;
  template <size_t Len, class... Types>
  using aligned_union_t = typename aligned_union<Len, Types...>::type;
  template <class T>
  using decay_t = typename decay<T>::type;
  template <class T>
  using remove_cvref_t = typename remove_cvref<T>::type;
  template <bool b, class T = void>
  using enable_if_t = typename enable_if<b, T>::type;
  template <bool b, class T, class F>
  using conditional_t = typename conditional<b, T, F>::type;
  template <class... T>
  using common_type_t = typename common_type<T...>::type;
  template <class T>
  using underlying_type_t = typename underlying_type<T>::type;
  template <class T>
  using result_of_t = typename result_of<T>::type;
  template <class F, class... ArgTypes> 
  using invoke_result_t = typename invoke_result<F, ArgTypes...>::type;
  template <class...>
  using void_t = void;
 
  // rasgos de operadores lógicos:
  template<class... B> struct conjunction;
  template<class... B> struct disjunction;
  template<class B> struct negation;
 
  // categorías de tipo primarias
  template <class T> inline constexpr bool is_void_v
  = is_void<T>::value;
  template <class T> inline constexpr bool is_null_pointer_v
  = is_null_pointer<T>::value;
  template <class T> inline constexpr bool is_integral_v
  = is_integral<T>::value;
  template <class T> inline constexpr bool is_floating_point_v
  = is_floating_point<T>::value;
  template <class T> inline constexpr bool is_array_v
  = is_array<T>::value;
  template <class T> inline constexpr bool is_pointer_v
  = is_pointer<T>::value;
  template <class T> inline constexpr bool is_lvalue_reference_v
  = is_lvalue_reference<T>::value;
  template <class T> inline constexpr bool is_rvalue_reference_v
  = is_rvalue_reference<T>::value;
  template <class T> inline constexpr bool is_member_object_pointer_v
  = is_member_object_pointer<T>::value;
  template <class T> inline constexpr bool is_member_function_pointer_v
  = is_member_function_pointer<T>::value;
  template <class T> inline constexpr bool is_enum_v
  = is_enum<T>::value;
  template <class T> inline constexpr bool is_union_v
  = is_union<T>::value;
  template <class T> inline constexpr bool is_class_v
  = is_class<T>::value;
  template <class T> inline constexpr bool is_function_v
  = is_function<T>::value;
 
  // categorías de tipo compuestas
  template <class T> inline constexpr bool is_reference_v
  = is_reference<T>::value;
  template <class T> inline constexpr bool is_arithmetic_v
  = is_arithmetic<T>::value;
  template <class T> inline constexpr bool is_fundamental_v
  = is_fundamental<T>::value;
  template <class T> inline constexpr bool is_object_v
  = is_object<T>::value;
  template <class T> inline constexpr bool is_scalar_v
  = is_scalar<T>::value;
  template <class T> inline constexpr bool is_compound_v
  = is_compound<T>::value;
  template <class T> inline constexpr bool is_member_pointer_v
  = is_member_pointer<T>::value;
 
  // propiedades de tipos
  template <class T> inline constexpr bool is_const_v
  = is_const<T>::value;
  template <class T> inline constexpr bool is_volatile_v
  = is_volatile<T>::value;
  template <class T> inline constexpr bool is_trivial_v
  = is_trivial<T>::value;
  template <class T> inline constexpr bool is_trivially_copyable_v
  = is_trivially_copyable<T>::value;
  template <class T> inline constexpr bool is_standard_layout_v
  = is_standard_layout<T>::value;
  template <class T> inline constexpr bool is_pod_v
  = is_pod<T>::value;
  template <class T> inline constexpr bool is_empty_v
  = is_empty<T>::value;
  template <class T> inline constexpr bool is_polymorphic_v
  = is_polymorphic<T>::value;
  template <class T> inline constexpr bool is_abstract_v
  = is_abstract<T>::value;
  template <class T> inline constexpr bool is_final_v
  = is_final<T>::value;
  template <class T> inline constexpr bool is_aggregate_v
  = is_aggregate<T>::value;
  template <class T> inline constexpr bool is_signed_v
  = is_signed<T>::value;
  template <class T> inline constexpr bool is_unsigned_v
  = is_unsigned<T>::value;
  template <class T> inline constexpr bool is_bounded_array_v
  = is_bounded_array<T>::value;
  template <class T> inline constexpr bool is_unbounded_array_v
  = is_unbounded_array<T>::value;
  template <class T, class... Args> inline constexpr bool is_constructible_v
  = is_constructible<T, Args...>::value;
  template <class T> inline constexpr bool is_default_constructible_v
  = is_default_constructible<T>::value;
  template <class T> inline constexpr bool is_copy_constructible_v
  = is_copy_constructible<T>::value;
  template <class T> inline constexpr bool is_move_constructible_v
  = is_move_constructible<T>::value;
  template <class T, class U> inline constexpr bool is_assignable_v
  = is_assignable<T, U>::value;
  template <class T> inline constexpr bool is_copy_assignable_v
  = is_copy_assignable<T>::value;
  template <class T> inline constexpr bool is_move_assignable_v
  = is_move_assignable<T>::value;
  template <class T, class U> inline constexpr bool is_swappable_with_v
  = is_swappable_with<T, U>::value;
  template <class T> inline constexpr bool is_swappable_v
  = is_swappable<T>::value;
  template <class T> inline constexpr bool is_destructible_v
  = is_destructible<T>::value;
  template <class T, class... Args> inline constexpr bool is_trivially_constructible_v
  = is_trivially_constructible<T, Args...>::value;
  template <class T> inline constexpr bool is_trivially_default_constructible_v
  = is_trivially_default_constructible<T>::value;
  template <class T> inline constexpr bool is_trivially_copy_constructible_v
  = is_trivially_copy_constructible<T>::value;
  template <class T> inline constexpr bool is_trivially_move_constructible_v
  = is_trivially_move_constructible<T>::value;
  template <class T, class U> inline constexpr bool is_trivially_assignable_v
  = is_trivially_assignable<T, U>::value;
  template <class T> inline constexpr bool is_trivially_copy_assignable_v
  = is_trivially_copy_assignable<T>::value;
  template <class T> inline constexpr bool is_trivially_move_assignable_v
  = is_trivially_move_assignable<T>::value;
  template <class T> inline constexpr bool is_trivially_destructible_v
  = is_trivially_destructible<T>::value;
  template <class T, class... Args> inline constexpr bool is_nothrow_constructible_v
  = is_nothrow_constructible<T, Args...>::value;
  template <class T> inline constexpr bool is_nothrow_default_constructible_v
  = is_nothrow_default_constructible<T>::value;
  template <class T> inline constexpr bool is_nothrow_copy_constructible_v
  = is_nothrow_copy_constructible<T>::value;
  template <class T> inline constexpr bool is_nothrow_move_constructible_v
  = is_nothrow_move_constructible<T>::value;
  template <class T, class U> inline constexpr bool is_nothrow_assignable_v
  = is_nothrow_assignable<T, U>::value;
  template <class T> inline constexpr bool is_nothrow_copy_assignable_v
  = is_nothrow_copy_assignable<T>::value;
  template <class T> inline constexpr bool is_nothrow_move_assignable_v
  = is_nothrow_move_assignable<T>::value;
  template <class T, class U> inline constexpr bool is_nothrow_swappable_with_v
  = is_nothrow_swappable_with<T, U>::value;
  template <class T> inline constexpr bool is_nothrow_swappable_v
  = is_nothrow_swappable<T>::value;
  template <class T> inline constexpr bool is_nothrow_destructible_v
  = is_nothrow_destructible<T>::value;
  template <class T> inline constexpr bool has_virtual_destructor_v
  = has_virtual_destructor<T>::value;
  template <class T> inline constexpr bool has_unique_object_representations_v
  = has_unique_object_representations<T>::value;
 
  // consultas de propiedades de tipos
  template <class T> inline constexpr size_t alignment_of_v
  = alignment_of<T>::value;
  template <class T> inline constexpr size_t rank_v
  = rank<T>::value;
  template <class T, unsigned I = 0> inline constexpr size_t extent_v
  = extent<T, I>::value;
 
  // relaciones de tipos
  template <class T, class U> inline constexpr bool is_same_v
  = is_same<T, U>::value;
  template <class Base, class Derived> inline constexpr bool is_base_of_v
  = is_base_of<Base, Derived>::value;
  template <class From, class To> inline constexpr bool is_convertible_v
  = is_convertible<From, To>::value;
  template <class From, class To> inline constexpr bool is_nothrow_convertible_v
  = is_nothrow_convertible<From, To>::value;
  template <class T, class U>
    inline constexpr bool is_layout_compatible_v = is_layout_compatible<T, U>::value;
  template <class Base, class Derived>
    inline constexpr bool is_pointer_interconvertible_base_of_v
      = is_pointer_interconvertible_base_of<Base, Derived>::value;
 
  template <class Fn, class... ArgTypes> 
  inline constexpr bool is_invocable_v
    = is_invocable<Fn, ArgTypes...>::value;
  template <class R, class Fn, class... ArgTypes>
  inline constexpr bool is_invocable_r_v
    = is_invocable_r<R, Fn, ArgTypes...>::value;
  template <class Fn, class... ArgTypes>
  inline constexpr bool is_nothrow_invocable_v
    = is_nothrow_invocable<Fn, ArgTypes...>::value;
  template <class R, class Fn, class... ArgTypes>
  inline constexpr bool is_nothrow_invocable_r_v
    = is_nothrow_invocable_r<R, Fn, ArgTypes...>::value;
 
  // rasgos de operadores lógicos:
  template<class... B> inline constexpr bool conjunction_v = conjunction<B...>::value;
  template<class... B> inline constexpr bool disjunction_v = disjunction<B...>::value;
  template<class B> inline constexpr bool negation_v = negation<B>::value;
 
  // relaciones de miembros
  template <class S, class M>
    constexpr bool is_pointer_interconvertible_with_class(M S::*m) noexcept;
  template <class S1, class S2, class M1, class M2>
    constexpr bool is_corresponding_member(M1 S1::*m1, M2 S2::*m2) noexcept;
 
  // contexto de evaluación constante
  constexpr bool is_constant_evaluated() noexcept;
} // namespace std

[editar] Plantilla de clase std::integral_constant

namespace std {
  template <class T, T v>
  struct integral_constant {
    static constexpr T value = v;
    using value_type = T;
    using type = integral_constant<T, v>;
    constexpr operator value_type() const noexcept { return value; }
    constexpr value_type operator()() const noexcept { return value; }
  };
}
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/header/type_traits&oldid=44561»