Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Singleton, tovarna in dekorator v C++: arhitektura in objektni model

Trije vzorci ločijo identiteto in življenjsko dobo objekta, izbiro izvedbe, ki jo ustvarimo, ter dodajanje vedenja ob nespremenjenem vmesniku.

Različica: ISO C++23; implementation support may vary

Sintaksa

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

Obseg — arhitektura in objektni model. To so načrtovalski vzorci, ne posebna skladnja C++23. Singleton določa, kateri primerek si odjemalci delijo; tovarna odloča, kateri objekt ustvariti; dekorator odloča, katero vedenje dodati obstoječemu objektu.

Singleton. Style::instance() vrne nelastniško referenco const na isti lokalni objekt static v funkciji. Zasebni konstruktor in izbrisane operacije kopiranja odjemalcem preprečijo, da bi primerke neposredno ustvarjali ali kopirali. Če je potrebna dinamična inicializacija, se izvede ob prvem prehodu čez deklaracijo, sočasni klici pa počakajo na njen zaključek. To ne sinhronizira poznejših sprememb. Objekt se uniči ob običajnem koncu programa; po uničenju ga ne uporabljajte in ne predpostavljajte enega samega primerka za vse vtičnike. Če globalni dostop ni potreben, raje podajte odvisnost izrecno.

Tovarna. make_message(Kind) med izvajanjem izbere Brief ali Full, s std::make_unique ustvari nov objekt in prek std::unique_ptr<Message> prenese izključno lastništvo. Nepodprta vrednost sproži std::invalid_argument, namesto da bi funkcija vrnila ničelni kazalec. To je preprosta tovarniška funkcija, ne virtualna metoda vzorca Factory Method niti Abstract Factory za družine sorodnih izdelkov.

Dekorator. Bracketed implementira isti vmesnik Message in prek std::move prevzame izključno lastništvo ovitega objekta. Ničelni kazalec zavrne z izjemo std::invalid_argument. Znake iz Style kopira in reference ne shrani. text() posreduje klic ovitemu objektu in doda oglate oklepaje. Dekoratorje lahko gnezdimo in njihov vrstni red lahko spremeni rezultat. Virtualni destruktor razreda Message omogoča, da std::unique_ptr<Message> s privzetim brisalnikom pravilno uniči objekt izpeljanega razreda.

Primeri

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

Rezultat

true
brief
[full]

Pričakovane vrstice: `true` potrdi, da gre za isti primerek, `brief` je rezultat nedekoriranega objekta iz tovarne, `[full]` pa rezultat druge izvedbe z dekoratorjem.

Povezane lekcije

  • C++ · Lekcija 55 · Srednja · Različica: 2

Viri