CKTIS / C++
`= delete`: funciones eliminadas y propiedad exclusiva
`= delete` prohíbe usar una función en tiempo de compilación. Así, el propietario de un marco de corrutina puede impedir las copias, transferir la propiedad mediante movimiento y liberar el marco en su destructor.
Versión: ISO C++23; implementation support may vary
Sintaxis
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 explícitamente una función como eliminada y debe aparecer en su primera declaración. La función sigue participando en la resolución de sobrecargas. Si resulta seleccionada, el programa está mal formado: para f(3.5), la eliminada f(double) es preferible a f(int) y no se recurre a f(int). Tampoco se puede tomar la dirección de una función eliminada.
Elimina el constructor de copia y el operador de asignación por copia para evitar que dos objetos sean propietarios del mismo marco. En const Task&, & declara una referencia a lvalue; en Task&&, && declara una referencia a rvalue. std::move no transfiere el recurso por sí solo: entre objetos distintos, las operaciones de movimiento del propietario transfieren el identificador y dejan vacío el origen. La asignación por movimiento entre objetos distintos libera primero el marco que ya posea el destino, si lo hay. La asignación por movimiento de un objeto a sí mismo no lo modifica.
~Task() es un destructor, no el operador de complemento bit a bit ~. Si el identificador no está vacío, el propietario llama a destroy() solo si aquel se refiere a una corrutina viva y suspendida. = delete no destruye objetos ni libera memoria; delete p y delete[] p son expresiones distintas que actúan en tiempo de ejecución.
= default solicita la definición prevista por las reglas del lenguaje, que aun así pueden dar lugar a una función eliminada; no es la etiqueta default: de switch. Aquí, h_{} proporciona un estado inicial vacío. Las operaciones de movimiento generadas por defecto para el propio identificador de corrutina no vaciarían el origen. La sintaxis = delete; existe desde C++11; el ejemplo está dirigido a C++23 y la compatibilidad puede variar según la implementación.
Ejemplos
#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
La corrutina permanece en su punto de suspensión inicial. Tras dos movimientos, solo `c` posee el marco. Su destructor llama a `destroy()`, por lo que el destructor del objeto promesa imprime `promise destroyed` una sola vez. Descomenta cada línea de copia por separado para comprobar que se rechaza.
Lecciones relacionadas
- C++ · Lección 41 · Avanzado · Versión: 3
- C++ · Lección 42 · Avanzado · Versión: 3
- C++ · Lección 43 · Avanzado · Versión: 3
- C++ · Lección 45 · Avanzado · Versión: 3
Fuentes
- 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]