Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

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