CKTIS / C++
Destructeur C++ : durée de vie, états de coroutine et PImpl
Le destructeur marque la fin de vie d’un objet et libère ses ressources. Voyez comment un propriétaire détruit l’état d’une coroutine et pourquoi le destructeur PImpl se définit hors de la classe.
Version : ISO C++23; implementation support may vary
Syntaxe
// 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 destructeur ~T() est une fonction membre spéciale, sans paramètre ni type de retour. En C++23, un modèle de classe peut déclarer plusieurs destructeurs candidats soumis à des contraintes différentes ; la résolution de surcharge en sélectionne un pour une spécialisation. La durée de vie d’un objet de type classe se termine au début de l’appel à son destructeur. Un objet local entièrement construit et à durée de stockage automatique est détruit à la sortie de sa portée, y compris lors du déroulement de la pile. Après le corps du destructeur, les membres puis les bases sont détruits dans l’ordre inverse de leur construction.
Dans ~T(), le tilde fait partie du nom du destructeur ; dans ~bits, il indique le complément bit à bit. Un appel explicite p->~T() ne libère pas la mémoire de l’objet lui-même ; ne l’utilisez pas sur un objet local à durée de stockage automatique qui sera de nouveau détruit à la sortie de sa portée. Une expression delete p valide sur un pointeur non nul combine destruction et désallocation. Pour supprimer un objet dérivé via un pointeur vers une base publique, utilisez un destructeur de base virtuel. Ne laissez pas une exception sortir d’un destructeur : si elle sort d’un destructeur noexcept ou se propage hors d’un destructeur pendant le déroulement de la pile, std::terminate est appelé.
Un propriétaire d’état de coroutine comme TaskInt ou GeneratorStr applique le principe RAII : son destructeur appelle h.destroy() uniquement si h désigne une coroutine encore en vie et suspendue. std::coroutine_handle n’est pas lui-même propriétaire ; sa copie ne crée pas un nouvel état. = delete sur le constructeur et l’opérateur d’affectation de copie interdit la copie à la compilation, sans libérer de mémoire. Si vous ajoutez le déplacement, transférez le handle, videz le handle source et libérez l’ancien état de la destination lors de l’affectation par déplacement.
Avec PImpl, struct Impl; déclare un type imbriqué incomplet. Le membre std::unique_ptr<Impl> est autorisé, mais son suppresseur par défaut exige que Impl soit complet au point d’appel. Déclarez ~Widget(); dans la classe, puis écrivez Widget::~Widget() = default; après la définition de Impl, généralement dans le fichier .cpp. = default demande au compilateur de générer la destruction habituelle des membres ; le deux-points du constructeur ouvre la liste d’initialisation des membres, qui initialise impl_ au lieu de lui affecter une valeur.
Un destructeur déclaré par l’utilisateur, même avec = default, empêche la déclaration implicite des deux opérations de déplacement. std::unique_ptr n’est pas copiable, donc Widget ne l’est pas non plus. Pour rendre Widget déplaçable, déclarez explicitement les deux opérations et définissez-les avec = default une fois Impl complet : l’affectation par déplacement peut détruire l’objet précédemment détenu par le impl_ de destination.
Exemples
#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");
}
}Résultat
leaving task scope frame: promise destroyed leaving widget scope widget: implementation destroyed
La sortie est attendue, non mesurée. `finish()` atteint `co_return` et reste suspendue au point de suspension final jusqu’à la sortie de portée de `Task`. Après le déplacement, seul `second` possède l’objet `Impl` : chaque message de destruction s’affiche une fois. L’exemple nécessite la prise en charge de `<coroutine>` en mode C++23.
Leçons associées
- C++ · Leçon 41 · Avancé · Version : 3
- C++ · Leçon 42 · Avancé · Version : 3
- C++ · Leçon 43 · Avancé · Version : 3
- C++ · Leçon 57 · Avancé · Version : 3
Sources
- 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]