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
Източници
- Destructors [class.dtor]
- Lifetime [basic.life]
- Delete [expr.delete]
- Deleted definitions [dcl.fct.def.delete]
- Explicitly-defaulted functions [dcl.fct.def.default]
- Copy/move constructors [class.copy.ctor]
- Copy/move assignment operator [class.copy.assign]
- Coroutines [dcl.fct.def.coroutine]
- Coroutine handle resumption and destruction [coroutine.handle.resumption]
- default_delete [unique.ptr.dltr.dflt]
- Initializing bases and members [class.base.init]
- The std::terminate function [except.terminate]