CKTIS / C++
Destrutor em C++: tempo de vida, estruturas de corrotinas e PImpl
O destrutor assinala o fim da vida de um objeto e liberta os seus recursos. Veja como um proprietário destrói a estrutura de uma corrotina e por que se define o destrutor PImpl fora da classe.
Versão: ISO C++23; implementation support may vary
Sintaxe
// 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;
};Um destrutor ~T() é uma função-membro especial sem parâmetros nem tipo de retorno. Em C++23, um modelo de classe pode declarar vários destrutores candidatos com restrições diferentes; a resolução de sobrecargas seleciona um para cada especialização. O tempo de vida de um objeto de tipo classe termina quando começa a chamada ao seu destrutor. Um objeto local completamente construído com duração de armazenamento automática é destruído à saída do âmbito, incluindo durante o desenrolamento da pilha. Depois do corpo do destrutor, são destruídos primeiro os membros e depois as classes base, pela ordem inversa à da construção.
Em ~T(), o til faz parte do nome do destrutor; em ~bits, indica o complemento bit a bit. Uma chamada explícita p->~T() não liberta a memória do próprio objeto; não a use num objeto local com duração de armazenamento automática que voltará a ser destruído à saída do âmbito. Um delete p válido com um ponteiro não nulo combina destruição e libertação de memória. Para eliminar um objeto derivado através de um ponteiro para uma base pública, use um destrutor virtual na base. Não deixe exceções sair de um destrutor: se saírem de um destrutor noexcept ou de um destrutor durante o desenrolamento da pilha, é chamado std::terminate.
Um proprietário da estrutura de uma corrotina como TaskInt ou GeneratorStr usa RAII: o seu destrutor chama h.destroy() apenas se h referir uma corrotina ainda viva e suspensa. std::coroutine_handle não é, por si só, proprietário; copiá-lo não cria outra estrutura. = delete no construtor de cópia e no operador de atribuição por cópia proíbe a cópia em tempo de compilação; não liberta memória. Se adicionar operações de movimento, transfira o identificador, esvazie o da origem e liberte a estrutura anterior do destino na atribuição por movimento.
Em PImpl, struct Impl; declara um tipo aninhado incompleto. É permitido um membro std::unique_ptr<Impl>, mas o seu eliminador predefinido exige que Impl esteja completo no ponto em que é chamado. Declare ~Widget(); na classe e escreva Widget::~Widget() = default; depois de definir Impl, geralmente no ficheiro .cpp. = default pede ao compilador que gere a destruição normal dos membros. Os dois pontos no construtor abrem a lista de inicialização de membros, que inicializa impl_ em vez de lhe atribuir um valor.
Um destrutor declarado pelo utilizador, mesmo com = default, impede a declaração implícita de ambas as operações de movimento. std::unique_ptr não pode ser copiado, pelo que Widget também não. Para permitir o movimento de Widget, declare explicitamente ambas as operações e defina-as com = default depois de Impl estar completo: a atribuição por movimento pode destruir o objeto anteriormente detido pelo impl_ do destino.
Exemplos
#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");
}
}Resultado
leaving task scope frame: promise destroyed leaving widget scope widget: implementation destroyed
A saída é a esperada, não foi medida. `finish()` chega a `co_return` e permanece no ponto de suspensão final até `Task` sair do âmbito. Depois do movimento, só `second` possui o objeto `Impl`, pelo que cada mensagem de destruição aparece uma vez. O exemplo requer suporte para `<coroutine>` no modo C++23.
Lições relacionadas
- C++ · Lição 41 · Avançado · Versão: 3
- C++ · Lição 42 · Avançado · Versão: 3
- C++ · Lição 43 · Avançado · Versão: 3
- C++ · Lição 57 · Avançado · Versão: 3
Fontes
- 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]