Move-Konstruktoren und Statische Arrays

Ich habe die Möglichkeiten der Bewegen Konstruktoren in C++, und ich Frage mich, was sind einige Möglichkeiten der Einnahme von Vorteil, diese Funktion an einem Beispiel, wie unten. Betrachten Sie diesen code:

template<unsigned int N>
class Foo {
public:
    Foo() {
        for (int i = 0; i < N; ++i) _nums[i] = 0;
    }

    Foo(const Foo<N>& other) {
        for (int i = 0; i < N; ++i) _nums[i] = other._nums[i];
    }

    Foo(Foo<N>&& other) {
        //??? How can we take advantage of move constructors here?
    }

    //... other methods and members

    virtual ~Foo() { /* no action required */ }

private:
    int _nums[N];
};

Foo<5> bar() {
    Foo<5> result;
    //Do stuff with 'result'
    return result;
}

int main() {
    Foo<5> foo(bar());
    //...
    return 0;
}

In diesem obigen Beispiel, wenn wir verfolgen das Programm (mit MSVC++ 2011), sehen wir, dass Foo<N>::Foo(Foo<N>&&) aufgerufen wird, wenn der Bau foo, die das gewünschte Verhalten. Allerdings, wenn wir nicht Foo<N>::Foo(Foo<N>&&), Foo<N>::Foo(const Foo<N>&) aufgerufen werden würde, statt, das würde eine redundante Kopie Betrieb.

Meine Frage ist nun, wie bereits im code, die mit diesem spezifischen Beispiel welches mit einem statisch zugewiesenen einfaches array, gibt es eine Möglichkeit zu nutzen die move-Konstruktor, um dies zu vermeiden, wird die redundante Kopie?

InformationsquelleAutor Zeenobit | 2011-10-25
  1. 22

    First off, es ist eine Allgemeine Art von Beratung, die sagt, man sollte nicht schreiben, copy/move-Konstruktor, Zuweisungsoperator oder Destruktor an, wenn Sie ihm helfen kann, und eher verfassen deine Klasse von hochwertigen Komponenten, die wiederum diese, so dass die Standard-Funktionen generiert, Das Richtige zu Tun. (Die umgekehrte Implikation ist, dass, wenn Sie haben, schreiben Sie einer von denen, die Sie haben wahrscheinlich schreiben alle von Ihnen).

    Also die Frage läuft darauf hinaus, "die einzigen Verantwortung Komponente Klasse können die Vorteile der move-Semantik?" Die Allgemeine Antwort ist: Alles, was die Verwaltung einer Ressource. Der Punkt ist, dass der move-Konstruktor/zuordner wird nur setzen Sie die Ressource, die zu der neuen Sache und Verfall der alten, so dass die (vermutete teuer oder unmöglich) neue Aufteilung und Tiefe kopieren der Ressource.

    Das Paradebeispiel ist alles, was dynamischen Speicher verwaltet, wo Sie den Verschiebevorgang einfach Kopien der Zeiger und setzt die alte Objekt den Zeiger auf null (also die alten Objekts Destruktor nichts macht). Hier ist ein naives Beispiel:

    class MySpace
{
  void * addr;
  std::size_t len;

public:
  explicit MySpace(std::size_t n) : addr(::operator new(n)), len(n) { }

  ~MySpace() { ::operator delete(addr); }

  MySpace(const MySpace & rhs) : addr(::operator new(rhs.len)), len(rhs.len)
  { /* copy memory */ }

  MySpace(MySpace && rhs) : addr(rhs.addr), len(rhs.len)
  { rhs.len = 0; rhs.addr = 0; }

