C++ Academy · Lektion

Rule of Three/Five

Kopieren und Verschieben korrekt verwalten

Rule of Three/Five ist eine kostenlose C++ Academy-Lektion auf CoddyKit. Dies ist Lektion 3 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des C++ Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Die Rule of Three

Wenn eine Klasse einen eigenen Destruktor benötigt, braucht sie fast immer auch einen eigenen Kopierkonstruktor und eine eigene Kopierzuweisung. Diese drei gehören zusammen.

Warum drei?

Eine Klasse, die eine rohe Ressource verwaltet, muss festlegen, wie sie zerstört, kopiert und zugewiesen wird – andernfalls führen die vom Compiler erzeugten flachen Kopien zu doppelten Freigaben.

#include <iostream>

class Bad {
    int* p;
public:
    Bad(int v) : p(new int(v)) {}
    ~Bad() { delete p; }
    // default copy => two objects delete the same p!
};

Benutzerdefinierter Copy-Konstruktor

Ein korrekter Copy-Konstruktor führt eine tiefe Kopie durch und reserviert eine eigene Ressource, statt sie gemeinsam zu nutzen.

#include <iostream>

class Box {
    int* p;
public:
    Box(int v) : p(new int(v)) {}
    Box(const Box& o) : p(new int(*o.p)) {}   // deep copy
    ~Box() { delete p; }
    int get() const { return *p; }
};

int main() {
    Box a(5);
    Box b = a;   // independent copy
    std::cout << b.get() << "\n";
}

Benutzerdefinierte Copy-Zuweisung

Bei einer Copy-Zuweisung muss die alte Ressource freigegeben, Selbstzuweisung verhindert und der neue Wert tief kopiert werden.

Box& operator=(const Box& o) {
    if (this != &o) {              // self-assignment guard
        delete p;
        p = new int(*o.p);
    }
    return *this;
}

Die Fünferregel

C++11 ergänzt Move-Operationen. Wenn Sie eine der fünf Operationen definieren (Destruktor, Copy-Konstruktor, Copy-Zuweisung, Move-Konstruktor, Move-Zuweisung), sollten Sie erwägen, alle fünf zu definieren.

Move-Konstruktor

Ein Move-Konstruktor übernimmt die Ressource eines temporären Objekts und lässt die Quelle leer – das ist deutlich günstiger als Kopieren.

Box(Box&& o) noexcept : p(o.p) {
    o.p = nullptr;   // source left empty
}

Move-Zuweisung

Eine Move-Zuweisung gibt die aktuelle Ressource frei und übernimmt anschließend die Ressource der Quelle.

Box& operator=(Box&& o) noexcept {
    if (this != &o) {
        delete p;
        p = o.p;
        o.p = nullptr;
    }
    return *this;
}

Moves als noexcept markieren

Move-Operationen sollten noexcept sein, damit Container wie std::vector sie bei einer Reallokation sicher verwenden können.

Die Nullregel

Am besten verwalten Sie keine rohen Ressourcen selbst. Verwenden Sie std::unique_ptr, std::vector oder std::string, und Sie müssen keine der fünf Operationen definieren – die Standardimplementierungen des Compilers sind korrekt.

#include <memory>

class Good {
    std::unique_ptr<int> p;   // owns the resource for you
public:
    Good(int v) : p(std::make_unique<int>(v)) {}
    // no destructor, no copy/move needed
};

Operationen löschen

Wenn Kopieren keinen Sinn ergibt, löschen Sie die Operation: Box(const Box&) = delete;. Dadurch ist der Typ bewusst nur verschiebbar oder nicht kopierbar.

Die richtige Regel wählen

Streben Sie die Nullregel an. Greifen Sie nur dann auf die Fünferregel zurück, wenn Sie tatsächlich eine rohe Ressource kapseln, für die die Standardbibliothek keinen passenden Typ bereitstellt.

Kurze Überprüfung

Testen Sie Ihr Verständnis der Dreier-/Fünferregel.

Zusammenfassung

Sie haben die Dreier-/Fünferregel kennengelernt: Wenn Sie eine rohe Ressource verwalten, müssen Sie Destruktor-, Copy- und Move-Operationen konsistent definieren. Markieren Sie Moves mit noexcept. Am besten befolgen Sie die Nullregel, indem Sie standardmäßige RAII-Typen verwenden und keine dieser Operationen definieren.

Häufig gestellte Fragen

Ist die Lektion „Rule of Three/Five“ kostenlos?

Ja — der vollständige Text von „Rule of Three/Five“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des C++ Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der C++ Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „Rule of Three/Five“?

Kopieren und Verschieben korrekt verwalten Du übst C++ Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um C++ Academy zu starten?

Keine Vorkenntnisse erforderlich. C++ Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 3 von 4.

Wie lange dauert die Lektion „Rule of Three/Five“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser C++ Academy-Lektion Code schreiben und ausführen?

Ja. Jede C++ Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

← Zurück zu C++ Academy