CKTIS / C++
std::is_nothrow_copy_constructible — construção por cópia sem exceções
Este traço de <type_traits> verifica em tempo de compilação se a construção de T a partir de const T& é válida e não lança exceções. std::is_nothrow_copy_constructible<T>::value e std::is_nothrow_copy_constructible_v<T> disponibilizam o mesmo resultado bool.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
#include <type_traits>
std::is_nothrow_copy_constructible<T>::value
std::is_nothrow_copy_constructible_v<T>std::is_nothrow_copy_constructible<T> é um modelo de classe de <type_traits> cujo membro ::value é uma constante do tipo bool. std::is_nothrow_copy_constructible_v<T> é um modelo de variável que disponibiliza o mesmo valor. O resultado pode ser utilizado em static_assert e if constexpr.
Para um tipo T para o qual seja possível formar uma referência, o resultado é igual a std::is_nothrow_constructible_v<T, const T&>: a inicialização direta tem de ser válida e não pode lançar exceções. Para os outros tipos, o resultado é false. O teste não executa o construtor; mesmo um construtor vazio declarado como noexcept(false) produz false.
Este traço testa a construção, não a atribuição nem a cópia trivial. Se a resolução de sobrecargas para a construção a partir de const T& selecionar um construtor eliminado ou inacessível, o resultado é false. Por exemplo, para uma classe T com um construtor T(T&) eliminado e um construtor público T(const T&) declarado noexcept, a resolução de sobrecargas seleciona o construtor público. Isso, por si só, não garante que o resultado seja true: se o destrutor estiver eliminado ou for inacessível, a definição hipotética de variável usada no teste não é válida e o resultado é false. Para tipos de referência, verifica a ligação da referência, e não a cópia do objeto referenciado; por exemplo, std::is_nothrow_copy_constructible_v<int&> é true.
T tem de ser um tipo completo, possivelmente void qualificado com cv, ou um array de dimensão desconhecida. Não utilize este traço para examinar uma classe declarada antecipadamente antes da sua definição. Não acrescente especializações próprias destes modelos: fazê-lo torna o comportamento do programa indefinido.
Exemplos
#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
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.