std:: is_copy_constructible, std:: is_trivially_copy_constructible, std:: is_nothrow_copy_constructible

Si T n'est pas un type complet, (éventuellement qualifié cv) void , ou un tableau de limite inconnue, le comportement est indéfini.

Si l'instanciation d'un template ci-dessus dépend, directement ou indirectement, d'un type incomplet, et que cette instanciation pourrait produire un résultat différent si ce type était hypothétiquement complété, le comportement est indéfini.

Si le programme ajoute des spécialisations pour l'un des modèles décrits sur cette page, le comportement est indéfini.

Modèles de variables d'assistance

Implémentation possible

template<class T>
struct is_copy_constructible :
    std::is_constructible<T, typename std::add_lvalue_reference<
        typename std::add_const<T>::type>::type> {};
template<class T>
struct is_trivially_copy_constructible :
    std::is_trivially_constructible<T, typename std::add_lvalue_reference<
        typename std::add_const<T>::type>::type> {};
template<class T>
struct is_nothrow_copy_constructible :
    std::is_nothrow_constructible<T, typename std::add_lvalue_reference<
        typename std::add_const<T>::type>::type> {};

Notes

Dans de nombreuses implémentations, is_nothrow_copy_constructible vérifie également si le destructeur lève des exceptions car il est effectivement noexcept ( T ( arg ) ) . La même chose s'applique à is_trivially_copy_constructible , qui, dans ces implémentations, exige également que le destructeur soit trivial : Bug GCC 51452 , Problème LWG 2116 .

Exemple

#include <string>
#include <type_traits>
struct S1
{
    std::string str; // le membre a un constructeur de copie non trivial
};
static_assert(std::is_copy_constructible_v<S1>);
static_assert(!std::is_trivially_copy_constructible_v<S1>);
struct S2
{
    int n;
    S2(const S2&) = default; // trivial et non-lançant
};
static_assert(std::is_trivially_copy_constructible_v<S2>);
static_assert(std::is_nothrow_copy_constructible_v<S2>);
struct S3
{
    S3(const S3&) = delete; // explicitement supprimé
};
static_assert(!std::is_copy_constructible_v<S3>);
struct S4
{
    S4(S4&) {}; // ne peut pas lier const, donc pas de constructeur de copie
};
static_assert(!std::is_copy_constructible_v<S4>);
int main() {}

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

Voir aussi