Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::is_nothrow_copy_constructible — construcción por copia sin excepciones

Este rasgo de <type_traits> comprueba en tiempo de compilación si construir T a partir de const T& es válido y se sabe que no lanza excepciones. std::is_nothrow_copy_constructible<T>::value y std::is_nothrow_copy_constructible_v<T> ofrecen el mismo resultado bool.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <type_traits>

std::is_nothrow_copy_constructible<T>::value
std::is_nothrow_copy_constructible_v<T>

std::is_nothrow_copy_constructible<T> es una plantilla de clase de <type_traits> cuyo miembro ::value es una constante de tipo bool. std::is_nothrow_copy_constructible_v<T> es una plantilla de variable que ofrece el mismo valor. El resultado se puede usar en static_assert y if constexpr.

Para un tipo T al que se pueda formar una referencia, el resultado equivale a std::is_nothrow_constructible_v<T, const T&>: la inicialización directa debe ser válida y se debe saber que no lanza excepciones. Para los demás tipos, el resultado es false. La comprobación no ejecuta el constructor; incluso un constructor vacío declarado como noexcept(false) produce false.

Esto comprueba la construcción, no la asignación ni la copia trivial. Si la resolución de sobrecargas para la construcción a partir de const T& selecciona un constructor eliminado o inaccesible, el resultado es false. Por ejemplo, para una clase T con un constructor T(T&) eliminado y un constructor público T(const T&) declarado noexcept, la resolución de sobrecargas selecciona el constructor público. Eso no basta para garantizar un resultado de true: si el destructor está eliminado o es inaccesible, la definición hipotética de variable que se usa en la comprobación no es válida y el resultado es false. Para los tipos de referencia, comprueba la vinculación de referencias, no la copia del objeto referido; por ejemplo, std::is_nothrow_copy_constructible_v<int&> es true.

T debe ser un tipo completo, posiblemente void con calificadores cv, o un array de tamaño desconocido. No uses este rasgo para examinar una clase declarada hacia delante antes de su definición. No añadas especializaciones propias de estas plantillas: hacerlo provoca un comportamiento indefinido del programa.

Ejemplos

#include <iostream>
#include <type_traits>

struct Safe {
    Safe(const Safe&) noexcept {}
};

struct Risky {
    Risky(const Risky&) noexcept(false) {}
};

struct Blocked {
    Blocked(const Blocked&) = delete;
};

static_assert(std::is_nothrow_copy_constructible<Safe>::value);
static_assert(!std::is_nothrow_copy_constructible_v<Risky>);
static_assert(!std::is_nothrow_copy_constructible_v<Blocked>);

int main() {
    std::cout << std::boolalpha
              << std::is_nothrow_copy_constructible<Safe>::value << '\n'
              << std::is_nothrow_copy_constructible_v<Risky> << '\n'
              << std::is_nothrow_copy_constructible_v<Blocked> << '\n';
}

Resultado

true
false
false

El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.

Fuentes