Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Singleton, fabbrica e decoratore in C++: architettura e modello a oggetti

Questi tre pattern separano identità e durata di vita dell’oggetto, scelta dell’implementazione da costruire e aggiunta di comportamento senza cambiare l’interfaccia.

Versione: ISO C++23; implementation support may vary

Sintassi

// C++23 architecture/object-model patterns (representative declarations, not special language syntax).
#include <memory>
#include <string>

// Singleton
class Style final {
public:
    static const Style& instance();
    Style(const Style&) = delete;
    Style& operator=(const Style&) = delete;
    char opening() const;
    char closing() const;

private:
    Style() = default;
    ~Style() = default;
};

struct Message {
    virtual ~Message() = default;
    virtual std::string text() const = 0;
};

// Factory
enum class Kind { brief, full };
std::unique_ptr<Message> make_message(Kind kind);

// Decorator
class Bracketed final : public Message {
public:
    Bracketed(std::unique_ptr<Message> inner, const Style& style);
    std::string text() const override;

private:
    std::unique_ptr<Message> inner_;
    char opening_;
    char closing_;
};

Ambito — architettura e modello a oggetti. Sono pattern di progettazione, non sintassi speciale di C++23. Il singleton stabilisce quale istanza condividono i client; la fabbrica decide quale oggetto creare; il decoratore decide quale comportamento aggiungere a un oggetto esistente.

Singleton. Style::instance() restituisce un riferimento const non proprietario allo stesso oggetto static locale alla funzione. Il costruttore privato e le operazioni di copia eliminate impediscono ai client di costruire o copiare direttamente le istanze. Se serve l’inizializzazione dinamica, avviene al primo passaggio per la dichiarazione e le chiamate concorrenti ne attendono il completamento. Ciò non sincronizza le modifiche successive. L’oggetto viene distrutto alla terminazione normale del programma; non usarlo dopo la distruzione e non presumere che sia unico tra tutti i plugin. Passa esplicitamente la dipendenza se non serve l’accesso globale.

Fabbrica. make_message(Kind) sceglie Brief o Full in fase di esecuzione, crea un nuovo oggetto con std::make_unique e ne trasferisce la proprietà esclusiva tramite std::unique_ptr<Message>. Un valore non supportato provoca un’eccezione std::invalid_argument anziché restituire un puntatore nullo. È una funzione di fabbrica semplice, non un metodo virtuale del pattern Factory Method né una Abstract Factory per famiglie di prodotti correlati.

Decoratore. Bracketed implementa la stessa interfaccia Message e assume la proprietà esclusiva dell’oggetto avvolto tramite std::move. Rifiuta un puntatore nullo con std::invalid_argument. Copia i caratteri da Style senza conservare un riferimento. text() delega all’oggetto avvolto e aggiunge parentesi quadre. I decoratori possono essere annidati e il loro ordine può cambiare il risultato. Il distruttore virtuale di Message consente a std::unique_ptr<Message> con il deleter predefinito di distruggere correttamente un oggetto derivato.

Esempi

#include <iostream>
#include <memory>
#include <stdexcept>
#include <string>
#include <utility>

class Style final {
public:
    static const Style& instance() {
        static const Style style;
        return style;
    }

    Style(const Style&) = delete;
    Style& operator=(const Style&) = delete;

    char opening() const { return '['; }
    char closing() const { return ']'; }

private:
    Style() = default;
    ~Style() = default;
};

struct Message {
    virtual ~Message() = default;
    virtual std::string text() const = 0;
};

struct Brief final : Message {
    std::string text() const override { return "brief"; }
};

struct Full final : Message {
    std::string text() const override { return "full"; }
};

enum class Kind { brief, full };

std::unique_ptr<Message> make_message(Kind kind) {
    switch (kind) {
    case Kind::brief: return std::make_unique<Brief>();
    case Kind::full:  return std::make_unique<Full>();
    }
    throw std::invalid_argument("unsupported message kind");
}

class Bracketed final : public Message {
public:
    Bracketed(std::unique_ptr<Message> inner, const Style& style)
        : inner_(std::move(inner)),
          opening_(style.opening()), closing_(style.closing()) {
        if (!inner_) {
            throw std::invalid_argument("missing wrapped message");
        }
    }

    std::string text() const override {
        return opening_ + inner_->text() + closing_;
    }

private:
    std::unique_ptr<Message> inner_;
    char opening_;
    char closing_;
};

int main() {
    const auto& style = Style::instance();
    auto plain = make_message(Kind::brief);
    std::unique_ptr<Message> decorated =
        std::make_unique<Bracketed>(make_message(Kind::full), style);

    std::cout << std::boolalpha << (&style == &Style::instance()) << '\n'
              << plain->text() << '\n'
              << decorated->text() << '\n';
}

Risultato

true
brief
[full]

Righe attese: `true` conferma che l’istanza è la stessa, `brief` è il risultato dell’oggetto senza decoratore e `[full]` è il risultato della seconda implementazione decorata.

Lezioni correlate

  • C++ · Lezione 55 · Intermedio · Versione: 2

Fonti