Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

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