База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

Деструктор в C++: живот на обектите, рамки на корутини и PImpl

Деструкторът отбелязва края на живота на обекта и освобождава ресурсите му. Вижте как собственик унищожава рамка на корутина и защо деструкторът при PImpl се дефинира извън класа.

Версия: ISO C++23; implementation support may vary

Синтаксис

// 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;
};

Деструкторът ~T() е специална член-функция без параметри и тип на връщаната стойност. В C++23 шаблон на клас може да декларира няколко кандидата за деструктор с различни ограничения; разрешаването на претоварването избира един за дадена специализация. Животът на обект от класов тип приключва при започване на извикването на деструктора. Напълно конструиран локален обект с автоматична продължителност на съхранение се унищожава при напускане на областта си на видимост, включително при развиване на стека. След тялото на деструктора се унищожават първо членовете, после базовите класове в обратния на конструирането ред.

В ~T() тилдата е част от името на деструктора; в ~bits тя означава побитово допълнение. Явното извикване p->~T() не освобождава паметта на самия обект. Не го използвайте за локален обект с автоматична продължителност на съхранение, който ще бъде унищожен отново при напускане на областта. Валиден израз delete p с ненулев указател съчетава унищожаване и освобождаване на памет. При изтриване на производен обект през указател към публичен базов клас използвайте виртуален деструктор в базовия клас. Не допускайте изключение да напусне деструктора: ако то напусне деструктор noexcept или напусне деструктор по време на развиване на стека, се извиква std::terminate.

Собственик на рамка като TaskInt или GeneratorStr използва RAII: деструкторът му извиква h.destroy() само ако h сочи към все още съществуваща, спряна корутина. std::coroutine_handle сам по себе си не е собственик; копирането му не създава нова рамка. = delete за копиращия конструктор и оператора за копиращо присвояване забранява копирането по време на компилация, а не освобождава памет. Ако добавите операции за преместване, прехвърлете дескриптора, занулете източника и при преместващо присвояване освободете старата рамка на целта.

При PImpl struct Impl; декларира непълен вложен тип. Член std::unique_ptr<Impl> е допустим, но стандартната му операция за изтриване изисква Impl да е пълен на мястото на извикването. Декларирайте ~Widget(); в класа, а след дефиницията на Impl, обикновено във файл .cpp, напишете Widget::~Widget() = default;. С = default указвате на компилатора да генерира обичайното унищожаване на членовете. Двоеточието в конструктора въвежда списъка за инициализация на членовете, който инициализира impl_, вместо да му присвоява стойност.

Деклариран от потребителя деструктор, дори с = default, потиска неявното деклариране на двете операции за преместване. std::unique_ptr не може да се копира, затова и Widget не може. За да позволите преместване на Widget, декларирайте изрично и двете операции и ги дефинирайте с = default, след като Impl стане пълен: преместващото присвояване може да унищожи обекта, който целевият impl_ е притежавал дотогава.

Примери

#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");
    }
}

Резултат

leaving task scope
frame: promise destroyed
leaving widget scope
widget: implementation destroyed

Изходът е очакван, а не измерен. `finish()` достига `co_return` и остава в крайната точка на спиране, докато `Task` напусне областта си на видимост. След преместването само `second` притежава обекта `Impl`, затова всяко съобщение за унищожаване се появява веднъж. Примерът изисква поддръжка на `<coroutine>` в режим C++23.

Свързани уроци

  • C++ · Урок 41 · Напреднало · Версия: 3
  • C++ · Урок 42 · Напреднало · Версия: 3
  • C++ · Урок 43 · Напреднало · Версия: 3
  • C++ · Урок 57 · Напреднало · Версия: 3

Източници