Pourquoi aucun constructeur de déplacement / affectation de déplacement par défaut?

Je suis un simple programmeur. Les variables de mes membres de classe se composent le plus souvent de types POD et de conteneurs STL. Pour cette raison, je dois rarement écrire des opérateurs d'affectation ou copier des constructeurs, car ils sont implémentés par défaut.

Ajoutez à cela, si j'utilise std::movesur des objets non mobiles, il utilise l'opérateur d'affectation, ce qui signifie qu'il std::moveest parfaitement sûr.

Comme je suis un simple programmeur, j'aimerais profiter des capacités de déplacement sans ajouter un constructeur de déplacement / opérateur d'assignation à chaque classe que j'écris, car le compilateur pourrait simplement les implémenter comme " this->member1_ = std::move(other.member1_);..."

Mais ce n'est pas le cas (du moins pas dans Visual 2010), y a-t-il une raison particulière à cela?

Plus important; y a-t-il un moyen de contourner cela?

Mise à jour: Si vous regardez la réponse de GManNickG, il fournit une excellente macro pour cela. Et si vous ne le saviez pas, si vous implémentez la sémantique de déplacement, vous pouvez supprimer la fonction membre d'échange.

La génération implicite de constructeurs de déplacement et d'opérateurs d'affectation a été controversée et il y a eu des révisions majeures dans les versions récentes de la norme C ++, de sorte que les compilateurs actuellement disponibles se comporteront probablement différemment en ce qui concerne la génération implicite.

Pour en savoir plus sur l'historique du problème, consultez la liste des articles du WG21 2010 et recherchez "mov"

La spécification actuelle (N3225, à partir de novembre) stipule (N3225 12.8 / 8):

Si la définition d'une classe Xne déclare pas explicitement un constructeur de déplacement, l'un sera implicitement déclaré comme étant par défaut si et seulement si

• X n'a pas de constructeur de copie déclaré par l'utilisateur, et

• X n'a pas d'opérateur d'affectation de copie déclaré par l'utilisateur,

• X n'a pas d'opérateur d'affectation de déplacement déclaré par l'utilisateur,

• X n'a pas de destructeur déclaré par l'utilisateur, et

• le constructeur de déplacement ne serait pas implicitement défini comme supprimé.

Il existe un langage similaire dans 12.8 / 22 spécifiant quand l'opérateur d'assignation de déplacement est implicitement déclaré comme étant par défaut. Vous pouvez trouver la liste complète des modifications apportées pour prendre en charge la spécification actuelle de la génération de mouvements implicites dans N3203: resserrer les conditions de génération de mouvements implicites , qui était largement basée sur l'une des résolutions proposées par l'article de Bjarne Stroustrup N3201: Moving right along .

Les constructeurs de déplacement générés implicitement ont été pris en compte pour la norme, mais peuvent être dangereux. Voir l' analyse de Dave Abrahams .

En fin de compte, cependant, la norme incluait la génération implicite de constructeurs de déplacement et d'opérateurs d'affectation de déplacement, bien qu'avec une liste assez importante de limitations:

Si la définition d'une classe X ne déclare pas explicitement un constructeur de déplacement, un sera implicitement déclaré comme étant par défaut si et seulement si
- X n'a ​​pas de constructeur de copie déclaré par l'utilisateur,
- X n'a ​​pas d'opérateur d'affectation de copie déclaré par l'utilisateur ,
- X n'a ​​pas d'opérateur d'affectation de déplacement déclaré par l'utilisateur,
- X n'a ​​pas de destructeur déclaré par l'utilisateur, et
- le constructeur de déplacement ne serait pas implicitement défini comme supprimé.

Ce n'est pas tout à fait tout ce qu'il y a dans l'histoire. Un ctor peut être déclaré, mais toujours défini comme supprimé:

Un constructeur de copie / déplacement déclaré implicitement est un membre public en ligne de sa classe. Un constructeur de copie / déplacement par défaut pour une classe X est défini comme supprimé (8.4.3) si X a:

