CKTIS / C++
Copie interdite (`= delete`) et destructeur virtuel par défaut (`= default`)
Interdisez séparément la construction et l’affectation par copie, et laissez le compilateur définir un destructeur virtuel pour détruire correctement un objet via un pointeur de base.
Version : ISO C++23; implementation support may vary
Syntaxe
struct Base {
Base() = default;
Base(const Base&) = delete;
Base& operator=(const Base&) = delete;
virtual ~Base() = default;
};Base(const Base&) = delete; interdit de construire un nouvel objet Base par copie, tandis que Base& operator=(const Base&) = delete; interdit l’affectation par copie d’un objet existant. Les deux fonctions participent toujours à la résolution de surcharge. Utiliser directement l’une de ces fonctions supprimées dans l’exemple rend le programme mal formé et exige un diagnostic. En revanche, si la substitution des arguments de modèle rend une exigence dépendante invalide parce qu’une fonction supprimée est sélectionnée, l’expression requires peut s’évaluer à false sans diagnostic. = delete ne libère pas de mémoire.
Dans virtual ~Base() = default;, virtual permet la liaison dynamique et = default demande au compilateur de fournir la définition habituelle du destructeur. Celui-ci détruit toujours les sous-objets membres et de base : = default ne signifie pas qu’il ne fait rien et n’équivaut pas à = 0. Si un membre a un destructeur supprimé, le destructeur par défaut de la classe peut lui-même être défini comme supprimé.
Avec un delete p ordinaire sur un seul objet, si Base* p pointe vers un Derived créé par new, la liaison dynamique garantit l’exécution de ~Derived() puis de ~Base(). Sans destructeur virtuel dans la classe de base, le comportement serait indéfini dans ce cas. Cette règle ne permet pas de détruire un tableau d’objets dérivés via un pointeur de base avec delete[].
Le constructeur de copie supprimé reste déclaré par l’utilisateur : l’exemple ajoute donc explicitement Base() = default;. Les opérations de copie et le destructeur déclarés empêchent aussi la déclaration implicite du constructeur et de l’opérateur d’affectation par déplacement de Base. Interdire la copie ne suffit donc pas à obtenir un type seulement déplaçable. Ces règles sont décrites pour ISO C++23 ; la prise en charge peut varier selon l’implémentation.
Exemples
#include <iostream>
#include <type_traits>
struct Base {
Base() = default;
Base(const Base&) = delete;
Base& operator=(const Base&) = delete;
virtual ~Base() = default;
};
struct Derived final : Base {
~Derived() override {
std::cout << "Derived destroyed\n";
}
};
static_assert(!std::is_copy_constructible_v<Base>);
static_assert(!std::is_copy_assignable_v<Base>);
int main() {
Base* p = new Derived;
delete p;
// Base a, b;
// Base c(a);
// b = a;
}
Résultat
Derived destroyed
Les `static_assert` vérifient que les deux opérations de copie sont indisponibles. `delete p` exécute le destructeur de `Derived`, qui affiche `Derived destroyed`, puis celui de `Base`, qui n’affiche rien. Décommentez `Base a, b;` et essayez séparément `Base c(a);` et `b = a;` : chaque instruction doit provoquer une erreur de compilation.
Leçons associées
- C++ · Leçon 55 · Intermédiaire · Version : 2