Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Destruktor v C++: življenjska doba, okviri korutin in PImpl

Destruktor označi konec življenjske dobe objekta in sprosti njegove vire. Spoznajte, kako lastnik uniči okvir korutine in zakaj je destruktor PImpl definiran zunaj razreda.

Različica: 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() je posebna članska funkcija brez parametrov in povratnega tipa. V C++23 lahko razredna predloga deklarira več kandidatov za destruktor z različnimi omejitvami; razreševanje preobremenitev za dano specializacijo izbere enega. Življenjska doba objekta razrednega tipa se konča ob začetku klica destruktorja. Popolnoma zgrajen lokalni objekt s samodejnim trajanjem shranjevanja se uniči ob izhodu iz dosega, tudi med odvijanjem sklada. Po telesu destruktorja se najprej uničijo člani in nato bazni razredi v obratnem vrstnem redu od konstrukcije.

V ~T() je tilda del imena destruktorja; v ~bits označuje bitni komplement. Eksplicitni klic p->~T() ne sprosti pomnilnika samega objekta. Ne uporabite ga za lokalni objekt s samodejnim trajanjem shranjevanja, ki bi se ob izhodu iz dosega uničil še enkrat. Veljaven delete p z neničelnim kazalcem združi uničenje in sprostitev pomnilnika. Pri brisanju izpeljanega objekta prek kazalca na javni bazni razred uporabite virtualni destruktor baze. Ne dovolite, da izjema uide iz destruktorja: če uide iz destruktorja noexcept ali iz destruktorja med odvijanjem sklada, se pokliče std::terminate.

Lastnik okvira, kot je TaskInt ali GeneratorStr, uporablja RAII: njegov destruktor pokliče h.destroy() le, če se h nanaša na še živo, začasno ustavljeno korutino. std::coroutine_handle sam ni lastnik; njegovo kopiranje ne ustvari novega okvira. = delete pri kopirnem konstruktorju in operatorju kopirnega prirejanja prepove kopiranje med prevajanjem; ne sprošča pomnilnika. Če dodate operaciji premika, prenesite ročico, izpraznite izvorno ročico in pri prirejanju s premikom sprostite stari okvir cilja.

Pri PImpl struct Impl; deklarira nepopoln ugnezdeni tip. Član std::unique_ptr<Impl> je dovoljen, vendar njegov privzeti brisalnik na mestu klica zahteva popoln tip Impl. Deklarirajte ~Widget(); v razredu in za definicijo Impl, običajno v datoteki .cpp, napišite Widget::~Widget() = default;. Z = default prevajalniku naročite, naj ustvari običajno uničenje članov. Dvopičje v konstruktorju uvede inicializacijski seznam članov, ki impl_ inicializira, namesto da bi mu priredil vrednost.

Uporabniško deklariran destruktor, tudi z = default, prepreči implicitno deklaracijo obeh operacij premika. Ker std::unique_ptr ni mogoče kopirati, tudi Widget ni mogoče kopirati. Za premikanje objekta Widget obe operaciji izrecno deklarirajte in definirajte z = default po dopolnitvi tipa Impl: prirejanje s premikom lahko uniči objekt, ki ga je prej imel v lasti ciljni impl_.

Primeri

#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

Izpis je pričakovan, ni bil izmerjen. `finish()` doseže `co_return` in ostane v končni točki ustavitve, dokler `Task` ne zapusti dosega. Po premiku ima objekt `Impl` v lasti le `second`, zato se vsako sporočilo o uničenju pojavi enkrat. Primer zahteva podporo za `<coroutine>` v načinu C++23.

Povezane lekcije

  • C++ · Lekcija 41 · Napredna · Različica: 3
  • C++ · Lekcija 42 · Napredna · Različica: 3
  • C++ · Lekcija 43 · Napredna · Različica: 3
  • C++ · Lekcija 57 · Napredna · Različica: 3

Viri