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
- Destructors [class.dtor]
- Lifetime [basic.life]
- Delete [expr.delete]
- Deleted definitions [dcl.fct.def.delete]
- Explicitly-defaulted functions [dcl.fct.def.default]
- Copy/move constructors [class.copy.ctor]
- Copy/move assignment operator [class.copy.assign]
- Coroutines [dcl.fct.def.coroutine]
- Coroutine handle resumption and destruction [coroutine.handle.resumption]
- default_delete [unique.ptr.dltr.dflt]
- Initializing bases and members [class.base.init]
- The std::terminate function [except.terminate]