Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

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