KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

C++-destructor: levensduur, coroutineframes en PImpl

Een destructor markeert het einde van de levensduur van een object en geeft resources vrij. Leer hoe een eigenaar een coroutineframe vernietigt en waarom de PImpl-destructor buiten de klasse staat.

Versie: 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;
};

Een destructor ~T() is een speciale lidfunctie zonder parameters of retourtype. In C++23 kan een klassetemplate meerdere destructorkandidaten met verschillende constraints declareren; overbelastingsresolutie kiest er één voor een specialisatie. De levensduur van een klasseobject eindigt zodra de aanroep van de destructor begint. Een volledig geconstrueerd lokaal object met automatische opslagduur wordt vernietigd bij het verlaten van zijn scope, ook tijdens stack unwinding. Na de destructorbody worden eerst de leden en dan de basisklassen in omgekeerde constructievolgorde vernietigd.

In ~T() hoort de tilde bij de naam van de destructor; in ~bits geeft die het bitsgewijze complement aan. Een expliciete aanroep p->~T() geeft het geheugen van het object zelf niet vrij. Gebruik die niet op een lokaal object met automatische opslagduur dat bij het verlaten van zijn scope opnieuw wordt vernietigd. Een geldige delete p met een niet-nulle pointer combineert vernietiging met het vrijgeven van geheugen. Gebruik een virtuele destructor in de basisklasse als je een afgeleid object via een pointer naar een publieke basisklasse verwijdert. Laat geen exception uit een destructor ontsnappen: gebeurt dat vanuit een noexcept-destructor of tijdens stack unwinding, dan wordt std::terminate aangeroepen.

Een frame-eigenaar zoals TaskInt of GeneratorStr gebruikt RAII: zijn destructor roept h.destroy() alleen aan als h verwijst naar een nog bestaande, gepauzeerde coroutine. std::coroutine_handle is zelf geen eigenaar; kopiëren maakt geen nieuw frame aan. = delete op de kopieerconstructor en de kopieertoewijzingsoperator verbiedt kopiëren tijdens compilatie en geeft geen geheugen vrij. Voeg je verplaatsbewerkingen toe, draag dan de handle over, maak de bron leeg en geef bij verplaatsingstoewijzing het oude frame van het doel vrij.

In PImpl declareert struct Impl; een incompleet genest type. Een lid std::unique_ptr<Impl> is toegestaan, maar de standaarddeleter vereist dat Impl compleet is op de plek waar die wordt aangeroepen. Declareer ~Widget(); in de klasse en schrijf na de definitie van Impl, meestal in het .cpp-bestand, Widget::~Widget() = default;. Met = default laat je de compiler de gebruikelijke vernietiging van leden genereren. De dubbele punt in de constructor opent de initialisatielijst voor leden, die impl_ initialiseert in plaats van er iets aan toe te wijzen.

Een door de gebruiker gedeclareerde destructor, ook met = default, onderdrukt de impliciete declaratie van beide verplaatsbewerkingen. std::unique_ptr is niet kopieerbaar, dus Widget ook niet. Declareer beide verplaatsbewerkingen expliciet en definieer ze met = default zodra Impl compleet is: verplaatsingstoewijzing kan het object vernietigen dat eerder eigendom was van het impl_-lid van het doel.

Voorbeelden

#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");
    }
}

Resultaat

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

De uitvoer is verwacht, niet gemeten. `finish()` bereikt `co_return` en blijft op het laatste pauzepunt totdat `Task` zijn scope verlaat. Na de verplaatsing bezit alleen `second` het `Impl`-object, dus elk vernietigingsbericht verschijnt één keer. Het voorbeeld vereist ondersteuning voor `<coroutine>` in C++23-modus.

Gerelateerde lessen

  • C++ · Les 41 · Gevorderd · Versie: 3
  • C++ · Les 42 · Gevorderd · Versie: 3
  • C++ · Les 43 · Gevorderd · Versie: 3
  • C++ · Les 57 · Gevorderd · Versie: 3

Bronnen