Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

`= delete` : fonctions supprimées et propriété exclusive

`= delete` interdit l’utilisation d’une fonction à la compilation. Le propriétaire d’un cadre de coroutine peut ainsi interdire la copie, transférer la propriété par déplacement et libérer le cadre dans son destructeur.

Version : ISO C++23; implementation support may vary

Syntaxe

void f(int);
void f(double) = delete;

struct Task {
    Task() noexcept = default;
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;
    Task(Task&&) noexcept;
    Task& operator=(Task&&) noexcept;
    ~Task();
};

= delete; définit explicitement une fonction comme supprimée et doit figurer dans sa première déclaration. La fonction participe toujours à la résolution de surcharge. Si elle est sélectionnée, le programme est mal formé : pour f(3.5), la surcharge supprimée f(double) l’emporte sur f(int), sans repli sur f(int). Prendre l’adresse d’une fonction supprimée est également interdit.

Supprimez le constructeur de copie et l’opérateur d’affectation par copie pour éviter que deux objets possèdent le même cadre. Dans const Task&, & déclare une référence de lvalue ; dans Task&&, && déclare une référence de rvalue. std::move ne transfère pas la ressource à lui seul : entre objets distincts, les opérations de déplacement du propriétaire transfèrent le handle et vident la source. L’affectation par déplacement entre objets distincts libère d’abord le cadre éventuellement détenu par la destination. L’affectation par déplacement d’un objet à lui-même le laisse inchangé.

~Task() est un destructeur, pas l’opérateur de complément bit à bit ~. Si le handle n’est pas vide, le propriétaire n’appelle destroy() que s’il désigne une coroutine encore en vie et suspendue. = delete ne détruit aucun objet et ne libère pas de mémoire ; delete p et delete[] p sont des expressions distinctes qui agissent à l’exécution.

= default demande la définition prévue par les règles du langage, qui peut encore aboutir à une fonction supprimée ; ce n’est pas une étiquette default: de switch. Ici, h_{} donne un état initial vide. Les opérations de déplacement par défaut du handle de coroutine lui-même ne videraient pas la source. La syntaxe = delete; existe depuis C++11 ; l’exemple cible C++23 et sa prise en charge dépend de l’implémentation.

Exemples

#include <coroutine>
#include <cstdio>
#include <exception>
#include <utility>

class Task {
public:
    struct promise_type;

private:
    using Handle = std::coroutine_handle<promise_type>;
    Handle h_{};

    explicit Task(Handle h) noexcept : h_(h) {}

public:
    struct promise_type {
        Task get_return_object() noexcept {
            return Task{Handle::from_promise(*this)};
        }
        std::suspend_always 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("promise destroyed"); }
    };

    Task() noexcept = default;
    Task(const Task&) = delete;
    Task& operator=(const Task&) = delete;

    Task(Task&& other) noexcept : h_(std::exchange(other.h_, Handle{})) {}

    Task& operator=(Task&& other) noexcept {
        if (this != &other) {
            if (h_) h_.destroy();
            h_ = std::exchange(other.h_, Handle{});
        }
        return *this;
    }

    ~Task() {
        if (h_) h_.destroy();
    }
};

Task make_task() { co_return; }

int main() {
    Task a = make_task();
    // Task copy = a;
    Task b{std::move(a)};
    Task c;
    // c = b;
    c = std::move(b);
    std::puts("leaving scope");
}

Résultat

leaving scope
promise destroyed

La coroutine reste à son point de suspension initial. Après deux déplacements, seul `c` possède le cadre. Son destructeur appelle `destroy()`, et le destructeur de l’objet promesse affiche `promise destroyed` une seule fois. Décommentez séparément chaque ligne de copie pour vérifier son rejet.

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 45 · Avancé · Version : 3

Sources