  //ditto for assignment
};

    Der Schlüssel ist, dass jede Kopie/move-Konstruktor wird eine vollständige kopieren der member-Variablen; es ist nur, wenn diese Variablen sind in sich selbst behandelt oder Verweise auf Ressourcen, die Sie vermeiden können, kopieren Sie die Ressource, wegen der Vereinbarung, die einem bewegten Objekt ist nicht mehr gültig und du bist frei, um es stehlen. Wenn es nichts zu stehlen, dann gibt es keinen Vorteil in der Bewegung.

    • Tolle Tipps. Vielen Dank für die Antwort!
    • Es kann sein, erwähnenswert, dass der compiler generiert move - Konstruktor/Zuordnung unter gewissen Umständen (fehlen von copy/move-Konstruktor/Zuweisung und Destruktor, zusammen mit ein paar anderen Einschränkungen), und in diesen Fällen, wenn der Typ bewegliche dann den implizit definierten move-Konstruktor wird move jeweils eine der enthaltenen Elemente.
    • Recht. Was ich meinte im letzten Absatz ist, dass der eigentliche Daten-member-Variablen werden immer physisch kopiert werden, egal ob die operation semantisch kopieren oder verschieben, und so, wenn es letztlich ist keine Ressource management, dann gibt es keinen Vorteil zu verschieben. So... Lesen Sie den letzten Absatz rekursiv, nehme ich an 🙂
    • Ich denke auch, es ist erwähnenswert, dass dies über move-Konstruktoren in Bezug auf die copy-Konstruktoren oder in anderen Worten mit move-Semantik als eine Optimierung des Kopierens. Eine Art, für die das kopieren nicht sinnvoll semantisch sprechen können, machen Sie gute Verwendung von ein move-Konstruktor zu erlauben, z.B. die Rückgabe von Funktionen, unabhängig davon, ob das move-Konstruktor muss setzen Sie eine Ressource oder machen Sie schlicht zu kopieren. Dies ist die Art von Sache, die Sie geht, ohne zu sagen, aber ich würde eher sagen, dass es trotzdem in den Kommentaren für Klarheit 🙂
    • Ja, natürlich, danke. Ich habe irgendwie schlich sich dieser in der Klausel "teuer oder gar nicht": wenn etwas nicht kopiert, sondern verschoben werden kann, dann zähle ich es als "Ressource" (zum Beispiel, wie Sie einen mutex). Aber wie du sagst, Beweglichkeit ist ein etwas spezielles Konzept angesehen werden kann, in seinem eigenen Recht.
    InformationsquelleAutor Kerrek SB
  2. 8

    In diesem Fall ist es nicht nützlich ist, weil int hat keine move-Konstruktoren.

    Jedoch, es könnte nützlich sein, wenn diejenigen, die waren Zeichenketten statt, zum Beispiel:

    template<unsigned int N>
class Foo {
public:
    //[snip]

    Foo(Foo<N>&& other) {
        //move each element from other._nums to _nums
        std::move(std::begin(other._nums), std::end(other._nums), &_nums[0]);
    }

    //[snip]

private:
    std::string _nums[N];
};

    Nun vermeiden Sie das kopieren von strings, wo eine Bewegung zu tun. Ich bin mir nicht sicher, ob ein konformer C++11 compiler generiert entsprechenden code, wenn du weglassen, alle die kopieren-/verschieben-Konstruktoren komplett, sorry.

    (In anderen Worten, ich bin nicht sicher, ob std::move ist speziell definiert, um ein element-Weise für arrays.)

    • Ich sehe. Also, wenn meine eigentliche Inhalt wurden Objekte umgesetzt, dass die move-Semantik, es könnte nützlich sein. Danke. Ich sehe, wie das funktionieren würde.
    • Was, wenn der Typ keine default-Konstruktor? Dann, die oben nicht kompilieren (da _nums nicht berührt, die in der Initialisierungsliste).
    • Dann initialisieren. 🙂
    InformationsquelleAutor GManNickG
  3. 7

    Für die Klasse Vorlage, die Sie schrieb, es gibt keinen Vorteil zu nehmen, in der ein move-Konstruktor.

    Wäre es von Vorteil, wenn das Mitglied-array wurde dynamisch zugewiesen. Aber mit einem einfachen array als member, es gibt nichts zu optimieren, können Sie nur kopieren die Werte. Es gibt keinen Weg, um bewegen Sie.

    InformationsquelleAutor Didier Trosset
  4. 2

    In der Regel, bewegen-semantische implementiert, wenn die Klasse verwaltet Ressource. Da in Ihrem Fall die Klasse nicht verwaltet Ressource, die move-semantic wäre mehr wie copy-semantische, da gibt es nichts zu verschoben.

    Besser zu verstehen, wenn move-semantic notwendig wird, sollten Sie _nums einen pointer statt einem array:

    template<unsigned int N>
class Foo {
public:
    Foo() 
    {
        _nums = new int[N](); //allocate and zeo-initialized
    }
    Foo(const Foo<N>& other) 
    {
        _nums = new int[N];
        for (int i = 0; i < N; ++i) _nums[i] = other._nums[i];
    }

    Foo(Foo<N>&& other) 
    {
         _nums = other._nums; //move the resource
         other._nums=0; //make it null
    }

    Foo<N> operator=(const Foo<N> & other); //implement it!

    virtual ~Foo() { delete [] _nums; }

private:
    int *_nums;
};
    • Wenn ich eine ähnliche Sache in meinem Projekt habe ich erlebt, eine massive Verlangsamung (bis zu 3 mal langsamer) Wandel, von der ein array zu einem Zeiger. Ich war in der Lage zu implementieren move-Semantik, aber es hat nicht make-up für den Unterschied.
    • also irgendwie ist das statische array-version, C++ und OS verwaltet den Speicher effizienter als die dynamische version. Gut, Sie haben diese getestet. Ich habe mich immer schon gefragt, die Verwendung von statischen Arrays oder die dynamische Zuordnung für kleine Arrays.
    InformationsquelleAutor Nawaz
Schreibe einen Kommentar