WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

C++-Destruktor: Objektlebensdauer, Koroutinen-Frames und PImpl

Ein Destruktor markiert das Ende der Objektlebensdauer und gibt Ressourcen frei. Lerne, wie ein Besitzer einen Koroutinen-Frame zerstört und warum der PImpl-Destruktor außerhalb der Klasse definiert wird.

Version: ISO C++23; implementation support may vary

Syntax

// Destructor declared in the class, then defaulted outside it:
class T {
public:
    ~T();
};
T::~T() = default;

// A different class with a custom destructor and deleted copy operations:
class Owner {
public:
    Owner() = default;
    ~Owner() noexcept { /* release the owned resource */ }
    Owner(const Owner&) = delete;
    Owner& operator=(const Owner&) = delete;
};

Ein Destruktor ~T() ist eine spezielle Memberfunktion ohne Parameter und Rückgabetyp. In C++23 kann eine Klassenvorlage mehrere Destruktorkandidaten mit unterschiedlichen Constraints deklarieren; die Überladungsauflösung wählt für eine Spezialisierung einen aus. Die Lebensdauer eines Klassenobjekts endet mit Beginn des Destruktoraufrufs. Ein vollständig konstruiertes lokales Objekt mit automatischer Speicherdauer wird beim Verlassen seines Gültigkeitsbereichs zerstört, auch beim Stack-Unwinding. Nach dem Destruktorrumpf werden zuerst die Member und dann die Basisklassen in umgekehrter Konstruktionsreihenfolge zerstört.

In ~T() gehört die Tilde zum Destruktornamen; in ~bits steht sie für das bitweise Komplement. Ein explizites p->~T() gibt den Speicher des Objekts selbst nicht frei. Verwende es nicht für ein lokales Objekt mit automatischer Speicherdauer, das beim Verlassen des Bereichs erneut zerstört würde. Ein gültiges delete p mit einem Nichtnullzeiger verbindet Zerstörung mit Speicherfreigabe. Verwende beim Löschen eines abgeleiteten Objekts über einen Zeiger auf eine öffentliche Basisklasse einen virtuellen Basisdestruktor. Lass keine Ausnahme aus einem Destruktor entweichen: Geschieht das bei einem noexcept-Destruktor oder beim Stack-Unwinding, wird std::terminate aufgerufen.

Ein Frame-Besitzer wie TaskInt oder GeneratorStr nutzt RAII: Sein Destruktor ruft h.destroy() nur auf, wenn h auf eine noch existierende, suspendierte Koroutine verweist. std::coroutine_handle besitzt den Frame nicht selbst; eine Kopie erzeugt keinen neuen Frame. = delete am Kopierkonstruktor und am Kopierzuweisungsoperator verbietet das Kopieren zur Übersetzungszeit und gibt keinen Speicher frei. Wenn du Verschiebeoperationen hinzufügst, übertrage das Handle, leere die Quelle und gib bei der Verschiebezuweisung den bisherigen Frame des Ziels frei.

Bei PImpl deklariert struct Impl; einen unvollständigen geschachtelten Typ. Ein Member std::unique_ptr<Impl> ist zulässig, doch sein Standard-Deleter benötigt beim Aufruf den vollständigen Typ Impl. Deklariere ~Widget(); in der Klasse und schreibe nach der Definition von Impl, üblicherweise in der .cpp-Datei, Widget::~Widget() = default;. = default lässt den Compiler die übliche Zerstörung der Member erzeugen. Der Doppelpunkt im Konstruktor leitet die Member-Initialisierungsliste ein, die impl_ initialisiert, statt ihm etwas zuzuweisen.

Ein benutzerdeklarierter Destruktor unterdrückt auch mit = default die implizite Deklaration beider Verschiebeoperationen. std::unique_ptr ist nicht kopierbar, daher ist es auch Widget nicht. Soll Widget verschiebbar sein, deklariere beide Operationen explizit und definiere sie mit = default, nachdem Impl vollständig ist: Die Verschiebezuweisung kann das zuvor vom Ziel-impl_ besessene Objekt zerstören.

Beispiele

#include <coroutine>
#include <cstdio>
#include <exception>
#include <memory>
#include <utility>

class Task {
public:
    struct promise_type;
    using Handle = std::coroutine_handle<promise_type>;

    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;
    ~Task() noexcept { if (h_) h_.destroy(); }

private:
    explicit Task(Handle h) noexcept : h_(h) {}
    Handle h_;
};

struct Task::promise_type {
    Task get_return_object() noexcept { return Task{Handle::from_promise(*this)}; }
    std::suspend_never initial_suspend() noexcept { return {}; }
    std::suspend_always final_suspend() noexcept { return {}; }
    void return_void() noexcept {}
    void unhandled_exception() noexcept { std::terminate(); }
    ~promise_type() { std::puts("frame: promise destroyed"); }
};

Task finish() { co_return; }

class Widget {
    struct Impl;
    std::unique_ptr<Impl> impl_;

public:
    Widget();
    ~Widget();
    Widget(Widget&&) noexcept;
    Widget& operator=(Widget&&) noexcept;
};

struct Widget::Impl {
    ~Impl() { std::puts("widget: implementation destroyed"); }
};

Widget::Widget() : impl_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;

int main() {
    {
        auto task = finish();
        std::puts("leaving task scope");
    }
    {
        Widget first;
        Widget second = std::move(first);
        std::puts("leaving widget scope");
    }
}

Ergebnis

leaving task scope
frame: promise destroyed
leaving widget scope
widget: implementation destroyed

Die Ausgabe ist erwartet, nicht gemessen. `finish()` erreicht `co_return` und bleibt am letzten Suspendierungspunkt, bis `Task` seinen Gültigkeitsbereich verlässt. Nach dem Verschieben besitzt nur `second` das `Impl`-Objekt, daher erscheint jede Zerstörungsmeldung einmal. Das Beispiel benötigt Unterstützung für `<coroutine>` im C++23-Modus.

Zugehörige Lektionen

  • C++ · Lektion 41 · Fortgeschritten · Version: 3
  • C++ · Lektion 42 · Fortgeschritten · Version: 3
  • C++ · Lektion 43 · Fortgeschritten · Version: 3
  • C++ · Lektion 57 · Fortgeschritten · Version: 3

Quellen