CKTIS / C++
`= delete`: funzioni eliminate e proprietà esclusiva
`= delete` vieta l’uso di una funzione in fase di compilazione. Il proprietario di un frame di coroutine può così vietare la copia, trasferire la proprietà tramite spostamento e liberare il frame nel distruttore.
Versione: ISO C++23; implementation support may vary
Sintassi
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; definisce esplicitamente una funzione come eliminata e deve comparire nella sua prima dichiarazione. La funzione continua a partecipare alla risoluzione del sovraccarico. Se viene selezionata, il programma è mal formato: per f(3.5), la funzione eliminata f(double) prevale su f(int) e non si ripiega su f(int). Non si può nemmeno prendere l’indirizzo di una funzione eliminata.
Elimina il costruttore di copia e l’operatore di assegnazione per copia per evitare che due oggetti possiedano lo stesso frame. In const Task&, & dichiara un riferimento a lvalue; in Task&&, && dichiara un riferimento a rvalue. std::move non trasferisce la risorsa da solo: tra oggetti distinti, le operazioni di spostamento del proprietario trasferiscono l’handle e svuotano la sorgente. L’assegnazione per spostamento tra oggetti distinti libera prima l’eventuale frame già posseduto dalla destinazione. L’assegnazione per spostamento di un oggetto a sé stesso lo lascia invariato.
~Task() è un distruttore, non l’operatore di complemento bit a bit ~. Se l’handle non è vuoto, il proprietario chiama destroy() solo quando l’handle si riferisce a una coroutine ancora in vita e sospesa. = delete non distrugge oggetti né libera memoria; delete p e delete[] p sono espressioni distinte che agiscono in fase di esecuzione.
= default richiede la definizione prevista dalle regole del linguaggio, che può comunque risultare eliminata; non è l’etichetta default: di switch. Qui, grazie a h_{}, lo stato iniziale è vuoto. Le operazioni di spostamento predefinite dell’handle stesso non svuoterebbero la sorgente. La sintassi = delete; è disponibile da C++11; l’esempio è per C++23 e il supporto può variare tra implementazioni.
Esempi
#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");
}Risultato
leaving scope promise destroyed
La coroutine rimane nel punto di sospensione iniziale. Dopo due spostamenti, solo `c` possiede il frame. Il suo distruttore chiama `destroy()`, quindi il distruttore dell’oggetto promise stampa `promise destroyed` una sola volta. Decommenta separatamente ciascuna riga di copia per verificarne il rifiuto.
Lezioni correlate
- C++ · Lezione 41 · Avanzato · Versione: 3
- C++ · Lezione 42 · Avanzato · Versione: 3
- C++ · Lezione 43 · Avanzato · Versione: 3
- C++ · Lezione 45 · Avanzato · Versione: 3
Fonti
- Working Draft, Standard for Programming Language C++ (N4950, C++23)
- Deleted definitions [dcl.fct.def.delete]
- Explicitly-defaulted functions [dcl.fct.def.default]
- Copy/move constructors [class.copy.ctor]
- Copy/move assignment operator [class.copy.assign]
- References [dcl.ref]
- Destructors [class.dtor]
- Delete [expr.delete]
- Coroutines [dcl.fct.def.coroutine]
- Coroutine handle resumption and destruction [coroutine.handle.resumption]