Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / C++

`= delete`: funções eliminadas e propriedade exclusiva

`= delete` proíbe a utilização de uma função em tempo de compilação. O proprietário de um contexto de corrotina pode assim impedir cópias, transferir a propriedade por movimento e libertar o contexto no destrutor.

Versão: ISO C++23; implementation support may vary

Sintaxe

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; define explicitamente uma função como eliminada e tem de constar da sua primeira declaração. A função continua a participar na resolução de sobrecargas. Se for selecionada, o programa é malformado: para f(3.5), a função eliminada f(double) prevalece sobre f(int) e não há recurso a f(int). Também não é permitido obter o endereço de uma função eliminada.

Elimina o construtor de cópia e o operador de atribuição por cópia para impedir que dois objetos sejam proprietários do mesmo contexto de corrotina. Em const Task&, & declara uma referência a lvalue; em Task&&, && declara uma referência a rvalue. std::move não transfere o recurso por si só: entre objetos distintos, as operações de movimento do proprietário transferem o identificador e deixam a origem vazia. A atribuição por movimento entre objetos distintos começa por libertar o contexto que o destino já possua, se existir. A atribuição por movimento de um objeto a si próprio deixa-o inalterado.

~Task() é um destrutor, não o operador de complemento bit a bit ~. Se o identificador não estiver vazio, o proprietário só chama destroy() se este se referir a uma corrotina suspensa que ainda esteja viva. = delete não destrói objetos nem liberta memória; delete p e delete[] p são expressões distintas que atuam em tempo de execução.

= default pede a definição prevista pelas regras da linguagem, que ainda pode resultar numa função eliminada; não é a etiqueta default: de switch. Aqui, h_{} garante um estado inicial vazio. As operações de movimento geradas por omissão para o próprio identificador da corrotina não esvaziariam a origem. A sintaxe = delete; existe desde C++11; o exemplo destina-se a C++23 e o suporte pode variar entre implementações.

Exemplos

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

Resultado

leaving scope
promise destroyed

A corrotina permanece no ponto de suspensão inicial. Após dois movimentos, só `c` possui o contexto. O seu destrutor chama `destroy()`, pelo que o destrutor do objeto de promessa escreve `promise destroyed` uma única vez. Retira o comentário de cada linha de cópia separadamente para verificar que é rejeitada.

Lições relacionadas

  • C++ · Lição 41 · Avançado · Versão: 3
  • C++ · Lição 42 · Avançado · Versão: 3
  • C++ · Lição 43 · Avançado · Versão: 3
  • C++ · Lição 45 · Avançado · Versão: 3

Fontes