Vermeiden Sie, den gleichen Code im Kopierkonstruktor zu wiederholen und operator =

Question

In C++, wenn Klassen dynamisch zugeordnete Daten enthalten, ist es normalerweise sinnvoll, explizit den Kopierkonstruktor operator = und destructor zu definieren. Aber die Aktivität dieser speziellen Methoden überlappt sich. Genauer gesagt, operator = normalerweise zuerst etwas Zerstörung und dann macht es Coping ähnlich dem im Copy-Konstruktor.

Meine Frage ist, wie man dies am besten schreibt, ohne die gleichen Codezeilen zu wiederholen und ohne dass der Prozessor unnötige Arbeit verrichten muss (wie unnötiges Kopieren).

Ich habe normalerweise zwei helfende Methoden. Eine für den Bau und eine für die Zerstörung. Die erste wird sowohl von copy constructor als auch operator = aufgerufen. Die zweite wird von destructor und operator = verwendet. Hier

ist der Beispielcode:

template <class T> 
    class MyClass 
    { 
     private: 
     // Data members 
     int count; 
     T* data; // Some of them are dynamicly allocated 
     void construct(const MyClass& myClass) 
     { 
      // Code which does deep copy 
      this->count = myClass.count; 
      data = new T[count]; 
      try 
      { 
       for (int i = 0; i < count; i++) 
        data[i] = myClass.data[i]; 
      } 
      catch (...) 
      { 
       delete[] data; 
       throw; 
      } 
     } 
     void destruct() 
     { 
      // Dealocate all dynamicly allocated data members 
      delete[] data; 
     } 
     public: MyClass(int count) : count(count) 
     { 
      data = new T[count]; 
     } 
     MyClass(const MyClass& myClass) 
     { 
      construct(myClass); 
     } 
     MyClass& operator = (const MyClass& myClass) 
     { 
      if (this != &myClass) 
      { 
       destruct(); 
       construct(myClass); 
      } 
      return *this; 
     } 
     ~MyClass() 
     { 
      destruct(); 
     } 
    }; 

Ist das auch richtig? Und ist es eine gute Angewohnheit, den Code auf diese Weise zu teilen?

Answer 1

Implementieren Sie die Zuweisung, indem Sie zuerst die rechte Seite kopieren und dann mit ihr tauschen. Auf diese Weise erhalten Sie auch Ausnahmesicherheit, die Ihr Code oben nicht zur Verfügung stellt. Sie könnten mit einem beschädigten Container enden, wenn construct() fehlschlägt, nachdem destruct() erfolgreich ausgeführt wurde, weil der Memberzeiger auf einige nicht zugeordnete Daten verweist und auf die Destruction, die wieder freigegeben wird, was zu undefiniertem Verhalten führt.

Answer 2

Ich sehe kein inhärentes Problem damit, solange Sie sicherstellen, nicht zu konstruieren oder zu destruieren virtuell.

Sie könnten Interesse an Kapitel 2 in Effektiv C++ (Scott Meyers), die vollständig auf Konstruktoren, Kopieroperatoren und Destruktoren gewidmet ist.

Für Ausnahmen, die Ihr Code nicht so behandelt, wie es sollte, beachten Sie Artikel 10 & 11 in effektiver C++ (Scott Meyers).

Answer 3

Ein erster Kommentar: Die operator= tut nicht Start von zerstörenden, aber durch den Bau. Andernfalls wird das Objekt in einem ungültigen Zustand belassen, wenn die Konstruktion über eine Ausnahme beendet wird. Ihr Code ist deshalb falsch. (Beachten Sie, dass die Notwendigkeit für die Selbstzuordnung zu testen, ist in der Regel ein Zeichen dafür, dass der Zuweisungsoperator ist nicht korrekt.)

Die klassische Lösung für diese Handhabung ist das Swap-Idiom: Sie eine Memberfunktion Swap hinzufügen:

void MyClass:swap(MyClass& other) 
{ 
    std::swap(count, other.count); 
    std::swap(data, other.data); 
} 

die garantiert nicht zu werfen ist. (Hier ist es tauscht nur einen int und einen Zeiger, kann keiner von denen werfen.) Dann Sie den Zuweisungsoperator implementieren, wie:

MyClass& MyClass<T>::operator=(MyClass const& other) 
{ 
    MyClass tmp(other); 
    swap(tmp); 
    return *this; 
} 

Das ist einfach und geradlinig, aber jede Lösung, in der alle Vorgänge, die fehlschlagen können, sind beendet, bevor Sie beginnen Ändern der Daten ist akzeptabel.Für einen einfachen Fall wie Ihr Code, zum Beispiel:

MyClass& MyClass<T>::operator=(MyClass const& other) 
{ 
    T* newData = cloneData(other.data, other.count); 
    delete data; 
    count = other.count; 
    data = newData; 
    return *this; 
} 

(wo cloneData ist Mitglied Funktion, die tut das meiste, was Ihre construct nicht, aber die Zeiger zurückgibt, und nichts in this ändern).

EDIT:

nicht direkt auf Ihre erste Frage, aber in der Regel, in solchen Fällen tun Sie nicht eine new T[count] in cloneData tun wollen (oder construct, oder was auch immer). Dies erstellt alle der T mit dem Standardkonstruktor und weist sie dann zu. Der idiomatische Weg, dies zu tun, ist so etwas wie:

T* 
MyClass<T>::cloneData(T const* other, int count) 
{ 
    // ATTENTION! the type is a lie, at least for the moment! 
    T* results = static_cast<T*>(operator new(count * sizeof(T))); 
    int i = 0; 
    try { 
     while (i != count) { 
      new (results + i) T(other[i]); 
      ++ i; 
     } 
    } catch (...) { 
     while (i != 0) { 
      -- i; 
      results[i].~T(); 
     } 
     throw; 
    } 
    return results; 
} 

oft meisten wird dieser Manager mit einem separaten (privat) erfolgen Klasse:

// Inside MyClass, private: 
struct Data 
{ 
    T* data; 
    int count; 
    Data(int count) 
     : data(static_cast<T*>(operator new(count * sizeof(T))) 
     , count(0) 
    { 
    } 
    ~Data() 
    { 
     while (count != 0) { 
      -- count; 
      (data + count)->~T(); 
     } 
    } 
    void swap(Data& other) 
    { 
     std::swap(data, other.data); 
     std::swap(count, other.count); 
    } 
}; 
Data data; 

// Copy constructor 
MyClass(MyClass const& other) 
    : data(other.data.count) 
{ 
    while (data.count != other.data.count) { 
     new (data.data + data.count) T(other.date[data.count]); 
     ++ data.count; 
    } 
} 

(und natürlich das Swap-Idiom für die Zuordnung). Dies ermöglicht mehrere Anzahl/Datenpaare ohne das Risiko, die Ausnahme Sicherheit zu verlieren.