CKTIS / C++
Fonctions supprimées (`= delete`) en C++
`= delete` interdit l’utilisation d’une fonction précise à la compilation, par exemple pour bloquer une surcharge indésirable ou empêcher la copie et le déplacement d’un pool propriétaire.
Version : ISO C++23; implementation support may vary
Syntaxe
void f(int);
void f(double) = delete;
struct Pool {
explicit Pool(int value);
Pool(double) = delete;
Pool(const Pool&) = delete;
Pool& operator=(const Pool&) = delete;
Pool(Pool&&) = delete;
Pool& operator=(Pool&&) = delete;
};Disponible depuis C++11 et présente dans ISO C++23, la syntaxe = delete; définit explicitement une fonction comme supprimée dès sa première déclaration, sans corps entre accolades. Elle s’applique aux fonctions membres et aux fonctions déclarées à la portée d’un espace de noms. Appeler une telle fonction, même implicitement, ou prendre son adresse est une erreur de compilation, pas d’exécution.
Une surcharge explicitement supprimée participe toujours à la résolution de surcharge. Si elle est sélectionnée, l’appel est mal formé : le compilateur ne se rabat pas sur une surcharge moins bien adaptée. Pour Pool{42.0}, Pool(double) correspond exactement à l’argument : la conversion vers int ne rend donc pas l’appel valide. En revanche, la résolution ignore un constructeur ou un opérateur d’affectation de déplacement déclaré default qui se trouve défini comme supprimé.
Pool possède un seul emplacement et conserve un pointeur vers l’objet dans son propre tampon. Copier uniquement la valeur du pointeur le laisserait pointer dans le tampon du pool source. La classe supprime donc explicitement le constructeur et l’opérateur d’affectation de copie, ainsi que le constructeur et l’opérateur d’affectation de déplacement.
La forme standard non allouante ::new (adresse) T{...} construit un objet dans une zone de stockage existante, assez grande et correctement alignée. L’appel explicite au destructeur item_->~Item() met fin à la durée de vie de l’objet sans libérer le tampon. Les expressions delete p et delete[] p servent à détruire les objets et à libérer le stockage obtenu avec la forme allouante correspondante de new. Ne les utilise pas pour l’objet dans ce tampon. = delete ne détruit aucun objet et ne libère aucun stockage.
Exemples
#include <cstddef>
#include <iostream>
#include <new>
#include <type_traits>
class Pool {
struct Item { int value; };
alignas(Item) std::byte slot_[sizeof(Item)];
Item* item_;
public:
explicit Pool(int value)
: item_(::new (static_cast<void*>(slot_)) Item{value}) {}
Pool(double) = delete;
Pool(const Pool&) = delete;
Pool& operator=(const Pool&) = delete;
Pool(Pool&&) = delete;
Pool& operator=(Pool&&) = delete;
~Pool() { item_->~Item(); }
int value() const noexcept { return item_->value; }
};
static_assert(!std::is_copy_constructible_v<Pool>);
static_assert(!std::is_copy_assignable_v<Pool>);
static_assert(!std::is_move_constructible_v<Pool>);
static_assert(!std::is_move_assignable_v<Pool>);
int main() {
Pool a{42};
std::cout << a.value() << '\n';
// Pool b = a;
// Pool c{42.0};
}Résultat
42
Les quatre vérifications `static_assert` couvrent la construction et l’affectation par copie et par déplacement. Le programme devrait afficher `42`. Décommente chacune des deux dernières déclarations séparément : la compilation devrait échouer, car un constructeur supprimé est sélectionné.
Leçons associées
- C++ · Leçon 19 · Avancé · Version : 3
Sources
- Working Draft, Standard for Programming Language C++ (N4950, C++23)
- Deleted definitions [dcl.fct.def.delete]
- Copy/move constructors [class.copy.ctor]
- Copy/move assignment operator [class.copy.assign]
- Non-allocating forms [new.delete.placement]
- Destructors [class.dtor]
- Object lifetime [basic.life]
- Delete [expr.delete]