Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Funzioni eliminate (`= delete`) in C++

`= delete` vieta l’uso di una funzione specifica in fase di compilazione, per esempio per rifiutare un overload indesiderato o impedire la copia e lo spostamento di un pool proprietario.

Versione: ISO C++23; implementation support may vary

Sintassi

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;
};

Disponibile da C++11 e presente in ISO C++23, la sintassi = delete; definisce esplicitamente una funzione come eliminata già alla prima dichiarazione, senza un corpo tra parentesi graffe. Vale sia per le funzioni membro sia per quelle con ambito di namespace. Invocare una funzione eliminata, anche implicitamente, o prenderne l’indirizzo è un errore di compilazione, non di esecuzione.

Un overload eliminato esplicitamente partecipa ancora alla risoluzione degli overload. Se viene selezionato, la chiamata è mal formata: il compilatore non ripiega su un overload meno adatto. In Pool{42.0}, Pool(double) corrisponde esattamente all’argomento, quindi la conversione a int non salva la chiamata. La risoluzione ignora invece un costruttore di spostamento o un operatore di assegnazione per spostamento dichiarato default che viene definito come eliminato.

Pool possiede un solo slot e conserva un puntatore all’oggetto nel proprio buffer. Copiare soltanto il valore del puntatore lo lascerebbe puntare al buffer del pool di origine. La classe elimina quindi esplicitamente sia il costruttore e l’operatore di assegnazione per copia sia il costruttore e l’operatore di assegnazione per spostamento.

La forma standard non allocante ::new (indirizzo) T{...} costruisce un oggetto in memoria già disponibile, di dimensione sufficiente e correttamente allineata. La chiamata esplicita al distruttore item_->~Item() termina la vita dell’oggetto senza deallocare il buffer. Le espressioni delete p e delete[] p servono a distruggere gli oggetti e a rilasciare la memoria ottenuta con la corrispondente forma allocante di new. Non usarle per l’oggetto in questo buffer. = delete non distrugge oggetti né rilascia memoria.

Esempi

#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};
}

Risultato

42

Le quattro verifiche `static_assert` coprono la costruzione e l’assegnazione per copia e per spostamento. Il programma dovrebbe stampare `42`. Rimuovi il commento da ciascuna delle ultime due dichiarazioni, una alla volta: la compilazione dovrebbe fallire perché viene selezionato un costruttore eliminato.

Lezioni correlate

  • C++ · Lezione 19 · Avanzato · Versione: 3

Fonti