CKTIS / C++
Función eliminada (`= delete`)
Rechaza una sobrecarga concreta o impide la copia en tiempo de compilación, sin renunciar al movimiento ni a la destrucción correcta de la implementación oculta.
Versión: ISO C++23; implementation support may vary
Sintaxis
void f(int) = delete;
// Inside class T:
T(const T&) = delete;
T& operator=(const T&) = delete;En C++23, = delete; define explícitamente una función como eliminada y debe aparecer en su primera declaración. No se puede llamar a esa función ni tomar su dirección. Se aplica tanto a funciones miembro como a funciones con ámbito de espacio de nombres. No es una expresión como delete p;, que sirve para destruir un objeto y liberar su memoria, no para deshabilitar una función.
Una sobrecarga eliminada explícitamente con = delete sigue participando en la resolución de sobrecargas. Con void f(double); y void f(int) = delete;, f(1) selecciona la coincidencia exacta f(int) y está mal formada: el compilador no recurre a f(double). La llamada f(1.0) selecciona f(double). En cambio, un constructor de movimiento o un operador de asignación por movimiento especificado como predeterminado se omite en la resolución de sobrecargas si queda definido como eliminado.
Widget elimina el constructor de copia y el operador de asignación por copia. En cambio, usa = default en el constructor de movimiento, el operador de asignación por movimiento y el destructor, para pedir al compilador que los genere conforme a las reglas del lenguaje. Una función así especificada todavía puede quedar definida como eliminada si no está disponible una operación necesaria de un miembro o de una clase base.
En el idioma de diseño PImpl, std::unique_ptr<Impl> se puede declarar mientras Impl sea incompleto, pero el eliminador predeterminado requiere un tipo completo. Esto importa en la destrucción y en la asignación por movimiento, que puede destruir el objeto que poseía el destino. El ejemplo define el destructor y ambas operaciones de movimiento fuera de la clase, después de definir Impl. Si se separa el código, las declaraciones quedan en la cabecera y estas definiciones van en el archivo .cpp.
Ejemplos
#include <iostream>
#include <memory>
#include <type_traits>
#include <utility>
class Widget {
public:
Widget();
~Widget();
Widget(const Widget&) = delete;
Widget& operator=(const Widget&) = delete;
Widget(Widget&&) noexcept;
Widget& operator=(Widget&&) noexcept;
bool has_impl() const noexcept { return static_cast<bool>(impl_); }
private:
struct Impl;
std::unique_ptr<Impl> impl_;
};
struct Widget::Impl {};
Widget::Widget() : impl_(std::make_unique<Impl>()) {}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;
static_assert(!std::is_copy_constructible_v<Widget>);
static_assert(!std::is_copy_assignable_v<Widget>);
static_assert(std::is_move_constructible_v<Widget>);
static_assert(std::is_move_assignable_v<Widget>);
int main() {
Widget a;
// Widget copy(a);
Widget b(std::move(a));
Widget c;
// c = b;
c = std::move(b);
std::cout << std::boolalpha << a.has_impl() << ' '
<< b.has_impl() << ' ' << c.has_impl() << '\n';
}
Resultado
false false true
Las comprobaciones `static_assert` confirman que la copia no se permite y el movimiento sí. `false false true` significa que solo `c` posee un `Impl` después de los dos movimientos. Descomenta por separado cada intento de copia para ver un error de compilación.
Lecciones relacionadas
- C++ · Lección 11 · Avanzado · Versión: 3
Fuentes
- Deleted definitions [dcl.fct.def.delete]
- Explicitly-defaulted functions [dcl.fct.def.default]
- Delete [expr.delete]
- Default deleter for single objects [unique.ptr.dltr.dflt]
- unique_ptr constructors [unique.ptr.single.ctor]
- unique_ptr destructor [unique.ptr.single.dtor]
- unique_ptr assignment [unique.ptr.single.asgn]
- C++23 working draft N4950