Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

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