Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

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