WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

`= delete`: gelöschte Funktionen und exklusiver Besitz

`= delete` verbietet die Verwendung einer Funktion zur Kompilierzeit. Damit kann der Besitzer eines Koroutinenrahmens Kopien verbieten, den Besitz aber verschieben und den Rahmen im Destruktor freigeben.

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

Syntax

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; definiert eine Funktion ausdrücklich als gelöscht und muss in ihrer ersten Deklaration stehen. Die Funktion nimmt weiterhin an der Überladungsauflösung teil. Wird eine gelöschte Funktion ausgewählt, ist das Programm nicht wohlgeformt: Bei f(3.5) gewinnt das gelöschte f(double) gegen f(int), ohne Rückgriff auf f(int). Auch die Adresse einer gelöschten Funktion darf nicht gebildet werden.

Lösche den Kopierkonstruktor und den Kopierzuweisungsoperator, damit nicht zwei Objekte denselben Rahmen besitzen. In const Task& bezeichnet & eine Lvalue-Referenz, in Task&& bezeichnet && eine Rvalue-Referenz. std::move überträgt die Ressource nicht selbst: Beim Verschieben zwischen verschiedenen Objekten übertragen die Verschiebeoperationen des Besitzers das Handle und leeren die Quelle. Bei einer Verschiebezuweisung zwischen verschiedenen Objekten wird ein eventuell bereits vom Ziel besessener Rahmen zuerst freigegeben. Eine Verschiebezuweisung an sich selbst lässt das Objekt unverändert.

~Task() ist ein Destruktor, nicht der Operator für das bitweise Komplement ~. Bei einem nichtleeren Handle ruft der Besitzer destroy() nur auf, wenn das Handle auf eine noch lebende, suspendierte Koroutine verweist. = delete zerstört kein Objekt und gibt keinen Speicher frei; delete p und delete[] p sind separate Ausdrücke zur Laufzeit.

= default fordert die durch die Sprachregeln bestimmte Definition an, die auch gelöscht sein kann; es ist keine switch-Marke wie default:. Hier ergibt sich dank h_{} ein leerer Anfangszustand. Standardmäßig erzeugte Verschiebeoperationen für das Koroutinen-Handle selbst würden die Quelle nicht leeren. = delete; gibt es seit C++11; das Beispiel zielt auf C++23, und die Unterstützung kann je nach Implementierung variieren.

Beispiele

#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");
}

Ergebnis

leaving scope
promise destroyed

Die Koroutine bleibt am anfänglichen Suspendierungspunkt. Nach zwei Verschiebeoperationen besitzt nur `c` den Rahmen. Sein Destruktor ruft `destroy()` auf, sodass der Destruktor des Promise-Objekts einmal `promise destroyed` ausgibt. Aktiviere die beiden auskommentierten Kopierzeilen einzeln, um die Ablehnung zu prüfen.

Zugehörige Lektionen

  • C++ · Lektion 41 · Fortgeschritten · Version: 3
  • C++ · Lektion 42 · Fortgeschritten · Version: 3
  • C++ · Lektion 43 · Fortgeschritten · Version: 3
  • C++ · Lektion 45 · Fortgeschritten · Version: 3

Quellen