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
- 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]