std:: is_move_constructible, std:: is_trivially_move_constructible, std:: is_nothrow_move_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 une 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 auxiliaires

Implémentation possible

template<class T>
struct is_move_constructible :
    std::is_constructible<T, typename std::add_rvalue_reference<T>::type> {};
template<class T>
struct is_trivially_move_constructible :
    std::is_trivially_constructible<T, typename std::add_rvalue_reference<T>::type> {};
template<class T>
struct is_nothrow_move_constructible :
    std::is_nothrow_constructible<T, typename std::add_rvalue_reference<T>::type> {};

Notes

Les types sans constructeur de déplacement, mais avec un constructeur de copie qui accepte const T & arguments, satisfont std::is_move_constructible .

Les constructeurs de déplacement sont généralement noexcept, car sinon ils sont inutilisables dans tout code qui fournit une garantie d'exception forte.

Dans de nombreuses implémentations, std::is_nothrow_move_constructible vérifie également si le destructeur lève des exceptions car il est effectivement noexcept ( T ( arg ) ) . La même chose s'applique à std::is_trivially_move_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 Ex1
{
    std::string str; // le membre a un constructeur de déplacement non trivial mais non lançant d'exception
};
static_assert(std::is_move_constructible_v<Ex1>);
static_assert(!std::is_trivially_move_constructible_v<Ex1>);
static_assert(std::is_nothrow_move_constructible_v<Ex1>);
struct Ex2
{
    int n;
    Ex2(Ex2&&) = default; // trivial et non lançant d'exception
};
static_assert(std::is_move_constructible_v<Ex2>);
static_assert(std::is_trivially_move_constructible_v<Ex2>);
static_assert(std::is_nothrow_move_constructible_v<Ex2>);
struct NoMove1
{
    // empêche la déclaration implicite du constructeur de déplacement par défaut ;
    // cependant, la classe reste déplaçable car son
    // constructeur de copie peut lier un argument rvalue
    NoMove1(const NoMove1&) {}
};
static_assert(std::is_move_constructible_v<NoMove1>);
static_assert(!std::is_trivially_move_constructible_v<NoMove1>);
static_assert(!std::is_nothrow_move_constructible_v<NoMove1>);
struct NoMove2
{
    // Non déplaçable car la référence lvalue
    // ne peut pas lier l'argument rvalue
    NoMove2(NoMove2&) {}
};
static_assert(!std::is_move_constructible_v<NoMove2>);
static_assert(!std::is_trivially_move_constructible_v<NoMove2>);
static_assert(!std::is_nothrow_move_constructible_v<NoMove2>);
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