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

CKTIS / C++

Funciones eliminadas (`= delete`) en C++

`= delete` impide usar una función concreta en tiempo de compilación. Sirve para rechazar una sobrecarga no deseada o impedir que un pool propietario se copie o se mueva.

Versión: ISO C++23; implementation support may vary

Sintaxis

void f(int);
void f(double) = delete;

struct Pool {
    explicit Pool(int value);
    Pool(double) = delete;
    Pool(const Pool&) = delete;
    Pool& operator=(const Pool&) = delete;
    Pool(Pool&&) = delete;
    Pool& operator=(Pool&&) = delete;
};

La sintaxis = delete;, disponible desde C++11 e incluida en ISO C++23, define explícitamente una función como eliminada en su primera declaración, sin un cuerpo entre llaves. Se aplica tanto a las funciones miembro como a las que tienen ámbito de espacio de nombres. Invocar una función eliminada, incluso de forma implícita, o tomar su dirección es un error de compilación, no de ejecución.

Una sobrecarga eliminada explícitamente sigue participando en la resolución de sobrecargas. Si se selecciona, la llamada está mal formada: el compilador no recurre a una sobrecarga que encaje peor. En Pool{42.0}, Pool(double) es una coincidencia exacta, así que la conversión a int no salva la llamada. En cambio, la resolución de sobrecargas ignora un constructor de movimiento o un operador de asignación por movimiento declarado default que resulte definido como eliminado.

Pool posee un único espacio de almacenamiento y guarda un puntero al objeto en su propio búfer. Si solo se copiara el valor del puntero, este seguiría apuntando al búfer del pool de origen. Por eso la clase elimina explícitamente el constructor y el operador de asignación de copia, así como el constructor y el operador de asignación de movimiento.

La forma estándar no asignadora ::new (dirección) T{...} construye un objeto en almacenamiento existente, con tamaño y alineación adecuados. La llamada explícita al destructor item_->~Item() termina la vida del objeto sin liberar el búfer. Las expresiones delete p y delete[] p sirven para destruir objetos y liberar el almacenamiento obtenido mediante la forma correspondiente de new que reserva memoria. No las uses para el objeto de este búfer. = delete no destruye objetos ni libera almacenamiento.

Ejemplos

#include <cstddef>
#include <iostream>
#include <new>
#include <type_traits>

class Pool {
    struct Item { int value; };
    alignas(Item) std::byte slot_[sizeof(Item)];
    Item* item_;

public:
    explicit Pool(int value)
        : item_(::new (static_cast<void*>(slot_)) Item{value}) {}
    Pool(double) = delete;
    Pool(const Pool&) = delete;
    Pool& operator=(const Pool&) = delete;
    Pool(Pool&&) = delete;
    Pool& operator=(Pool&&) = delete;

    ~Pool() { item_->~Item(); }
    int value() const noexcept { return item_->value; }
};

static_assert(!std::is_copy_constructible_v<Pool>);
static_assert(!std::is_copy_assignable_v<Pool>);
static_assert(!std::is_move_constructible_v<Pool>);
static_assert(!std::is_move_assignable_v<Pool>);

int main() {
    Pool a{42};
    std::cout << a.value() << '\n';

    // Pool b = a;
    // Pool c{42.0};
}

Resultado

42

Las cuatro comprobaciones `static_assert` cubren la construcción y la asignación por copia y por movimiento. El programa debería imprimir `42`. Descomenta por separado cada una de las dos últimas declaraciones: la compilación debería fallar porque se selecciona un constructor eliminado.

Lecciones relacionadas

  • C++ · Lección 19 · Avanzado · Versión: 3

Fuentes