CKTIS / C++
Destruktor v C++: životnost objektu, rámce korutin a PImpl
Destruktor označuje konec životnosti objektu a uvolňuje jeho prostředky. Naučte se, jak vlastník zničí rámec korutiny a proč se destruktor PImpl definuje mimo třídu.
Verze: ISO C++23; implementation support may vary
Syntaxe
// 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() je speciální členská funkce bez parametrů a návratového typu. V C++23 může šablona třídy deklarovat několik kandidátů na destruktor s různými omezeními; řešení přetížení vybere pro danou specializaci jednoho. Životnost objektu třídního typu končí zahájením volání destruktoru. Plně zkonstruovaný lokální objekt s automatickou dobou uložení se zničí při opuštění oboru platnosti, a to i při odvíjení zásobníku. Po těle destruktoru se zničí nejprve členy a potom bázové třídy v opačném pořadí oproti konstrukci.
V ~T() je vlnovka součástí názvu destruktoru; v ~bits označuje bitový doplněk. Výslovné volání p->~T() neuvolní paměť samotného objektu. Nepoužívejte ho u lokálního objektu s automatickou dobou uložení, který se při opuštění oboru zničí znovu. Platné delete p s nenulovým ukazatelem spojuje zničení objektu s uvolněním paměti. Při mazání odvozeného objektu přes ukazatel na veřejnou bázovou třídu použijte virtuální destruktor báze. Nenechte výjimku uniknout z destruktoru: při úniku z destruktoru noexcept nebo z destruktoru během odvíjení zásobníku se zavolá std::terminate.
Vlastník rámce jako TaskInt nebo GeneratorStr používá RAII: jeho destruktor volá h.destroy() pouze tehdy, když h odkazuje na dosud existující pozastavenou korutinu. std::coroutine_handle sám není vlastníkem; jeho zkopírováním nevznikne nový rámec. = delete u kopírovacího konstruktoru a operátoru kopírovacího přiřazení zakazuje kopírování při překladu; paměť neuvolňuje. Pokud přidáte operace přesunu, převeďte úchyt, vyprázdněte zdrojový úchyt a při přiřazení přesunem uvolněte původní rámec cíle.
V PImpl deklaruje struct Impl; neúplný vnořený typ. Člen std::unique_ptr<Impl> je povolen, ale jeho výchozí mazací funkce vyžaduje v místě volání úplný typ Impl. Deklarujte ~Widget(); ve třídě a po definici Impl napište Widget::~Widget() = default;, obvykle v souboru .cpp. = default říká překladači, aby vygeneroval obvyklé zničení členů. Dvojtečka v konstruktoru uvozuje seznam inicializátorů členů, který impl_ inicializuje, nikoli přiřazuje.
Uživatelsky deklarovaný destruktor, i s = default, potlačí implicitní deklaraci obou operací přesunu. std::unique_ptr nelze kopírovat, takže ani Widget není kopírovatelný. Chcete-li Widget přesouvat, obě operace výslovně deklarujte a definujte pomocí = default, až bude Impl úplný: přiřazení přesunem může zničit objekt, který dříve vlastnil cílový impl_.
Příklady
#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");
}
}Výsledek
leaving task scope frame: promise destroyed leaving widget scope widget: implementation destroyed
Výstup je očekávaný, nikoli naměřený. `finish()` dosáhne `co_return` a zůstane v koncovém bodě pozastavení, dokud `Task` neopustí svůj obor platnosti. Po přesunu vlastní objekt `Impl` pouze `second`, takže každá zpráva o zničení zazní jednou. Příklad vyžaduje podporu `<coroutine>` v režimu C++23.
Související lekce
- C++ · Lekce 41 · Pokročilá · Verze: 3
- C++ · Lekce 42 · Pokročilá · Verze: 3
- C++ · Lekce 43 · Pokročilá · Verze: 3
- C++ · Lekce 57 · Pokročilá · Verze: 3
Zdroje
- 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]