Überladen = Operator in C++, wenn Arrays von Werten zu kopieren sind

Question

Ich bin etwas neu in C++ also, ich denke, das ist eine sehr grundlegende Frage.

Angenommen, ich habe diese Klasse:

// file Graph.h 
class Graph { 
public: 
    Graph(int N); // contructor 
    ~Graph();  // destructor 
    Graph& operator=(Graph other); 
private: 
    int * M; 
    int N; 
}; 

// file Graph.cpp 
Graph :: Graph(int size) { 
    M = new int [size]; 
    N = size; 
} 

Graph :: ~Graph() { 
    delete [] M; 
} 

Ich möchte einen Zuweisungsoperator erstellen, die der Inhalt von Array kopiert M [] aber , es nicht zu überschreiben, wenn ich es nach der Kopie ändern (Ich denke, das wird erreicht, indem man den eigentlichen Zeiger nicht kopiert, sondern nur den Inhalt, weiß nicht, ob ich recht habe). Das habe ich ausprobiert:

Graph& Graph::operator=(Graph other) { 
    int i; 
    N = other.N; 
    M = new int [N]; 
    for (i = 0; i < N; i++) 
    M[i] = other.M[i]; 
    return *this; 
} 

Ist das korrekt? Gibt es andere Möglichkeiten, dies zu tun?

edit: Eine wichtige Frage, die ich vergessen habe. Warum muss ich es wie Graph& operator=(Graph other); deklarieren und nicht nur: Graph operator=(Graph other); was ist in meinem Buch (C++: The Complete Reference, 2. Auflage, Herbert Schildt, Seiten 355-357) geschrieben?

Answer 1

Der kanonische Weg besteht darin, eine std::vector<int> zu verwenden, um die Speicherverwaltung selbst zu vermeiden. obwohl für die Ausübung der richtige Weg zu tun, was Sie wollen, ist:

#include <algorithm> 

class Graph 
{ 
public:  
    Graph(size_t n) { data_ = new int[n](); size_ = n; } 

    Graph(Graph const& g) 
    { 
     data_ = new int(g.size_); 
     size_ = g.size_; 
     std::copy(g.data_, g.data_ + g.size_, data_); 
    } 

    ~Graph() { delete[] data_; } 

    void swap(Graph& g) throw() 
    { 
     std::swap(data_, g.data_); 
     std::swap(size_, g.size_); 
    } 

    Graph& operator=(Graph g) { g.swap(*this); return *this; } 

private: 
    int* data_; 
    size_t size_; 
}; 

Google „Kopie und Swap-Idiom“ für die Logik hinter dem Code. Beachten Sie, dass Ihr Zuweisungsoperator Speicher verliert (das ursprüngliche Array wird überschrieben, aber nie gelöscht). Wenn die Zuweisung fehlschlägt, liegt ein fehlerhaftes Objekt vor. Darüber hinaus wird x = x nicht tun, was es zu tun ist. Diese drei Fallstricke sind üblich, und Schreibzuweisungsoperatoren im Copy-and-Swap-Stil vermeiden sie.

BEARBEITEN: Für Ihre andere Frage ermöglicht die Rückgabe einer Referenz die Zuordnung von Zuordnungen, wie a = b = c, die für integrierte Typen gültig ist. Es kann oder kann nicht sein, was Sie wollen (ist es normalerweise).

Answer 2

könnten Sie auch std :: mehr hier kopieren std::copy

oder können Sie memcpy Arrays sowie

Answer 3

Sie würden wahrscheinlich wollen einen Kopierkonstruktor erklären und zu definieren.

In der Tat ist es ein Muss in Ihrer Situation, weil der Standard-Kopierkonstruktor bei der Zerstörung zu einem doppelten delete führen wird.

Ich denke, es ist idiomatischer, den Kopierkonstruktor im Zuweisungsoperator zu verwenden (ein Kopieraufbau gefolgt von einem Austausch).

Wie für den aktuellen Code gibt es ein Speicherleck (weil das alte M ist nicht delete d).

Answer 4

Vergessen Sie nicht, dass es zulässig ist zu schreiben graph_a = graph_a; Ihr Code wird den Speicher verlieren, der ursprünglich für graph_a.M reserviert wurde, und Sie werden mit nicht initialisiertem Speicher in M nach der Kopie enden.

Bevor Sie eine Kopie-Zuordnung zu tun, müssen Sie prüfen, ob Sie das gleiche Objekt über sich selbst nicht zu kopieren (in dem Fall, dass Sie nur zurückgeben kann).

Answer 5

Sie benötigen die & in operator=, so dass es keine Kopie verursacht, wenn Sie *this zurückgeben. Die wichtigere Frage ist, warum Sie etwas zurückgeben müssen. Die Antwort ist a=b=c Syntax zu unterstützen.

Ich würde vorschlagen, Sie Memcpy für Standard-Arrays von Einbau-int-ähnlichen Typen (oder Zeiger). Der Standard definiert es so, dass der Compiler-Writer eine Möglichkeit hat, die schnellstmögliche plattformspezifische Implementierung bereitzustellen.

Verwenden Memcpy nicht, wenn der Typ ein Objekt (wird nicht Copykonstruktor anrufen und viele andere schlechte Dinge)

Answer 6

Sie einen Verweis auf das Objekt zurückgeben müssen, die Sie aufgebaut haben. Wenn Sie eine Kopie zurückgegeben, würden Sie dann weiter kopieren ein anderes Objekt zu konstruieren, die ein Verwerfen, die Sie bereits haben.

Answer 7

fast alle haben gesagt worden, aber es gibt ein paar wichtige Hinweise:

• ist es ratsam, die Parameter zu übergeben Konstruktor und Zuweisungsoperator als const Referenz, dh const Graph& other, kopieren schwere Kopieren zu vermeiden in ein temporären Objekt (es sei denn Du ein "copy and swap" idiom
• , wenn man sie privat Zeiger als Klasse Mitglied Sie muss (na ja, solltest in den meisten Fällen) bietet sowohl Kopie ctor und Zuweisungsoperator, oder deaktivieren, indem sie verwendet verwenden Ansonsten werden die Standardeinstellungen verwendet ein Leck verursachen.
• schließlich, warum nicht std::vector verwenden? Sie sparen all diese Probleme ohne spürbare Leistungseinbußen.

kann diese Seite hilfreich sein - einfach und umfassend: C++ Operator Overloading Guidelines

Answer 8

haben einige davon bereits von anderen gesagt worden, aber wenn wir mit den grundlegenden Layout bleiben möchten, dass Sie haben, sollten Sie dies ändern:

• Fabrikat „Graph andere“ konstante -> „const Graph andere“ (Gutes zu tun, so dass Sie ‚versehentlich‘ ändern dont die Daten in „anderen“)
• Haben Sie einen Scheck auf „andere“ zu Beachten Sie, dass es sich nicht um das gleiche Objekt wie das Objekt handelt, dem Sie zuweisen (der L-Wert). Kann dies tun, wenn Aussage ein einfaches, indem sie -> if (dies == & andere)
• den Speicher M. Löschen (Wir wollen don Speicherlecks :))

btw Oh. müssen Sie nicht auf C-Syntax von "i" in der Start der Funktion erklärt wird -> "for (int i = ...."

Hope it :) half