Einführung
C ++ behandelt Variablen benutzerdefinierter Typen mit Wertsemantik . Dies bedeutet, dass Objekte implizit in verschiedenen Kontexten kopiert werden, und wir sollten verstehen, was "Kopieren eines Objekts" tatsächlich bedeutet.
Betrachten wir ein einfaches Beispiel:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age) : name(name), age(age)
{
}
};
int main()
{
person a("Bjarne Stroustrup", 60);
person b(a); // What happens here?
b = a; // And here?
}
(Wenn Sie von dem name(name), age(age)Teil verwirrt sind , wird dies als Mitgliederinitialisierungsliste bezeichnet .)
Spezielle Mitgliedsfunktionen
Was bedeutet es, ein personObjekt zu kopieren ? Die mainFunktion zeigt zwei unterschiedliche Kopierszenarien. Die Initialisierung person b(a);wird vom Kopierkonstruktor durchgeführt . Seine Aufgabe ist es, ein neues Objekt basierend auf dem Status eines vorhandenen Objekts zu erstellen. Die Zuordnung b = awird vom Kopierzuweisungsoperator ausgeführt . Die Aufgabe ist im Allgemeinen etwas komplizierter, da sich das Zielobjekt bereits in einem gültigen Zustand befindet, der behandelt werden muss.
Da wir weder den Kopierkonstruktor noch den Zuweisungsoperator (noch den Destruktor) selbst deklariert haben, sind diese implizit für uns definiert. Zitat aus dem Standard:
Der [...] Kopierkonstruktor und der Kopierzuweisungsoperator, [...] und der Destruktor sind spezielle Elementfunktionen. [ Hinweis : Die Implementierung deklariert diese Elementfunktionen implizit für einige Klassentypen, wenn das Programm sie nicht explizit deklariert.
Die Implementierung definiert sie implizit, wenn sie verwendet werden. [...] Endnote ] [n3126.pdf Abschnitt 12 § 1]
Standardmäßig bedeutet das Kopieren eines Objekts das Kopieren seiner Mitglieder:
Der implizit definierte Kopierkonstruktor für eine Nicht-Union-Klasse X führt eine Mitgliedskopie ihrer Unterobjekte durch. [n3126.pdf Abschnitt 12.8 §16]
Der implizit definierte Kopierzuweisungsoperator für eine Nicht-Gewerkschaftsklasse X führt eine kopierweise Zuweisung ihrer Unterobjekte durch. [n3126.pdf Abschnitt 12.8 §30]
Implizite Definitionen
Die implizit definierten speziellen Elementfunktionen für personsehen folgendermaßen aus:
// 1. copy constructor
person(const person& that) : name(that.name), age(that.age)
{
}
// 2. copy assignment operator
person& operator=(const person& that)
{
name = that.name;
age = that.age;
return *this;
}
// 3. destructor
~person()
{
}
Das kopieren von Mitgliedern ist genau das, was wir in diesem Fall wollen:
nameund agewerden kopiert, sodass wir ein in sich geschlossenes, unabhängiges personObjekt erhalten. Der implizit definierte Destruktor ist immer leer. Dies ist auch in diesem Fall in Ordnung, da wir im Konstruktor keine Ressourcen erworben haben. Die Destruktoren der Mitglieder werden implizit aufgerufen, nachdem der personDestruktor fertig ist:
Nach dem Ausführen des Körpers des Destruktors und dem Zerstören aller im Körper zugewiesenen automatischen Objekte ruft ein Destruktor für Klasse X die Destruktoren für die direkten [...] Mitglieder von X auf [n3126.pdf 12.4 §6].
Ressourcen verwalten
Wann sollten wir diese speziellen Mitgliedsfunktionen explizit deklarieren? Wenn unsere Klasse verwaltet eine Ressource , das heißt, wenn ein Objekt der Klasse ist verantwortlich für diese Ressource. Das bedeutet in der Regel die Ressource erworben im Konstruktor (oder in den Konstruktor übergibt) und freigegeben im destructor.
Lassen Sie uns in der Zeit zurück zu C ++ gehen. Es gab keine std::stringund Programmierer waren in Zeiger verliebt. Die personKlasse könnte so ausgesehen haben:
class person
{
char* name;
int age;
public:
// the constructor acquires a resource:
// in this case, dynamic memory obtained via new[]
person(const char* the_name, int the_age)
{
name = new char[strlen(the_name) + 1];
strcpy(name, the_name);
age = the_age;
}
// the destructor must release this resource via delete[]
~person()
{
delete[] name;
}
};
Noch heute schreiben die Leute Klassen in diesem Stil und geraten in Schwierigkeiten: „ Ich habe eine Person in einen Vektor gestoßen und jetzt bekomme ich verrückte Speicherfehler! “ Denken Sie daran, dass das Kopieren eines Objekts standardmäßig das Kopieren seiner Mitglieder bedeutet, aber nur das Kopieren des nameMitglieds kopiert einen Zeiger, nicht das Zeichenarray, auf das er zeigt! Dies hat mehrere unangenehme Auswirkungen:
- Änderungen über
akönnen über beobachtet werden b.
- Sobald
bzerstört a.nameist, baumelt ein Zeiger.
- Wenn
aes zerstört wird, führt das Löschen des baumelnden Zeigers zu undefiniertem Verhalten .
- Da bei der Zuweisung nicht berücksichtigt wird, worauf
namevor der Zuweisung hingewiesen wurde, treten früher oder später überall Speicherlecks auf.
Explizite Definitionen
Da das kopieren nach Elementen nicht den gewünschten Effekt hat, müssen wir den Kopierkonstruktor und den Kopierzuweisungsoperator explizit definieren, um tiefe Kopien des Zeichenarrays zu erstellen:
// 1. copy constructor
person(const person& that)
{
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
// 2. copy assignment operator
person& operator=(const person& that)
{
if (this != &that)
{
delete[] name;
// This is a dangerous point in the flow of execution!
// We have temporarily invalidated the class invariants,
// and the next statement might throw an exception,
// leaving the object in an invalid state :(
name = new char[strlen(that.name) + 1];
strcpy(name, that.name);
age = that.age;
}
return *this;
}
Beachten Sie den Unterschied zwischen Initialisierung und Zuweisung: Wir müssen den alten Status vor der Zuweisung aufheben name, um Speicherverluste zu vermeiden. Wir müssen uns auch vor Selbstzuweisung des Formulars schützen x = x. Ohne diese Prüfung delete[] namewürde das Array mit der Quellzeichenfolge gelöscht , da beim Schreiben x = xbeide this->nameund that.namedenselben Zeiger enthalten.
Ausnahmesicherheit
Leider new char[...]schlägt diese Lösung fehl, wenn aufgrund von Speicherauslastung eine Ausnahme ausgelöst wird. Eine mögliche Lösung besteht darin, eine lokale Variable einzuführen und die Anweisungen neu zu ordnen:
// 2. copy assignment operator
person& operator=(const person& that)
{
char* local_name = new char[strlen(that.name) + 1];
// If the above statement throws,
// the object is still in the same state as before.
// None of the following statements will throw an exception :)
strcpy(local_name, that.name);
delete[] name;
name = local_name;
age = that.age;
return *this;
}
Dies sorgt auch für eine Selbstzuweisung ohne explizite Prüfung. Eine noch robustere Lösung für dieses Problem ist das Copy-and-Swap-Idiom , aber ich werde hier nicht auf die Details der Ausnahmesicherheit eingehen. Ich habe nur Ausnahmen erwähnt, um den folgenden Punkt hervorzuheben : Das Schreiben von Klassen, die Ressourcen verwalten, ist schwierig.
Nicht kopierbare Ressourcen
Einige Ressourcen können oder sollten nicht kopiert werden, z. B. Dateihandles oder Mutexe. In diesem Fall deklarieren Sie einfach den Kopierkonstruktor und den Kopierzuweisungsoperator als privateohne Definition:
private:
person(const person& that);
person& operator=(const person& that);
Alternativ können Sie sie erben boost::noncopyableoder als gelöscht deklarieren (in C ++ 11 und höher):
person(const person& that) = delete;
person& operator=(const person& that) = delete;
Die Dreierregel
Manchmal müssen Sie eine Klasse implementieren, die eine Ressource verwaltet. (Verwalten Sie niemals mehrere Ressourcen in einer Klasse. Dies führt nur zu Schmerzen.) Denken Sie in diesem Fall an die Dreierregel :
Wenn Sie entweder den Destruktor, den Kopierkonstruktor oder den Kopierzuweisungsoperator selbst explizit deklarieren müssen, müssen Sie wahrscheinlich alle drei explizit deklarieren.
(Leider wird diese "Regel" weder vom C ++ - Standard noch von einem mir bekannten Compiler durchgesetzt.)
Die Regel von fünf
Ab C ++ 11 verfügt ein Objekt über zwei spezielle Elementfunktionen: den Verschiebungskonstruktor und die Verschiebungszuweisung. Die Regel von fünf Staaten, um diese Funktionen ebenfalls zu implementieren.
Ein Beispiel mit den Signaturen:
class person
{
std::string name;
int age;
public:
person(const std::string& name, int age); // Ctor
person(const person &) = default; // Copy Ctor
person(person &&) noexcept = default; // Move Ctor
person& operator=(const person &) = default; // Copy Assignment
person& operator=(person &&) noexcept = default; // Move Assignment
~person() noexcept = default; // Dtor
};
Die Regel von Null
Die Regel von 3/5 wird auch als Regel von 0/3/5 bezeichnet. Der Nullteil der Regel besagt, dass Sie beim Erstellen Ihrer Klasse keine der speziellen Elementfunktionen schreiben dürfen.
Rat
In den meisten Fällen müssen Sie eine Ressource nicht selbst verwalten, da eine vorhandene Klasse dies std::stringbereits für Sie erledigt. Vergleichen Sie einfach den einfachen Code mit einem std::stringMitglied mit der verschlungenen und fehleranfälligen Alternative mit a, char*und Sie sollten überzeugt sein. Solange Sie sich von rohen Zeigerelementen fernhalten, ist es unwahrscheinlich, dass die Dreierregel Ihren eigenen Code betrifft.
c++-faqTag-Wiki, bevor du abstimmst, um zu schließen .