Dlaczego nie ma domyślnego move-assignment/move-constructor?

Domyślnie generowane konstruktory ruchu były brane pod uwagę dla standardu, ale mogą być niebezpieczne. Zobacz analizę Dave ' a Abrahamsa .

W końcu jednak standard zawierał Ukryte generowanie konstruktorów ruchu i operatorów przydziału ruchu, choć z dość dużą listą ograniczeń:

Jeśli definicja klasy X nie deklaruje jawnie konstruktora move, zostanie ona domyślnie zadeklarowana jako defaulted wtedy i tylko wtedy, gdy
- X nie posiada deklarowanego przez użytkownika konstruktora kopiującego,
- X nie posiada zadeklarowanego przez użytkownika operatora przypisywania kopii,
- X nie posiada zadeklarowanego przez użytkownika operatora przypisania ruchu,
- X nie posiada destruktora zadeklarowanego przez użytkownika i
- konstruktor move nie będzie domyślnie zdefiniowany jako usunięty.

To jednak nie wszystko. Ctor może być zadeklarowany, ale nadal zdefiniowany jako usunięty:

Domyślnie zadeklarowana Kopia/ruch constructor jest inline publicznym członkiem swojej klasy. Domyślny konstruktor kopiowania/przenoszenia dla klasy X jest zdefiniowany jako usunięty (8.4.3), jeśli X ma:

- element wariantowy z nietrywialnym odpowiednikiem konstruktora i X jest klasą podobną do Unii,
- niestatyczny element danych klasy typu M (lub ich tablica), który nie może być kopiowany / przenoszony, ponieważ rozdzielczość przeciążenia (13.3), zastosowana do odpowiedniego konstruktora m, powoduje niejednoznaczność lub funkcję, która jest usuwana lub niedostępna od domyślnego konstruktora,
- bezpośrednia lub wirtualna klasa bazowa B, której nie można skopiować/przenieść, ponieważ rozdzielczość przeciążenia (13.3), zastosowana do odpowiedniego konstruktora B, powoduje niejednoznaczność lub funkcję, która jest usuwana lub niedostępna z domyślnego konstruktora,
- Dowolna bezpośrednia lub wirtualna klasa bazowa lub niestatyczny element danych typu z destruktorem, który jest usuwany lub Niedostępny z domyślnego konstruktora,
- dla konstruktora kopiującego dane niestatyczne członek typu referencyjnego rvalue, lub
- dla konstruktora move, niestatyczny element danych lub bezpośrednia lub wirtualna klasa bazowa z typem, który nie ma konstruktora move i nie jest trywialnie kopiowalny.

(Jak na razie pracuję nad głupim makrem...)

// 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

(usunąłem prawdziwe komentarze, które są długie i dokumentalne.)

Określasz bazy i/lub członków w swojej klasie jako listę preprocesorów, na przykład:

#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;
};

I wychodzi konstruktor ruchu i operator przypisania ruchu.

(na marginesie, jeśli ktoś wie, jak Mogę połączyć szczegóły w jeden makro, byłoby super.)

VS2010 tego nie robi, ponieważ nie były standardowe w momencie implementacji.