Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Destruktor w C++: czas życia, ramki korutyn i PImpl

Destruktor kończy czas życia obiektu i służy do zwalniania jego zasobów. Zobacz, jak właściciel niszczy ramkę korutyny i dlaczego w PImpl definicja destruktora trafia poza klasę.

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

Składnia

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

Destruktor ~T() to specjalna funkcja składowa bez parametrów i typu zwracanego. W C++23 szablon klasy może deklarować kilka destruktorów z różnymi ograniczeniami; rozstrzyganie przeciążeń wybiera jeden dla danej specjalizacji. Czas życia obiektu klasy kończy się z chwilą rozpoczęcia wywołania destruktora. W pełni skonstruowany obiekt lokalny o automatycznym okresie przechowywania jest niszczony przy wyjściu z zakresu, również podczas odwijania stosu. Po ciele destruktora składowe, a następnie klasy bazowe są niszczone w kolejności odwrotnej do ich konstrukcji.

W ~T() tylda należy do nazwy destruktora; w ~bits oznacza dopełnienie bitowe. Jawne p->~T() nie zwalnia pamięci samego obiektu; nie wywołuj go dla obiektu lokalnego o automatycznym okresie przechowywania, który zostanie zniszczony ponownie przy wyjściu z zakresu. Poprawne delete p dla niepustego wskaźnika łączy niszczenie z dealokacją. Przy usuwaniu obiektu pochodnego przez wskaźnik do publicznej klasy bazowej stosuj wirtualny destruktor bazy. Nie pozwól, by wyjątek opuścił destruktor: jeśli opuści destruktor noexcept lub wydostanie się z destruktora podczas odwijania stosu, nastąpi std::terminate.

Właściciel ramki w stylu TaskInt lub GeneratorStr stosuje RAII: jego destruktor wywołuje h.destroy() tylko wtedy, gdy h wskazuje na nadal istniejącą, zawieszoną korutynę. std::coroutine_handle sam nie jest właścicielem; skopiowanie go nie tworzy nowej ramki. = delete na konstruktorze kopiującym i operatorze przypisania kopiującego zabrania kopiowania na etapie kompilacji, a nie zwalnia pamięci. Jeśli dodasz przenoszenie, przekaż uchwyt, wyzeruj uchwyt źródła i przy przypisaniu zwolnij dotychczasową ramkę celu.

W PImpl struct Impl; deklaruje niekompletny typ zagnieżdżony. Składowa std::unique_ptr<Impl> jest dozwolona, ale jej domyślny deleter wymaga kompletnego Impl w miejscu wywołania. Zadeklaruj ~Widget(); w klasie, a po definicji Impl zapisz Widget::~Widget() = default;, zwykle w pliku .cpp. = default zleca kompilatorowi wygenerowanie zwykłego niszczenia składowych; dwukropek w konstruktorze rozpoczyna listę inicjalizacyjną i służy do inicjalizacji impl_, nie do przypisania.

Destruktor zadeklarowany przez użytkownika, nawet z = default, blokuje niejawne deklarowanie obu operacji przenoszenia. std::unique_ptr nie daje się kopiować, więc Widget także nie jest kopiowalny. Jeśli Widget ma być przenoszalny, zadeklaruj obie operacje jawnie i zdefiniuj je przez = default po definicji Impl: przypisanie przenoszące może zniszczyć dotychczasowy obiekt docelowy wskazywany przez impl_.

Przykłady

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

Wynik

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

Wynik jest oczekiwany, nie zmierzony. `finish()` dochodzi do `co_return` i pozostaje w końcowym zawieszeniu do wyjścia `Task` z zakresu. Po przeniesieniu tylko `second` posiada `Impl`, więc każda informacja o niszczeniu pojawia się raz. Przykład wymaga obsługi `<coroutine>` w trybie C++23.

Powiązane lekcje

  • C++ · Lekcja 41 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 42 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 43 · Zaawansowany · Wersja: 3
  • C++ · Lekcja 57 · Zaawansowany · Wersja: 3

Źródła