CKTIS / C++
std::is_nothrow_copy_constructible — construction par copie sans exception
Ce trait de <type_traits> vérifie à la compilation si la construction de T à partir de const T& est valide et réputée ne pas lancer d’exception. std::is_nothrow_copy_constructible<T>::value et std::is_nothrow_copy_constructible_v<T> donnent le même résultat bool.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
#include <type_traits>
std::is_nothrow_copy_constructible<T>::value
std::is_nothrow_copy_constructible_v<T>std::is_nothrow_copy_constructible<T> est un modèle de classe de <type_traits> dont le membre ::value est une constante de type bool. std::is_nothrow_copy_constructible_v<T> est un modèle de variable qui expose la même valeur. Le résultat peut être utilisé dans static_assert et if constexpr.
Pour un type T auquel une référence peut être formée, le résultat est égal à std::is_nothrow_constructible_v<T, const T&> : l’initialisation directe doit être valide et réputée ne pas lancer d’exception. Pour les autres types, le résultat est false. Le test n’exécute pas le constructeur ; même un constructeur vide déclaré noexcept(false) donne false.
Ce trait teste la construction, et non l’affectation ou la copie triviale. Si la résolution de surcharge pour la construction à partir de const T& sélectionne un constructeur supprimé ou inaccessible, le résultat est false. Par exemple, pour une classe T dotée d’un constructeur T(T&) supprimé et d’un constructeur public T(const T&) déclaré noexcept, la résolution de surcharge sélectionne le constructeur public. Cela ne suffit pas à garantir un résultat de true : si le destructeur est supprimé ou inaccessible, la définition hypothétique de variable utilisée par le test est mal formée, et le résultat est false. Pour les types référence, il vérifie la liaison de référence plutôt que la copie de l’objet référencé ; par exemple, std::is_nothrow_copy_constructible_v<int&> vaut true.
T doit être un type complet, éventuellement void qualifié cv, ou un tableau de taille inconnue. N’utilisez pas ce trait pour examiner une classe déclarée en avance avant sa définition. N’ajoutez pas vos propres spécialisations de ces modèles : cela entraîne un comportement indéfini du programme.
Exemples
#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';
}
Résultat
true false false
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.