Warum kein Standard-move-assignment / move-constructor?

Ich bin ein einfacher Programmierer. Meine Klasse member-Variablen am häufigsten besteht der POD-Typen und STL-Containern. Da ich nur selten schreiben Zuweisungsoperatoren oder copy-Konstruktoren, da diese standardmäßig implementiert.

Hinzu, wenn ich std::move auf Objekte, nicht beweglich, es verwendet den Zuweisungsoperator, d.h. std::move ist absolut sicher.

So, ich bin ein einfacher Programmierer, würde ich mag, um die Vorteile der move-Funktionen, ohne einen move-Konstruktor/Zuweisungsoperator für jede Klasse I schreiben, da der compiler könnte einfach umsetzen Sie als "this->member1_ = std::move(other.member1_);..."

Aber nicht (zumindest nicht in Visual 2010), gibt es einen bestimmten Grund dafür?

Wichtiger; gibt es eine Möglichkeit dies zu umgehen?

Update:
Wenn Sie schauen nach GManNickG Antwort, er bietet ein tolles makro. Und wenn Sie nicht wissen, wenn Sie implementieren move-Semantik können Sie entfernen Sie die swap Memberfunktion.

InformationsquelleAutor der Frage Viktor Sehr | 2011-01-27

c++c++11 move-semantics pod

73

Die implizite Generierung von move-Konstruktoren und Zuweisungsoperatoren wurde strittig, und es wurden wichtige änderungen in den letzten Entwürfe der C++ - Standard, so dass aktuell verfügbare Compiler wird wahrscheinlich anders Verhalten mit Bezug auf implizite generation.

Mehr über die Geschichte des Problems finden 2010 WG21 Papiere Liste und die Suche nach "mov"

Der aktuellen Spezifikation (N3225, ab November) Staaten (N3225 12.8/8):
Wenn die definition einer Klasse X nicht ausdrücklich erklärt, eine move-Konstruktor wird implizit deklariert als ausgefallen, wenn, und nur wenn
- X keinen user-deklarierten Kopier-Konstruktor, und
- X keinen user-deklarierten Kopier Zuweisungsoperator,
- X keinen user-deklarierten move-Zuweisungs-operator,
- X keinen user-deklarierten Destruktor und
- den move-Konstruktor würde nicht implizit definiert als gelöscht.
Gibt es ähnliche Sprache, in 12,8/22, der angibt, Wann der move-Zuweisungs-operator implizit deklariert als ausgefallen. Finden Sie die vollständige Liste von änderungen zu unterstützen, die aktuelle Spezifikation der impliziten move-generation in N3203: Verschärfung der Bedingungen für die Generierung impliziten bewegt
die sich weitgehend auf eine von der beschlussvorschläge von Bjarne Stroustrup ' s Papier N3201: Moving rechts entlang.

InformationsquelleAutor der Antwort James McNellis
12

Implizit generiert move-Konstruktoren wurden als für den standard, kann aber gefährlich sein. Siehe Dave Abrahams ist Analyse.

In das Ende, jedoch der standard Tat auch implizite Generierung von move-Konstruktoren und move-Zuweisungsoperatoren, allerdings mit einer ziemlich umfangreiche Liste von Einschränkungen:

Wenn die definition einer Klasse X nicht explizit deklarieren Sie eine move-Konstruktor wird implizit deklariert als ausgefallen, wenn und nur, wenn

— X keinen user-deklarierten Kopier-Konstruktor,

— X keinen user-deklarierten Kopier Zuweisungsoperator

— X keinen user-deklarierten move-Zuweisungs-operator,

— X keinen user-deklarierten Destruktor und

— der move-Konstruktor würde nicht implizit definiert als gelöscht.

Dass nicht ganz alle, es ist die Geschichte aber. Ein ctor, erklärt werden kann, aber immer noch definiert als gelöscht:

Eine implizit deklarierte copy/move-Konstruktor ist ein inline-öffentliche Mitglied seiner Klasse. Ein Verzug der copy/move-Konstruktor für eine Klasse X ist definiert als gelöscht (8.4.3) wenn X:

— Variante-Mitglied mit einem nicht-trivialen entsprechenden Konstruktor und X ist ein union-wie Klasse,

— ein nicht-statisches Datenelement der Klasse, Typ M (oder ein array davon), können nicht kopiert/verschoben werden, weil überlast Auflösung (13.3), angewandt auf M den entsprechenden Konstruktor, resultiert eine Mehrdeutigkeit oder eine Funktion, die gelöscht oder unzugänglich sind von der ausgefallenen Konstruktor

— eine direkte oder virtuelle Basisklasse B, können nicht kopiert/verschoben werden, weil überlast Auflösung (13.3), angewandt auf B den zugehörigen Konstruktor, resultiert eine Mehrdeutigkeit oder eine Funktion, die gelöscht oder unzugänglich sind von der ausgefallenen Konstruktor

— jede direkte oder virtuelle Basisklasse oder nicht-statischen Daten-member eines Typs mit einem Destruktor, die gelöscht oder unzugänglich sind von der ausgefallenen Konstruktor

— für den copy-Konstruktor, einen nicht-statischen Daten-member von rvalue-Referenz-Typ oder

— für die move-Konstruktor, einen nicht-statischen Daten-member oder der direkten oder virtuellen Basis-Klasse mit einem Typ, der nicht über einen move-Konstruktor, und ist nicht-trivial kopierbar.

InformationsquelleAutor der Antwort Jerry Coffin

(wie jetzt, ich bin auf eine blöde makro...)

Yeah, ich ging diesen Weg auch. Hier ist das makro:

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

(Ich habe entfernt die wirkliche Kommentare, die Länge und Dokumentarfilm.)

Geben Sie die Basen und/oder Mitglieder in Ihrer Klasse als ein Präprozessor-Liste, zum Beispiel:

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

Und heraus kommt ein move-Konstruktor und move-Zuweisungs-operator.

(Nebenbei, wenn jemand weiß wie ich die kombinieren könnte, die details in einem makro, das wäre Dünung.)

InformationsquelleAutor der Antwort

4

VS2010 nicht tun es, weil Sie nicht Standard bei der Umsetzung.

InformationsquelleAutor der Antwort Puppy

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.