Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Distruttore C++: durata di vita, frame delle coroutine e PImpl

Il distruttore segna la fine della vita di un oggetto e ne libera le risorse. Scopri come un proprietario distrugge il frame di una coroutine e perché il distruttore PImpl si definisce fuori dalla classe.

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

Sintassi

// 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;
};

Un distruttore ~T() è una funzione membro speciale priva di parametri e di tipo di ritorno. In C++23 un template di classe può dichiarare più distruttori candidati con vincoli diversi; la risoluzione del sovraccarico ne seleziona uno per ogni specializzazione. La vita di un oggetto di tipo classe termina quando inizia la chiamata al suo distruttore. Un oggetto locale completamente costruito con durata di memorizzazione automatica viene distrutto all’uscita dall’ambito, anche durante lo svolgimento dello stack. Dopo il corpo del distruttore, vengono distrutti prima i membri e poi le basi, nell’ordine inverso a quello di costruzione.

In ~T() la tilde fa parte del nome del distruttore; in ~bits indica il complemento bit a bit. La chiamata esplicita p->~T() non dealloca la memoria dell’oggetto stesso: non usarla su un oggetto locale con durata di memorizzazione automatica che verrebbe distrutto di nuovo all’uscita dall’ambito. Un delete p valido con puntatore non nullo unisce distruzione e deallocazione. Per eliminare un oggetto derivato tramite un puntatore a una base pubblica, usa un distruttore virtuale nella base. Non lasciare propagare eccezioni fuori da un distruttore: se escono da un distruttore noexcept o da un distruttore durante lo svolgimento dello stack, viene invocato std::terminate.

Un proprietario del frame come TaskInt o GeneratorStr usa RAII: il suo distruttore chiama h.destroy() solo se h si riferisce a una coroutine ancora in vita e sospesa. std::coroutine_handle non è di per sé un proprietario; copiarlo non crea un altro frame. = delete sul costruttore e sull’operatore di assegnazione di copia vieta la copia in fase di compilazione e non libera memoria. Se aggiungi operazioni di spostamento, trasferisci l’handle, svuota quello di origine e libera il vecchio frame di destinazione nell’assegnazione per spostamento.

In PImpl, struct Impl; dichiara un tipo annidato incompleto. Un membro std::unique_ptr<Impl> è ammesso, ma il deleter predefinito richiede che Impl sia completo dove viene invocato. Dichiara ~Widget(); nella classe e scrivi Widget::~Widget() = default; dopo aver definito Impl, di solito nel file .cpp. = default chiede al compilatore di generare la normale distruzione dei membri; i due punti nel costruttore introducono la lista di inizializzazione dei membri, che inizializza impl_ invece di assegnargli un valore.

Un distruttore dichiarato dall’utente, anche con = default, impedisce la dichiarazione implicita di entrambe le operazioni di spostamento. std::unique_ptr non è copiabile, quindi neanche Widget lo è. Per rendere Widget spostabile, dichiara entrambe le operazioni esplicitamente e definiscile con = default quando Impl è completo: l’assegnazione per spostamento può distruggere l’oggetto prima posseduto dall’impl_ di destinazione.

Esempi

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

Risultato

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

L’output è atteso, non misurato. `finish()` raggiunge `co_return` e resta sospesa al punto di sospensione finale fino all’uscita di `Task` dal suo ambito. Dopo lo spostamento, soltanto `second` possiede l’oggetto `Impl`, quindi ogni messaggio di distruzione appare una volta. L’esempio richiede il supporto a `<coroutine>` in modalità C++23.

Lezioni correlate

  • C++ · Lezione 41 · Avanzato · Versione: 3
  • C++ · Lezione 42 · Avanzato · Versione: 3
  • C++ · Lezione 43 · Avanzato · Versione: 3
  • C++ · Lezione 57 · Avanzato · Versione: 3

Fonti