CKTIS / C++
Deštruktor v C++: životnosť objektu, rámce korutín a PImpl
Deštruktor označuje koniec životnosti objektu a uvoľňuje jeho zdroje. Zistite, ako vlastník zničí rámec korutiny a prečo sa deštruktor PImpl definuje mimo triedy.
Verzia: 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;
};Deštruktor ~T() je špeciálna členská funkcia bez parametrov a návratového typu. V C++23 môže šablóna triedy deklarovať viacero kandidátov na deštruktor s rôznymi obmedzeniami; rozlíšenie preťaženia vyberie pre danú špecializáciu jedného. Životnosť objektu triedneho typu sa končí začiatkom volania deštruktora. Úplne skonštruovaný lokálny objekt s automatickou dobou uloženia sa zničí pri opustení rozsahu platnosti, a to aj pri odvíjaní zásobníka. Po tele deštruktora sa zničia najprv členy a potom bázové triedy v opačnom poradí ako pri konštrukcii.
V ~T() je vlnovka súčasťou názvu deštruktora; v ~bits označuje bitový doplnok. Explicitné volanie p->~T() neuvoľňuje pamäť samotného objektu. Nepoužívajte ho na lokálny objekt s automatickou dobou uloženia, ktorý sa pri opustení rozsahu zničí znova. Platné delete p s nenulovým ukazovateľom spája zničenie s uvoľnením pamäte. Pri mazaní odvodeného objektu cez ukazovateľ na verejnú bázovú triedu použite virtuálny deštruktor bázy. Nedovoľte výnimke uniknúť z deštruktora: pri úniku z deštruktora noexcept alebo z deštruktora počas odvíjania zásobníka sa zavolá std::terminate.
Vlastník rámca ako TaskInt alebo GeneratorStr používa RAII: jeho deštruktor volá h.destroy() iba vtedy, ak h odkazuje na stále existujúcu pozastavenú korutinu. std::coroutine_handle sám nie je vlastníkom; jeho kopírovaním nevzniká nový rámec. = delete pri kopírovacom konštruktore a operátore kopírovacieho priradenia zakazuje kopírovanie pri preklade; pamäť neuvoľňuje. Ak pridáte operácie presunu, preveďte rukoväť, vyprázdnite zdrojovú rukoväť a pri priradení presunom uvoľnite pôvodný rámec cieľa.
V PImpl deklaruje struct Impl; neúplný vnorený typ. Člen std::unique_ptr<Impl> je povolený, ale jeho predvolená mazacia funkcia vyžaduje úplný typ Impl na mieste volania. Deklarujte ~Widget(); v triede a po definovaní Impl napíšte Widget::~Widget() = default;, zvyčajne v súbore .cpp. = default žiada prekladač, aby vygeneroval bežné zničenie členov. Dvojbodka v konštruktore uvádza zoznam inicializátorov členov, ktorý impl_ inicializuje, nie mu priraďuje hodnotu.
Destruktor deklarovaný používateľom, aj s = default, potláča implicitnú deklaráciu oboch operácií presunu. std::unique_ptr nemožno kopírovať, takže ani Widget nie je kopírovateľný. Ak má byť Widget presúvateľný, obe operácie explicitne deklarujte a definujte pomocou = default, keď je Impl úplný: priradenie presunom môže zničiť objekt, ktorý predtým vlastnil cieľový impl_.
Prí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ýsledok
leaving task scope frame: promise destroyed leaving widget scope widget: implementation destroyed
Výstup je očakávaný, nie nameraný. `finish()` dosiahne `co_return` a zostane v koncovom bode pozastavenia, kým `Task` neopustí svoj rozsah platnosti. Po presune vlastní objekt `Impl` iba `second`, preto sa každá správa o zničení objaví raz. Príklad vyžaduje podporu `<coroutine>` v režime C++23.
Súvisiace lekcie
- C++ · Lekcia 41 · Pokročilá · Verzia: 3
- C++ · Lekcia 42 · Pokročilá · Verzia: 3
- C++ · Lekcia 43 · Pokročilá · Verzia: 3
- C++ · Lekcia 57 · Pokročilá · Verzia: 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]