Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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

Fonti