- un membre variant avec un constructeur correspondant non trivial et X est une classe de type union,
- un membre de données non statique de type de classe M (ou un tableau de celui-ci) qui ne peut pas être copié / déplacé en raison de la résolution de surcharge (13.3), comme appliqué au constructeur correspondant de M, entraîne une ambiguïté ou une fonction qui est supprimée ou inaccessible du constructeur par défaut,
- une classe de base directe ou virtuelle B qui ne peut pas être copiée / déplacée car la résolution de surcharge (13.3), appliquée au constructeur correspondant de B , entraîne une ambiguïté ou une fonction qui est supprimée ou inaccessible du constructeur par défaut,
- toute classe de base directe ou virtuelle ou membre de données non statique d'un type avec un destructeur supprimé ou inaccessible du constructeur par défaut,
- pour le constructeur de copie, un membre de données non statique de type référence rvalue, ou
- pour le constructeur de déplacement, un membre de données non statique ou une classe de base directe ou virtuelle avec un type qui n'a pas de constructeur de déplacement et n'est pas trivialement copiable.

(pour l'instant, je travaille sur une macro stupide ...)

Ouais, j'ai aussi emprunté cette voie. Voici votre macro:

// detail/move_default.hpp
#ifndef UTILITY_DETAIL_MOVE_DEFAULT_HPP
#define UTILITY_DETAIL_MOVE_DEFAULT_HPP

#include <boost/preprocessor.hpp>

#define UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE(pR, pData, pBase) pBase(std::move(pOther))
#define UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE(pR, pData, pBase) pBase::operator=(std::move(pOther));

#define UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR(pR, pData, pMember) pMember(std::move(pOther.pMember))
#define UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT(pR, pData, pMember) pMember = std::move(pOther.pMember);

#define UTILITY_MOVE_DEFAULT_DETAIL(pT, pBases, pMembers)                                               \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE, BOOST_PP_EMPTY, pBases))                      \
        ,                                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR, BOOST_PP_EMPTY, pMembers))                         \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE, BOOST_PP_EMPTY, pBases)  \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT, BOOST_PP_EMPTY, pMembers)     \
                                                                                                        \
            return *this;                                                                               \
        }

#define UTILITY_MOVE_DEFAULT_BASES_DETAIL(pT, pBases)                                                   \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR_BASE, BOOST_PP_EMPTY, pBases))                      \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT_BASE, BOOST_PP_EMPTY, pBases)  \
                                                                                                        \
            return *this;                                                                               \
        }

#define UTILITY_MOVE_DEFAULT_MEMBERS_DETAIL(pT, pMembers)                                               \
        pT(pT&& pOther) :                                                                               \
        BOOST_PP_SEQ_ENUM(BOOST_PP_SEQ_TRANSFORM(                                                       \
            UTILITY_MOVE_DEFAULT_DETAIL_CONSTRUCTOR, BOOST_PP_EMPTY, pMembers))                         \
        {}                                                                                              \
                                                                                                        \
        pT& operator=(pT&& pOther)                                                                      \
        {                                                                                               \
            BOOST_PP_SEQ_FOR_EACH(UTILITY_MOVE_DEFAULT_DETAIL_ASSIGNMENT, BOOST_PP_EMPTY, pMembers)     \
                                                                                                        \
            return *this;                                                                               \
        }

#endif

​

// move_default.hpp
#ifndef UTILITY_MOVE_DEFAULT_HPP
#define UTILITY_MOVE_DEFAULT_HPP

#include "utility/detail/move_default.hpp"

// move bases and members
#define UTILITY_MOVE_DEFAULT(pT, pBases, pMembers) UTILITY_MOVE_DEFAULT_DETAIL(pT, pBases, pMembers)

// base only version
#define UTILITY_MOVE_DEFAULT_BASES(pT, pBases) UTILITY_MOVE_DEFAULT_BASES_DETAIL(pT, pBases)

// member only version
#define UTILITY_MOVE_DEFAULT_MEMBERS(pT, pMembers) UTILITY_MOVE_DEFAULT_MEMBERS_DETAIL(pT, pMembers)

#endif

(J'ai supprimé les vrais commentaires, qui sont longs et documentaires.)

Vous spécifiez les bases et / ou les membres de votre classe sous forme de liste de préprocesseurs, par exemple:

#include "move_default.hpp"

struct foo
{
    UTILITY_MOVE_DEFAULT_MEMBERS(foo, (x)(str));

    int x;
    std::string str;
};

struct bar : foo, baz
{
    UTILITY_MOVE_DEFAULT_BASES(bar, (foo)(baz));
};

struct baz : bar
{
    UTILITY_MOVE_DEFAULT(baz, (bar), (ptr));

    void* ptr;
};

Et en sort un constructeur de mouvement et un opérateur d'affectation de mouvement.

(En passant, si quelqu'un sait comment je pourrais combiner les détails en une seule macro, ce serait super.)

VS2010 ne le fait pas car ils n'étaient pas standard au moment de la mise en œuvre.