CKTIS / C++
Singleton, továreň a dekorátor v C++: architektúra a objektový model
Tieto tri vzory oddeľujú identitu a životnosť objektu, výber vytváranej implementácie a pridávanie správania pri zachovaní rovnakého rozhrania.
Verzia: 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_;
};Rozsah — architektúra a objektový model. Ide o návrhové vzory, nie o špeciálnu syntax C++23. Singleton určuje, ktorú inštanciu klienti zdieľajú; továreň rozhoduje, aký objekt vytvoriť; dekorátor rozhoduje, aké správanie pridať k existujúcemu objektu.
Singleton. Style::instance() vracia nevlastniacu referenciu const na ten istý lokálny objekt static vo funkcii. Súkromný konštruktor a odstránené kopírovacie operácie bránia klientom priamo vytvárať či kopírovať inštancie. Ak je potrebná dynamická inicializácia, prebehne pri prvom prechode deklaráciou a súbežné volania čakajú na jej dokončenie. Neskoršie zmeny stavu to nesynchronizuje. Objekt sa zničí pri riadnom ukončení programu; po zničení ho nepoužívajte a nepredpokladajte jedinú inštanciu naprieč všetkými zásuvnými modulmi. Ak globálny prístup netreba, odovzdajte závislosť explicitne.
Továreň. make_message(Kind) za behu vyberie Brief alebo Full, pomocou std::make_unique vytvorí nový objekt a odovzdá výhradné vlastníctvo cez std::unique_ptr<Message>. Nepodporovaná hodnota vyvolá std::invalid_argument namiesto vrátenia nulového ukazovateľa. Je to jednoduchá továrenská funkcia, nie virtuálna metóda vzoru Factory Method ani Abstract Factory pre rodiny súvisiacich produktov.
Dekorátor. Bracketed implementuje rovnaké rozhranie Message a pomocou std::move preberá výhradné vlastníctvo obaleného objektu. Nulový ukazovateľ odmietne výnimkou std::invalid_argument. Znaky zo Style skopíruje a referenciu neuchováva. text() deleguje volanie na obalený objekt a pridá hranaté zátvorky. Dekorátory možno vnárať a ich poradie môže zmeniť výsledok. Virtuálny deštruktor Message umožňuje, aby std::unique_ptr<Message> s predvoleným deleterom správne zničil odvodený objekt.
Príklady
#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';
}
Výsledok
true brief [full]
Očakávané riadky: `true` potvrdzuje tú istú inštanciu, `brief` je výsledok neobaleného objektu z továrne a `[full]` je výsledok druhej implementácie po obalení dekorátorom.
Súvisiace lekcie
- C++ · Lekcia 55 · Stredne pokročilá · Verzia: 2
Zdroje
- Declaration statement [stmt.dcl]
- The inline specifier [dcl.inline]
- Termination [basic.start.term]
- Virtual functions [class.virtual]
- Delete [expr.delete]
- Unique-ownership pointers: Creation [unique.ptr.create]
- unique_ptr for single objects: Constructors [unique.ptr.single.ctor]
- unique_ptr for single objects: Destructor [unique.ptr.single.dtor]
- Default deleters [unique.ptr.dltr.dflt]