CKTIS / C++
Fonction supprimée (`= delete`)
Interdisez une surcharge précise ou la copie dès la compilation, tout en conservant le déplacement et la destruction correcte de l’implémentation cachée.
Version : ISO C++23; implementation support may vary
Syntaxe
void f(int) = delete;
// Inside class T:
T(const T&) = delete;
T& operator=(const T&) = delete;En C++23, = delete; définit explicitement une fonction comme supprimée et doit figurer dans sa première déclaration. Il est interdit d’appeler cette fonction ou de prendre son adresse. Cela vaut pour les fonctions membres comme pour les fonctions déclarées dans un espace de noms. Ce n’est pas une expression comme delete p;, qui sert à détruire un objet et à libérer sa mémoire, non à interdire une fonction.
Une surcharge explicitement supprimée avec = delete participe toujours à la résolution de surcharge. Avec void f(double); et void f(int) = delete;, f(1) sélectionne la correspondance exacte f(int) et est mal formé : le compilateur ne se rabat pas sur f(double). L’appel f(1.0) sélectionne f(double). En revanche, un constructeur de déplacement ou un opérateur d’affectation par déplacement spécifié par défaut est ignoré lors de la résolution de surcharge s’il est défini comme supprimé.
Widget supprime le constructeur de copie et l’opérateur d’affectation par copie. Pour le constructeur de déplacement, l’opérateur d’affectation par déplacement et le destructeur, = default demande au compilateur de les générer selon les règles du langage. Une fonction ainsi spécifiée peut tout de même être définie comme supprimée si une opération requise sur un membre ou une classe de base est indisponible.
Dans l’idiome PImpl, on peut déclarer std::unique_ptr<Impl> alors que Impl est encore incomplet, mais le suppresseur par défaut exige un type complet. Cela compte pour la destruction et pour l’affectation par déplacement, qui peut détruire l’objet précédemment détenu par la destination. L’exemple définit le destructeur et les deux opérations de déplacement hors de la classe, après la définition de Impl. Si le code est séparé, les déclarations restent dans l’en-tête et ces définitions vont dans le fichier .cpp.
Exemples
#include <iostream>
#include <memory>
#include <type_traits>
#include <utility>
class Widget {
public:
Widget();
~Widget();
Widget(const Widget&) = delete;
Widget& operator=(const Widget&) = delete;
Widget(Widget&&) noexcept;
Widget& operator=(Widget&&) noexcept;
bool has_impl() const noexcept { return static_cast<bool>(impl_); }
private:
struct Impl;
std::unique_ptr<Impl> impl_;
};
struct Widget::Impl {};
Widget::Widget() : impl_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;
static_assert(!std::is_copy_constructible_v<Widget>);
static_assert(!std::is_copy_assignable_v<Widget>);
static_assert(std::is_move_constructible_v<Widget>);
static_assert(std::is_move_assignable_v<Widget>);
int main() {
Widget a;
// Widget copy(a);
Widget b(std::move(a));
Widget c;
// c = b;
c = std::move(b);
std::cout << std::boolalpha << a.has_impl() << ' '
<< b.has_impl() << ' ' << c.has_impl() << '\n';
}
Résultat
false false true
Les vérifications `static_assert` confirment que la copie est interdite et le déplacement autorisé. `false false true` signifie que seul `c` détient un `Impl` après les deux déplacements. Décommentez l’une ou l’autre tentative de copie, séparément, pour obtenir une erreur de compilation.
Leçons associées
- C++ · Leçon 11 · Avancé · Version : 3
Sources
- Deleted definitions [dcl.fct.def.delete]
- Explicitly-defaulted functions [dcl.fct.def.default]
- Delete [expr.delete]
- Default deleter for single objects [unique.ptr.dltr.dflt]
- unique_ptr constructors [unique.ptr.single.ctor]
- unique_ptr destructor [unique.ptr.single.dtor]
- unique_ptr assignment [unique.ptr.single.asgn]
- C++23 working draft N4950