C++ Academy · Lektion

Objektlebensdauer

Verstehen, wann Objekte erstellt und zerstört werden

Objektlebensdauer 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.

Wenn Objekte entstehen

Die Lebensdauer eines Objekts beginnt, nachdem sein Speicher reserviert und sein Konstruktor abgeschlossen wurde. Ab diesem Zeitpunkt kann es vollständig verwendet werden.

#include <iostream>

struct Widget {
    Widget() { std::cout << "born\n"; }
};

int main() {
    Widget w;   // constructor runs here
}

Wenn Objekte zerstört werden

Die Lebensdauer endet, wenn der Destruktor ausgeführt wird. Bei einem Stack-Objekt geschieht das an der schließenden geschweiften Klammer seines Gültigkeitsbereichs.

#include <iostream>

struct Widget {
    ~Widget() { std::cout << "dies\n"; }
};

int main() {
    Widget w;
    std::cout << "alive\n";
}   // ~Widget runs here

Reihenfolge von Konstruktion und Zerstörung

Objekte werden in der umgekehrten Reihenfolge ihrer Konstruktion zerstört. Das zuletzt erstellte Objekt wird zuerst abgebaut.

#include <iostream>

struct Tag {
    int id;
    Tag(int i) : id(i) { std::cout << "make " << id << "\n"; }
    ~Tag() { std::cout << "drop " << id << "\n"; }
};

int main() {
    Tag a(1);
    Tag b(2);   // dropped before a
}

Automatische Lebensdauer (Stack)

Automatische Objekte leben für die Dauer des umschließenden Blocks. Dies ist das häufigste und sicherste Lebensdauermodell.

Dynamische Lebensdauer (Heap)

Mit new erstellte Heap-Objekte leben, bis delete aufgerufen wird – ihre Lebensdauer wird von Ihnen und nicht vom Gültigkeitsbereich gesteuert.

#include <iostream>

struct Widget {
    ~Widget() { std::cout << "dies\n"; }
};

int main() {
    Widget* w = new Widget();
    std::cout << "still alive\n";
    delete w;   // destructor runs here
}

Statische Lebensdauer

Objekte mit static-Speicherdauer leben während des gesamten Programms. Eine lokale statische Variable wird bei ihrer ersten Verwendung einmalig konstruiert.

#include <iostream>

int next() {
    static int counter = 0;   // built once
    return ++counter;
}

int main() {
    std::cout << next() << next() << next() << "\n";
}

Temporäre Objekte

Ein in einem Ausdruck erstelltes temporäres Objekt wird normalerweise am Ende des vollständigen Ausdrucks zerstört (am Semikolon).

#include <iostream>
#include <string>

int main() {
    std::cout << (std::string("a") + "b") << "\n";
}   // temporary string dies after this line

Member werden vor dem Konstruktorrumpf erstellt

Die Member-Objekte einer Klasse werden erstellt, bevor der Konstruktor-Rumpf des umschließenden Objekts ausgeführt wird, und nach dessen Destruktor-Rumpf zerstört.

#include <iostream>
#include <string>

struct Engine { Engine() { std::cout << "engine\n"; } };
struct Car {
    Engine e;
    Car() { std::cout << "car\n"; }
};

int main() { Car c; }

Verlängerung der Lebensdauer durch const-Referenz

Wenn Sie ein temporäres Objekt an eine const& binden, wird seine Lebensdauer auf die der Referenz verlängert – eine praktische C++-Regel.

#include <iostream>
#include <string>

int main() {
    const std::string& s = std::string("hi");
    std::cout << s << "\n";   // s still valid
}

Verwendung nach Ende der Lebensdauer

Auf ein Objekt zuzugreifen, nachdem seine Lebensdauer beendet ist, führt zu undefiniertem Verhalten – der klassische Fehler einer dangling reference oder einer use-after-free.

Die Lebensdauer bildet die Grundlage für RAII

Da Destruktoren deterministisch am Ende der Lebensdauer ausgeführt werden, verknüpft C++ die Ressourcenbereinigung mit der Lebensdauer – die Grundlage von RAII, das im nächsten Kurs behandelt wird.

Kurze Überprüfung

Testen Sie Ihr Verständnis der Lebensdauer von Objekten.

Zusammenfassung

Sie haben gelernt, dass die Lebensdauer eines Objekts nach seiner Konstruktion beginnt und mit seiner Zerstörung endet. Automatische Objekte folgen dem Gültigkeitsbereich, dynamische Objekte folgen new/delete, und statische Objekte bestehen während des gesamten Programms. Die Zerstörung erfolgt in umgekehrter Reihenfolge – die Grundlage von RAII.

Häufig gestellte Fragen

Ist die Lektion „Objektlebensdauer“ kostenlos?

Ja — der vollständige Text von „Objektlebensdauer“ 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 „Objektlebensdauer“?

Verstehen, wann Objekte erstellt und zerstört werden 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 „Objektlebensdauer“?

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