Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

`= delete`: odstraněné funkce a výhradní vlastnictví

`= delete` zakazuje použití funkce už při překladu. Vlastník rámce korutiny tak může zakázat kopírování, předávat vlastnictví přesunem a uvolňovat rámec v destruktoru.

Verze: 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; explicitně definuje funkci jako odstraněnou a musí být uvedeno v její první deklaraci. Funkce se stále účastní výběru přetížené funkce. Pokud je vybrána, je program nesprávně utvořený: pro f(3.5) má odstraněná f(double) přednost před f(int) a f(int) se nepoužije jako náhrada. Nelze ani získat adresu odstraněné funkce.

Označ kopírovací konstruktor a operátor přiřazení kopírováním jako odstraněné, aby tentýž rámec neměli dva vlastníci. V const Task& deklaruje & referenci na lvalue, v Task&& deklaruje && referenci na rvalue. Samotné std::move zdroj nepředává: při přesunu mezi různými objekty operace přesunu vlastníka předají úchyt a ponechají zdrojový objekt prázdný. Přiřazení přesunem mezi různými objekty nejprve uvolní rámec, který cílový objekt případně již vlastní. Přiřazení přesunem objektu sobě samému jej ponechá beze změny.

~Task() je destruktor, nikoli operátor bitového doplňku ~. U neprázdného úchytu volá vlastník destroy() pouze tehdy, když úchyt odkazuje na stále živou, pozastavenou korutinu. = delete neničí objekty ani neuvolňuje paměť; delete p a delete[] p jsou samostatné výrazy vyhodnocované za běhu.

= default požaduje definici podle pravidel jazyka, která mohou vést i k odstraněné funkci; není to návěští default: v příkazu switch. Díky h_{} je zde počáteční stav prázdný. Výchozí operace přesunu samotného úchytu korutiny by zdrojový objekt nevyprázdnily. Syntaxe = delete; je dostupná od C++11; příklad cílí na C++23 a podpora se může mezi implementacemi lišit.

Příklady

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

Výsledek

leaving scope
promise destroyed

Korutina zůstane v počátečním bodě pozastavení. Po dvou přesunech vlastní rámec pouze `c`. Jeho destruktor zavolá `destroy()`, takže destruktor objektu promise jednou vypíše `promise destroyed`. Každý řádek s kopírováním odkomentuj zvlášť a ověř, že ho překladač odmítne.

Související lekce

  • C++ · Lekce 41 · Pokročilá · Verze: 3
  • C++ · Lekce 42 · Pokročilá · Verze: 3
  • C++ · Lekce 43 · Pokročilá · Verze: 3
  • C++ · Lekce 45 · Pokročilá · Verze: 3

Zdroje