CKTIS / C++
`= default` — funzioni definite esplicitamente come predefinite in C++
`= default` chiede al compilatore di fornire la definizione standard di una funzione ammessa. La proprietà delle risorse, PImpl e i distruttori virtuali ne mostrano l’utilità.
Versione: ISO C++23; implementation support may vary
Sintassi
struct T {
T() = default;
T(const T&) = default;
T(T&&) = default;
T& operator=(const T&) = default;
T& operator=(T&&) = default;
~T();
bool operator==(const T&) const = default;
};
T::~T() = default;In C++23, = default; è una definizione esplicitamente predefinita, non un’assegnazione né un’etichetta default: di switch. Si usa per le funzioni membro speciali (da C++11) e per gli operatori di confronto ammessi (da C++20), come bool operator==(const T&) const = default;. Non si applica a una funzione qualsiasi e non ammette argomenti predefiniti. Il supporto può variare a seconda dell’implementazione.
Una funzione con = default alla prima dichiarazione è dichiarata dall’utente, ma non fornita dall’utente (user-provided). Una definizione successiva come T::~T() = default; è invece user-provided, il che può incidere sulla trivialità. Se un membro o una classe base impedisce l’operazione richiesta, la funzione può essere definita come eliminata. Se ciò avviene usando = default dopo la prima dichiarazione, il programma è mal formato.
In const T&, & dichiara un riferimento a lvalue; in T&&, && dichiara un riferimento a rvalue. Sono tipi di parametro tipici per copia e spostamento. = delete vieta esplicitamente l’uso di una funzione: se la risoluzione dell’overload la seleziona, la chiamata è mal formata. Non è un’espressione delete, che serve a distruggere un oggetto e a liberarne la memoria. Un tipo che contiene uno std::future può spostare l’handle dello stato condiviso, ma non può copiarlo membro per membro.
Con PImpl, dichiara Impl senza definirlo nell’header e conserva uno std::unique_ptr<Impl>. Il deleter predefinito richiede che Impl sia completo: definisci quindi il distruttore fuori dalla classe, dopo la definizione di Impl. Un distruttore dichiarato dall’utente impedisce la dichiarazione implicita di entrambe le operazioni di spostamento; se servono, dichiarale e definiscile con = default nello stesso punto. L’assegnazione per spostamento può eliminare il precedente Impl della destinazione. std::unique_ptr non è copiabile, e la lista di inizializzazione del costruttore inizializza il membro proprietario.
In un’interfaccia polimorfica per una strategia, = 0 indica una funzione virtuale pura. virtual ~Strategy() = default; definisce invece un distruttore virtuale pubblico, così un oggetto derivato viene distrutto correttamente tramite std::unique_ptr<Strategy>. Il chiamante inietta la strategia tramite il costruttore. Un registro di factory può associare nomi a factory di strategie già compilate e collegate al programma, senza caricare librerie dinamiche.
Esempi
#include <iostream>
#include <memory>
#include <stdexcept>
#include <utility>
struct Strategy {
virtual ~Strategy() = default;
virtual int apply(int value) const = 0;
};
struct Double final : Strategy {
int apply(int value) const override { return 2 * value; }
};
class Task {
public:
explicit Task(std::unique_ptr<Strategy> strategy);
~Task();
Task(Task&&) noexcept;
Task& operator=(Task&&) noexcept;
Task(const Task&) = delete;
Task& operator=(const Task&) = delete;
int run() const;
private:
struct Impl;
std::unique_ptr<Impl> impl_;
};
struct Task::Impl {
explicit Impl(std::unique_ptr<Strategy> s) : strategy(std::move(s)) {}
std::unique_ptr<Strategy> strategy;
};
Task::Task(std::unique_ptr<Strategy> s)
: impl_(std::make_unique<Impl>(std::move(s))) {}
Task::~Task() = default;
Task::Task(Task&&) noexcept = default;
Task& Task::operator=(Task&&) noexcept = default;
int Task::run() const {
if (!impl_ || !impl_->strategy) {
throw std::logic_error("no strategy");
}
return impl_->strategy->apply(21);
}
int main() {
Task original(std::make_unique<Double>());
Task owner(std::move(original));
std::cout << owner.run() << '\n';
}
Risultato
42
`main` inietta `Double`, poi il costruttore di spostamento predefinito trasferisce la proprietà di `Impl` da `original` a `owner`. La chiamata virtuale a `Double::apply(21)` produce `42`. L’esempio non copia l’oggetto e non chiama `run()` sull’oggetto sorgente dopo lo spostamento.
Lezioni correlate
- C++ · Lezione 45 · Avanzato · Versione: 3
- C++ · Lezione 57 · Avanzato · Versione: 3
- C++ · Lezione 59 · Avanzato · Versione: 3
Fonti
- WG21 N4950 — Working Draft, Standard for Programming Language C++ (C++23)
- Explicitly-defaulted functions [dcl.fct.def.default]
- Deleted definitions [dcl.fct.def.delete]
- Constructors [class.ctor]
- Copy/move assignment operator [class.copy.assign]
- Defaulted comparison operator functions [class.compare.default]
- Class template future [futures.unique.future]
- Default deleter [unique.ptr.dltr.dflt]
- GotW #7b Solution: Minimizing Compile-Time Dependencies, Part 2
- Abstract classes [class.abstract]
- Delete expressions [expr.delete]