Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

`= delete`: odstránené funkcie a výhradné vlastníctvo

`= delete` zakazuje použitie funkcie už pri preklade. Vlastník rámca korutiny tak môže zakázať kopírovanie, prenášať vlastníctvo presunom a uvoľniť rámec v deštruktore.

Verzia: 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; explicitne definuje funkciu ako odstránenú a musí byť uvedené v jej prvej deklarácii. Funkcia sa naďalej zúčastňuje výberu preťaženia. Ak je vybraná, program nie je správne utvorený: pre f(3.5) má odstránená f(double) prednosť pred f(int) a f(int) sa nepoužije ako náhrada. Nie je dovolené ani získať adresu odstránenej funkcie.

Označ kopírovací konštruktor a operátor priradenia kopírovaním ako odstránené, aby ten istý rámec nemali dvaja vlastníci. V const Task& deklaruje & referenciu na lvalue, v Task&& deklaruje && referenciu na rvalue. Samotné std::move neprenáša vlastníctvo rámca: pri presune medzi rôznymi objektmi operácie presunu vlastníka prenesú úchyt a zanechajú zdrojový objekt prázdny. Priradenie presunom medzi rôznymi objektmi najprv uvoľní rámec, ktorý cieľový objekt už prípadne vlastní. Priradenie presunom objektu do seba samého ho ponechá bez zmeny.

~Task() je deštruktor, nie operátor bitového doplnku ~. Pri neprázdnom úchyte vlastník volá destroy() iba vtedy, keď úchyt odkazuje na stále živú, pozastavenú korutinu. = delete neničí objekty ani neuvoľňuje pamäť; delete p a delete[] p sú samostatné výrazy vyhodnocované za behu.

= default žiada definíciu podľa pravidiel jazyka, ktoré môžu viesť aj k odstránenej funkcii; nejde o návestie default: v príkaze switch. Vďaka h_{} je tu počiatočný stav prázdny. Predvolené operácie presunu samotného úchytu korutiny by zdrojový objekt nevyprázdnili. Syntax = delete; je dostupná od C++11; príklad je určený pre C++23 a podpora sa môže medzi implementáciami líšiť.

Prí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ýsledok

leaving scope
promise destroyed

Korutina zostáva v počiatočnom bode pozastavenia. Po dvoch presunoch vlastní rámec iba `c`. Jeho deštruktor zavolá `destroy()`, takže deštruktor objektu promise raz vypíše `promise destroyed`. Každý riadok s kopírovaním odkomentuj zvlášť a over, že ho prekladač odmietne.

Súvisiace lekcie

  • C++ · Lekcia 41 · Pokročilá · Verzia: 3
  • C++ · Lekcia 42 · Pokročilá · Verzia: 3
  • C++ · Lekcia 43 · Pokročilá · Verzia: 3
  • C++ · Lekcia 45 · Pokročilá · Verzia: 3

Zdroje