CKTIS / C++
Funzioni membro speciali con `= default` in C++
In C++23, `= default` richiede al compilatore la definizione standard di una funzione membro speciale. Con Pimpl conta dove la si definisce; il supporto a C++23 può variare tra implementazioni.
Versione: ISO C++23; implementation support may vary
Sintassi
struct S {
S() = default;
S(const S&) = default;
S(S&&) = default;
S& operator=(const S&) = default;
S& operator=(S&&) = default;
~S();
};
S::~S() = default;= default chiede al compilatore di definire, secondo le regole del linguaggio, un costruttore predefinito, un costruttore di copia o di spostamento, un operatore di assegnazione per copia o spostamento, oppure un distruttore. Non è un corpo vuoto {}: la funzione generata applica le regole dell’operazione ai sotto-oggetti delle classi base e ai membri dati non statici.
Se = default compare nella prima dichiarazione, la funzione è dichiarata dall’utente, ma non è user-provided nel senso dello standard. Può essere triviale se soddisfa le altre condizioni, oppure risultare definita come eliminata se non è disponibile un’operazione necessaria su un sotto-oggetto. Se = default compare in una definizione successiva, la funzione è user-provided e non è triviale. Se la definizione generata dovesse risultare eliminata, il programma non sarebbe ben formato.
= delete ha un altro significato: un overload eliminato partecipa ancora alla risoluzione degli overload, ma selezionarlo è un errore. Non è un’espressione delete p e non libera memoria. Un distruttore dichiarato dall’utente, anche con = default, impedisce la dichiarazione implicita delle operazioni di spostamento. Perciò Widget le dichiara entrambe esplicitamente ed elimina entrambe le operazioni di copia.
Con Pimpl, l’header può dichiarare in anticipo Impl e contenere uno std::unique_ptr<Impl>. Il deleter predefinito richiede però che Impl sia completo: il distruttore può eliminare l’oggetto posseduto e l’assegnazione per spostamento può eliminare l’oggetto precedente della destinazione. Dichiara le funzioni nell’header e definisci il distruttore e le due operazioni di spostamento con = default nel file di implementazione dopo la definizione di Impl. Spostare il puntatore non elimina di per sé l’oggetto, ma un’eccezione durante la costruzione può richiedere la distruzione di sotto-oggetti. Per questo anche il costruttore di spostamento è definito lì.
Esempi
#include <iostream>
#include <memory>
#include <utility>
class Widget {
public:
explicit Widget(int value);
~Widget();
Widget(const Widget&) = delete;
Widget& operator=(const Widget&) = delete;
Widget(Widget&&) noexcept;
Widget& operator=(Widget&&) noexcept;
int value() const noexcept;
private:
struct Impl;
std::unique_ptr<Impl> impl_;
};
struct Widget::Impl {
int value;
};
Widget::Widget(int value) : impl_(std::make_unique<Impl>(Impl{value})) {}
Widget::~Widget() = default;
Widget::Widget(Widget&&) noexcept = default;
Widget& Widget::operator=(Widget&&) noexcept = default;
int Widget::value() const noexcept {
return impl_ ? impl_->value : -1;
}
int main() {
Widget source(42);
Widget intermediate(std::move(source));
Widget target(7);
target = std::move(intermediate);
std::cout << target.value() << '\n'
<< source.value() << '\n'
<< intermediate.value() << '\n';
}Risultato
42 -1 -1
Un solo file riproduce la separazione tra header e implementazione. Costruzione e assegnazione per spostamento trasferiscono a `target` l’oggetto con `42`, sostituendo quello con `7`. Entrambi i puntatori di origine restano vuoti, quindi `value()` restituisce `-1` per ciascuno.
Lezioni correlate
- C++ · Lezione 11 · Avanzato · Versione: 3