CKTIS / C++
`= delete`: verwijderde functies en exclusief eigendom
`= delete` verbiedt het gebruik van een functie tijdens het compileren. Een eigenaar van een coroutineframe kan zo kopiëren verbieden, het eigendom verplaatsen en het frame in zijn destructor vrijgeven.
Versie: 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; definieert een functie expliciet als verwijderd en moet bij haar eerste declaratie staan. De functie blijft meedoen aan de overloadresolutie. Wordt ze geselecteerd, dan is het programma niet geldig: bij f(3.5) wint de verwijderde f(double) van f(int), zonder terugval op f(int). Ook het adres van een verwijderde functie mag je niet opvragen.
Verwijder de kopieerconstructor en de kopieertoewijzingsoperator om te voorkomen dat twee objecten hetzelfde frame bezitten. In const Task& declareert & een lvalue-referentie; in Task&& declareert && een rvalue-referentie. std::move draagt de resource niet zelf over: tussen verschillende objecten dragen de verplaatsingsbewerkingen van de eigenaar de handle over en maken ze de bron leeg. Bij verplaatsingstoewijzing tussen verschillende objecten wordt eerst het frame vrijgegeven dat het doel eventueel al bezit. Verplaatsingstoewijzing van een object aan zichzelf laat het object ongewijzigd.
~Task() is een destructor, niet de bitsgewijze complementoperator ~. Bij een niet-lege handle roept de eigenaar destroy() alleen aan als de handle verwijst naar een nog levende, gesuspendeerde coroutine. = delete vernietigt geen object en geeft geen geheugen vrij; delete p en delete[] p zijn aparte expressies die tijdens de uitvoering werken.
= default vraagt om de definitie volgens de taalregels, die alsnog een verwijderde functie kunnen opleveren; het is niet het label default: van switch. Hier zorgt h_{} voor een lege begintoestand. Standaard gegenereerde verplaatsingsbewerkingen voor de coroutinehandle zelf zouden de bron niet leegmaken. De syntaxis = delete; bestaat sinds C++11; het voorbeeld is gericht op C++23 en de ondersteuning kan per implementatie verschillen.
Voorbeelden
#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");
}Resultaat
leaving scope promise destroyed
De coroutine blijft op haar eerste suspensiepunt. Na twee verplaatsingen bezit alleen `c` het frame. Zijn destructor roept `destroy()` aan, zodat de destructor van het promise-object één keer `promise destroyed` afdrukt. Haal de twee kopieerregels afzonderlijk uit commentaar om te controleren of ze worden afgewezen.
Gerelateerde lessen
- C++ · Les 41 · Gevorderd · Versie: 3
- C++ · Les 42 · Gevorderd · Versie: 3
- C++ · Les 43 · Gevorderd · Versie: 3
- C++ · Les 45 · Gevorderd · Versie: 3
Bronnen
- 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]