Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Funzione eliminata (`= delete`)

Rifiuta uno specifico overload o impedisci la copia in fase di compilazione, mantenendo lo spostamento e la corretta distruzione dell’implementazione nascosta.

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

Sintassi

void f(int) = delete;
// Inside class T:
T(const T&) = delete;
T& operator=(const T&) = delete;

In C++23, = delete; definisce esplicitamente una funzione come eliminata e deve comparire nella sua prima dichiarazione. Non si può chiamare quella funzione né prenderne l’indirizzo. Vale sia per le funzioni membro sia per quelle a livello di namespace. Non è un’espressione come delete p;, che serve a distruggere un oggetto e a liberarne la memoria, non a disabilitare una funzione.

Un overload eliminato esplicitamente con = delete continua a partecipare alla risoluzione degli overload. Con void f(double); e void f(int) = delete;, f(1) seleziona la corrispondenza esatta f(int) e non è valido: il compilatore non ripiega su f(double). La chiamata f(1.0) seleziona f(double). Invece, un costruttore di spostamento o un operatore di assegnazione per spostamento per cui è richiesta la definizione predefinita viene ignorato nella risoluzione degli overload se è definito come eliminato.

Widget elimina il costruttore di copia e l’operatore di assegnazione per copia. Per il costruttore di spostamento, l’operatore di assegnazione per spostamento e il distruttore usa invece = default, chiedendo al compilatore di generarli secondo le regole del linguaggio. Una funzione così specificata può comunque essere definita come eliminata se manca un’operazione necessaria su un membro o su una classe base.

Nell’idioma PImpl, si può dichiarare std::unique_ptr<Impl> quando Impl è ancora incompleto, ma il deleter predefinito richiede un tipo completo. Questo conta per la distruzione e per l’assegnazione per spostamento, che può distruggere l’oggetto posseduto in precedenza dalla destinazione. L’esempio definisce il distruttore e le due operazioni di spostamento fuori dalla classe, dopo la definizione di Impl. Separando il codice, le dichiarazioni restano nell’header e queste definizioni vanno nel file .cpp.

Esempi

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

Risultato

false false true

I controlli `static_assert` confermano che la copia è vietata e lo spostamento è consentito. `false false true` indica che dopo entrambi gli spostamenti solo `c` possiede un `Impl`. Togli il commento a un tentativo di copia alla volta per osservare un errore di compilazione.

Lezioni correlate

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

Fonti