Namespaces
Variants

std:: is_constructible, std:: is_trivially_constructible, std:: is_nothrow_constructible

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 ... Args >
struct is_constructible ;
(1) (desde C++11)
template < class T, class ... Args >
struct is_trivially_constructible ;
(2) (desde C++11)
template < class T, class ... Args >
struct is_nothrow_constructible ;
(3) (desde C++11)
1) Si T es un tipo objeto o referencia y la definición de variable T obj ( std:: declval < Args > ( ) ... ) ; está bien formada, proporciona la constante miembro value igual a true . En todos los demás casos, value es false .
Para los propósitos de esta verificación, la definición de variable nunca se interpreta como una declaración de función, y el uso de std::declval no se considera un odr-use . Las verificaciones de acceso se realizan como si fuera desde un contexto no relacionado con T y cualquiera de los tipos en Args . Solo se considera la validez del contexto inmediato de la definición de variable.
2) Igual que (1) , pero la definición de la variable no llama a ninguna operación que no sea trivial. Para los propósitos de esta verificación, la llamada a std::declval se considera trivial.
3) Igual que (1) , pero la definición de la variable es noexcept .

Si T o cualquier tipo en el paquete de parámetros Args 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, class ... Args >

inline constexpr bool is_constructible_v =

is_constructible < T, Args... > :: value ;
(desde C++17)
template < class T, class ... Args >

inline constexpr bool is_trivially_constructible_v =

is_trivially_constructible < T, Args... > :: value ;
(desde C++17)
template < class T, class ... Args >

inline constexpr bool is_nothrow_constructible_v =

is_nothrow_constructible < T, Args... > :: value ;
(desde C++17)

Heredado de std:: integral_constant

Constantes miembro

value
[static]
true si T es construible desde Args... , 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

En muchas implementaciones, is_nothrow_constructible también verifica si el destructor lanza excepciones porque es efectivamente noexcept ( T ( arg ) ) . Lo mismo aplica para is_trivially_constructible , que en estas implementaciones también requiere que el destructor sea trivial: GCC bug 51452 LWG issue 2116 .

Ejemplo

Ejecutar este código 
#include <iostream>
#include <type_traits>
class Foo
{
    int v1;
    double v2;
public:
    Foo(int n) : v1(n), v2() {}
    Foo(int n, double f) noexcept : v1(n), v2(f) {}
};
int main()
{
    auto is = [](bool o) { return (o ? "\t" "is " : "\t" "isn't "); };
    std::cout << "Foo ...\n"
              << is(std::is_trivially_constructible_v<Foo, const Foo&>)
              << "Trivially-constructible from const Foo&\n"
              << is(std::is_trivially_constructible_v<Foo, int>)
              << "Trivially-constructible from int\n"
              << is(std::is_constructible_v<Foo, int>)
              << "Constructible from int\n"
              << is(std::is_nothrow_constructible_v<Foo, int>)
              << "Nothrow-constructible from int\n"
              << is(std::is_nothrow_constructible_v<Foo, int, double>)
              << "Nothrow-constructible from int and double\n";
}

Salida: 

Foo ...
        is Trivially-constructible from const Foo&
        isn't Trivially-constructible from int
        is Constructible from int
        isn't Nothrow-constructible from int
        is Nothrow-constructible from int and double

Véase también

(C++11) (C++11) (C++11)
verifica si un tipo tiene un constructor por defecto
(plantilla de clase)
(C++11) (C++11) (C++11)
verifica si un tipo tiene un constructor de copia
(plantilla de clase)
(C++11) (C++11) (C++11)
verifica si un tipo puede ser construido desde una referencia a valor
(plantilla de clase)
(C++20)
especifica que una variable del tipo puede ser construida desde o enlazada a un conjunto de tipos de argumentos
(concepto)