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

1) Si T es un objeto o tipo referencia y la definición de variable T obj(std::declval<Args>()...); está bien formada, proporciona la constante miembro value igual a true. In all other cases, value is false.

A efectos de esta comprobació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 uso ODR. Las comprobaciones de acceso se llevan a cabo como si lo fueran desde un contexto no asociado 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 variable no llama a ninguna operación que no sea trivial. A efectos de esta comprobación, la llamada a std::declval se considera trivial.

3) Igual que (1), pero la definición de variable es noexcept.

T y todos los tipos en el paquete de parámetros Args 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.

[editar] Plantillas de variable auxiliares

[editar] Notas

En muchas implementaciones, is_nothrow_constructible también comprueba si el destructor lanza porque es efectivamente noexcept(T(arg)). Lo mismo se aplica a is_trivially_constructible, que en estas implementaciones también requiere que el destructor sea trivial: GCC error de programación 51452 LWG problema 2116.

[editar] Ejemplo

#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() {
    std::cout << "Foo es ...\n" << std::boolalpha
              << "\tTrivialmente construible de const Foo&? "
              << std::is_trivially_constructible<Foo, const Foo&>::value << '\n'
              << "\tTrivialmente construible de int? "
              << std::is_trivially_constructible<Foo, int>::value << '\n'
              << "\tConstruible de int? "
              << std::is_constructible<Foo, int>::value << '\n'
              << "\tNothrow construible de int? "
              << std::is_nothrow_constructible<Foo, int>::value << '\n'
              << "\tNothrow construible de int y double? "
              << std::is_nothrow_constructible<Foo, int, double>::value << '\n';
}

Foo es ...
        Trivialmente construible de const Foo&? true
        Trivialmente construible de int? false
        Construible de int? true
        Nothrow construible de int? false
        Nothrow construible de int y double? true

[editar] Véase también