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