CKTIS / C++
Programmarchitektur: Verantwortlichkeiten und Abhängigkeiten
Programmarchitektur legt Verantwortlichkeiten, Abhängigkeitsrichtung und Objektbesitz fest. Das Beispiel verbindet Strategy Pattern, Factory Registry, Dependency Injection und Decorator; Singleton wird als separate Entscheidung über Zugriff und Lebensdauer behandelt.
Version: C++23; repository compiler flag, production runtime not attested
Syntax
struct Interface { virtual ~Interface() = default; virtual int apply(int) const = 0; };Programmarchitektur beschreibt Komponentengrenzen, Verantwortlichkeiten, Abhängigkeiten und Lebensdauern. Sie ist kein C++-Schlüsselwort. Die folgenden Muster sind Entwurfskonventionen und keine Funktionen der Standardbibliothek. Die Quellen beschreiben Sprachmechanismen, keinen Katalog von Entwurfsmustern. Der bereitgestellte Arbeitsentwurf wird weiterentwickelt und ist keine eingefrorene C++23-Spezifikation; eine Compiler-Option im Repository belegt nicht die Produktionsumgebung.
Das Strategy Pattern trennt einen austauschbaren Algorithmus von seinem aufrufenden Objekt: Double implementiert Strategy, und Runner verwendet die Schnittstelle. Dependency Injection bedeutet, eine Abhängigkeit von außen bereitzustellen; der Konstruktor von Runner erhält eine Referenz, statt selbst eine Strategie zu erzeugen. Virtueller Dispatch wählt die Implementierung anhand des dynamischen Typs; override erkennt eine nicht übereinstimmende Deklaration zur Kompilierzeit.
Eine Factory Registry ordnet Schlüssel Funktionen zur Objekterzeugung zu. Hier erzeugt registry.at("double")() eine Strategie; ein unbekannter Schlüssel führt zu std::out_of_range. Ein Decorator umhüllt ein Objekt und erhält dabei dessen Schnittstelle: AddOne delegiert an die Strategie und addiert anschließend eins. Das Register wählt die Erzeugung, die Strategie den Algorithmus, und der Decorator erweitert das Verhalten.
std::unique_ptr drückt exklusiven Besitz aus; der virtuelle Destruktor ermöglicht das korrekte Löschen über einen Zeiger auf Strategy. AddOne benötigt einen Zeiger, der nicht null ist. Die Referenz in Runner besitzt das Objekt nicht: Die referenzierte Strategie muss länger leben als das Objekt, das sie verwendet. Das Beispiel erfüllt beide Bedingungen und liefert für 3 den Wert 7.
Ein Singleton beschränkt eine Klasse auf eine Instanz und bietet einen globalen Zugriffspunkt. Hier ist es unnötig: Die Objekte werden in main zusammengesetzt. Ein lokales static-Objekt einer Funktion kann eine solche Implementierung unterstützen; nebenläufige Initialisierung wartet auf ihren Abschluss, aber spätere Operationen auf dem Objekt werden dadurch nicht automatisch threadsicher. Globaler Zugriff kann Abhängigkeiten verbergen und die Isolation von Tests erschweren.
Beispiele
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <utility>
struct Strategy {
virtual ~Strategy() = default;
virtual int apply(int value) const = 0;
};
struct Double final : Strategy {
int apply(int value) const override { return value * 2; }
};
class AddOne final : public Strategy {
std::unique_ptr<Strategy> inner_;
public:
explicit AddOne(std::unique_ptr<Strategy> inner)
: inner_(std::move(inner)) {}
int apply(int value) const override {
return inner_->apply(value) + 1;
}
};
class Runner {
const Strategy& strategy_;
public:
explicit Runner(const Strategy& strategy) : strategy_(strategy) {}
int run(int value) const { return strategy_.apply(value); }
};
std::unique_ptr<Strategy> make_double() {
return std::make_unique<Double>();
}
int main() {
using Factory = std::unique_ptr<Strategy> (*)();
const std::map<std::string, Factory> registry{{"double", &make_double}};
auto strategy = std::make_unique<AddOne>(registry.at("double")());
const Runner runner{*strategy};
std::cout << runner.run(3) << '\n';
}
Ergebnis
7
Der angezeigte Code und das angegebene Ergebnis wurden in einer isolierten Umgebung mit der im Prüfnachweis für genau diese Version dokumentierten Methode verifiziert.