CKTIS / C++
Destructor de C++: vida del objeto, marcos de corrutina y PImpl
El destructor marca el final de la vida de un objeto y libera sus recursos. Aprende cómo un propietario destruye un marco de corrutina y por qué el destructor de PImpl se define fuera de la clase.
Versión: ISO C++23; implementation support may vary
Sintaxis
// 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;
};Un destructor ~T() es una función miembro especial sin parámetros ni tipo de retorno. En C++23, una plantilla de clase puede declarar varios destructores candidatos con distintas restricciones; la resolución de sobrecarga selecciona uno para cada especialización. La vida de un objeto de tipo clase termina al comenzar la llamada a su destructor. Un objeto local con duración de almacenamiento automática se destruye al salir de su ámbito si se ha construido por completo, también durante el desenrollado de la pila. Tras el cuerpo del destructor, se destruyen primero los miembros y luego las bases en orden inverso al de su construcción.
En ~T(), la tilde forma parte del nombre del destructor; en ~bits, indica el complemento bit a bit. La llamada explícita p->~T() no libera la memoria del propio objeto; no la uses con un objeto local con duración de almacenamiento automática que volverá a destruirse al salir de su ámbito. Un delete p válido con un puntero no nulo combina destrucción y liberación de memoria. Para eliminar un objeto derivado mediante un puntero a una base pública, usa un destructor virtual en la base. No dejes que una excepción salga del destructor: si sale de un destructor noexcept o se propaga desde él durante el desenrollado de la pila, se llama a std::terminate.
Un propietario del marco como TaskInt o GeneratorStr aplica RAII: su destructor llama a h.destroy() solo si h se refiere a una corrutina que sigue viva y está suspendida. std::coroutine_handle no es propietario por sí mismo; copiarlo no crea otro marco. Poner = delete en el constructor y el operador de asignación de copia prohíbe copiar en tiempo de compilación; no libera memoria. Si incorporas operaciones de movimiento, transfiere el manejador, vacía el original y, en la asignación por movimiento, libera el marco anterior del destino.
En PImpl, struct Impl; declara un tipo anidado incompleto. Se admite un miembro std::unique_ptr<Impl>, pero su eliminador predeterminado exige que Impl sea completo donde se lo invoca. Declara ~Widget(); en la clase y escribe Widget::~Widget() = default; después de definir Impl, normalmente en el archivo .cpp. = default pide al compilador que genere la destrucción habitual de los miembros; los dos puntos del constructor abren la lista de inicialización de miembros, que inicializa impl_ en vez de asignarle un valor.
Un destructor declarado por el usuario, incluso con = default, impide la declaración implícita de ambas operaciones de movimiento. std::unique_ptr no se puede copiar, así que Widget tampoco. Para que Widget se pueda mover, declara ambas operaciones de forma explícita y defínelas con = default cuando Impl ya sea completo: la asignación por movimiento puede destruir el objeto que antes poseía el impl_ de destino.
Ejemplos
#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
La salida es la esperada, no una medición. `finish()` llega a `co_return` y permanece en el punto de suspensión final hasta que `Task` sale de su ámbito. Tras el movimiento, solo `second` posee el objeto `Impl`, por lo que cada mensaje de destrucción aparece una vez. El ejemplo requiere compatibilidad con `<coroutine>` en modo C++23.
Lecciones relacionadas
- C++ · Lección 41 · Avanzado · Versión: 3
- C++ · Lección 42 · Avanzado · Versión: 3
- C++ · Lección 43 · Avanzado · Versión: 3
- C++ · Lección 57 · Avanzado · Versión: 3
Fuentes
- 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]