KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Singleton, factory en decorator in C++: architectuur en objectmodel

De drie patronen scheiden de identiteit en levensduur van een object, de keuze van de te maken implementatie en het toevoegen van gedrag zonder de interface te veranderen.

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

Syntax

// 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_;
};

Reikwijdte — architectuur en objectmodel. Dit zijn ontwerppatronen, geen speciale C++23-syntaxis. Singleton bepaalt welke instantie aanroepers delen; de factory kiest welk object wordt gemaakt; de decorator voegt gedrag toe aan een bestaand object.

Singleton. Style::instance() geeft een niet-bezittende const-referentie naar hetzelfde lokale static-object in de functie. Een private constructor en verwijderde kopieeroperaties voorkomen dat aanroepers rechtstreeks instanties maken of kopiëren. Als dynamische initialisatie nodig is, gebeurt die de eerste keer dat de uitvoering de declaratie bereikt; gelijktijdige aanroepen wachten tot ze klaar is. Dat synchroniseert latere wijzigingen niet. Het object wordt bij normale programmabeëindiging vernietigd. Gebruik het daarna niet en ga niet uit van één instantie voor alle plug-ins. Geef de afhankelijkheid liever expliciet door als globale toegang niet nodig is.

Factory. make_message(Kind) kiest tijdens uitvoering tussen Brief en Full, maakt met std::make_unique een nieuw object en draagt het exclusieve eigendom over via std::unique_ptr<Message>. Bij een niet-ondersteunde waarde gooit de functie std::invalid_argument in plaats van een nulpointer terug te geven. Dit is een eenvoudige factoryfunctie, geen virtuele Factory Method en geen Abstract Factory voor families van verwante producten.

Decorator. Bracketed implementeert dezelfde Message-interface en neemt via std::move het exclusieve eigendom van het omhulde object over. Een nulpointer wijst hij af met std::invalid_argument. Hij kopieert de tekens uit Style en bewaart geen referentie. text() delegeert naar het omhulde object en voegt vierkante haken toe. Decorators kunnen worden genest en hun volgorde kan de uitkomst wijzigen. Dankzij de virtuele destructor van Message kan std::unique_ptr<Message> met de standaarddeleter een afgeleid object correct vernietigen.

Voorbeelden

#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';
}

Resultaat

true
brief
[full]

Verwachte regels: `true` bevestigt dat het dezelfde instantie is, `brief` is het resultaat van het onbewerkte factoryproduct en `[full]` is het resultaat van de tweede implementatie na decoratie.

Gerelateerde lessen

  • C++ · Les 55 · Gemiddeld · Versie: 2

Bronnen