CKTIS / C++
Destruktor u C++-u: životni vijek, okviri korutina i PImpl
Destruktor označava kraj životnog vijeka objekta i oslobađa njegove resurse. Saznajte kako vlasnik uništava okvir korutine i zašto se destruktor PImpl definira izvan klase.
Verzija: ISO C++23; implementation support may vary
Sintaksa
// 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() posebna je funkcija članica bez parametara i povratnog tipa. U C++23 predložak klase može deklarirati nekoliko kandidata za destruktor s različitim ograničenjima; razrješavanje preopterećenja odabire jednog za pojedinu specijalizaciju. Životni vijek objekta klasnog tipa završava početkom poziva destruktora. Potpuno konstruiran lokalni objekt s automatskim trajanjem pohrane uništava se pri izlasku iz dosega, pa i tijekom odmotavanja stoga. Nakon tijela destruktora uništavaju se prvo članovi, a zatim bazne klase, obrnutim redoslijedom od konstrukcije.
U ~T() tilda je dio imena destruktora; u ~bits označava bitovni komplement. Izričit poziv p->~T() ne oslobađa memoriju samog objekta. Nemojte ga primijeniti na lokalni objekt s automatskim trajanjem pohrane koji će se ponovno uništiti pri izlasku iz dosega. Valjani delete p s pokazivačem koji nije nul-pokazivač spaja uništavanje i oslobađanje memorije. Pri brisanju izvedenog objekta preko pokazivača na javnu baznu klasu koristite virtualni destruktor baze. Ne dopustite da iznimka napusti destruktor: ako napusti destruktor noexcept ili destruktor tijekom odmotavanja stoga, poziva se std::terminate.
Vlasnik okvira poput TaskInt ili GeneratorStr koristi RAII: njegov destruktor poziva h.destroy() samo ako se h odnosi na još uvijek živu, obustavljenu korutinu. std::coroutine_handle sam nije vlasnik; njegovim se kopiranjem ne stvara novi okvir. = delete na konstruktoru kopiranja i operatoru pridruživanja kopiranjem zabranjuje kopiranje pri prevođenju; ne oslobađa memoriju. Dodate li operacije premještanja, prenesite ručku, ispraznite izvornu ručku i pri pridruživanju premještanjem oslobodite prethodni okvir odredišta.
U PImpl-u struct Impl; deklarira nepotpun ugniježđeni tip. Član std::unique_ptr<Impl> je dopušten, ali njegov zadani brisač zahtijeva da Impl bude potpun na mjestu poziva. Deklarirajte ~Widget(); u klasi, a nakon definicije tipa Impl, obično u datoteci .cpp, napišite Widget::~Widget() = default;. = default traži od prevoditelja generiranje uobičajenog uništavanja članova. Dvotočka u konstruktoru uvodi popis inicijalizatora članova, kojim se impl_ inicijalizira umjesto da mu se pridruži vrijednost.
Destruktor koji deklarira korisnik, čak i s = default, sprječava implicitnu deklaraciju obiju operacija premještanja. std::unique_ptr nije moguće kopirati, pa nije moguće kopirati ni Widget. Da biste omogućili premještanje objekta Widget, izričito deklarirajte obje operacije i definirajte ih s = default nakon što Impl postane potpun: pridruživanje premještanjem može uništiti objekt koji je prethodno posjedovao odredišni impl_.
Primjeri
#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");
}
}Rezultat
leaving task scope frame: promise destroyed leaving widget scope widget: implementation destroyed
Ispis je očekivan, nije izmjeren. `finish()` dolazi do `co_return` i ostaje u završnoj točki obustave dok `Task` ne izađe iz dosega. Nakon premještanja samo `second` posjeduje objekt `Impl`, pa se svaka poruka o uništavanju pojavljuje jednom. Primjer zahtijeva podršku za `<coroutine>` u načinu C++23.
Povezane lekcije
- C++ · Lekcija 41 · Napredno · Verzija: 3
- C++ · Lekcija 42 · Napredno · Verzija: 3
- C++ · Lekcija 43 · Napredno · Verzija: 3
- C++ · Lekcija 57 · Napredno · Verzija: 3
Izvori
- 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]