WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / C++

Singleton, Factory und Decorator in C++: Architektur und Objektmodell

Die drei Muster trennen Objektidentität und Lebensdauer, die Wahl der zu erzeugenden Implementierung und das Ergänzen von Verhalten bei unveränderter Schnittstelle.

Version: 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_;
};

Geltungsbereich — Architektur und Objektmodell. Das sind Entwurfsmuster, keine besondere C++23-Syntax. Singleton bestimmt, welche Instanz die Aufrufer gemeinsam nutzen; die Factory entscheidet, welches Objekt erzeugt wird; der Decorator ergänzt das Verhalten eines vorhandenen Objekts.

Singleton. Style::instance() gibt eine nicht besitzende const-Referenz auf dasselbe funktionslokale static-Objekt zurück. Ein privater Konstruktor und gelöschte Kopieroperationen verhindern, dass Aufrufer Instanzen direkt erzeugen oder kopieren. Ist eine dynamische Initialisierung nötig, erfolgt sie beim ersten Erreichen der Deklaration; gleichzeitige Aufrufe warten auf ihren Abschluss. Spätere Änderungen werden dadurch nicht synchronisiert. Das Objekt wird bei normaler Programmbeendigung zerstört. Greife danach nicht mehr darauf zu und gehe nicht von einer einzigen Instanz über alle Plugins hinweg aus. Übergib die Abhängigkeit lieber explizit, wenn kein globaler Zugriff nötig ist.

Factory. make_message(Kind) wählt zur Laufzeit Brief oder Full, erzeugt mit std::make_unique ein neues Objekt und überträgt dessen exklusiven Besitz per std::unique_ptr<Message>. Ein nicht unterstützter Wert führt zu std::invalid_argument, nicht zu einem Nullzeiger. Das ist eine einfache Fabrikfunktion, keine virtuelle Factory Method und keine Abstract Factory für Familien zusammengehöriger Produkte.

Decorator. Bracketed implementiert dieselbe Message-Schnittstelle und übernimmt per std::move exklusiv das eingepackte Objekt. Einen Nullzeiger weist er mit std::invalid_argument zurück. Er kopiert die Zeichen aus Style, statt eine Referenz zu behalten. text() delegiert an das eingepackte Objekt und setzt eckige Klammern um das Ergebnis. Decorators lassen sich verschachteln; die Reihenfolge kann das Ergebnis ändern. Der virtuelle Destruktor von Message sorgt dafür, dass std::unique_ptr<Message> mit dem Standard-Deleter ein abgeleitetes Objekt korrekt zerstört.

Beispiele

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

Ergebnis

true
brief
[full]

Erwartete Zeilen: `true` bestätigt dieselbe Instanz, `brief` ist das Ergebnis des unveränderten Fabrikobjekts und `[full]` das Ergebnis der zweiten Implementierung mit Decorator.

Zugehörige Lektionen

  • C++ · Lektion 55 · Mittlere Stufe · Version: 2

Quellen