CKTIS / C++
Programma-architectuur: verantwoordelijkheden en afhankelijkheden
Programma-architectuur bepaalt verantwoordelijkheden, de richting van afhankelijkheden en het eigendom van objecten. Het voorbeeld combineert strategy pattern, factory registry, dependency injection en decorator; singleton wordt apart behandeld als een keuze over toegang en levensduur.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
struct Interface { virtual ~Interface() = default; virtual int apply(int) const = 0; };Programma-architectuur beschrijft componentgrenzen, verantwoordelijkheden, afhankelijkheden en levensduren. Het is geen C++-trefwoord. De patronen hieronder zijn ontwerpconventies, geen functies van de standaardbibliotheek. De bronnen beschrijven mechanismen van de taal, geen catalogus van patronen. Het meegeleverde werkdocument wordt bijgewerkt en is geen definitieve C++23-specificatie; een compileroptie in een repository bevestigt niet de productieomgeving.
Het strategy pattern scheidt een vervangbaar algoritme van de client: Double implementeert Strategy, en Runner gebruikt de interface. Dependency injection betekent dat een afhankelijkheid van buitenaf wordt aangeleverd; de constructor van Runner ontvangt een referentie in plaats van zelf een strategie te maken. Virtuele dispatch kiest de implementatie op basis van het dynamische type; override kan een niet-passende declaratie tijdens het compileren opsporen.
Een factory registry koppelt sleutels aan functies die objecten maken. Hier maakt registry.at("double")() een strategie; een onbekende sleutel veroorzaakt std::out_of_range. Een decorator omhult een object met behoud van de interface: AddOne delegeert aan de strategie en telt daarna één op. Het register kiest de creatie, de strategie kiest het algoritme en de decorator breidt het gedrag uit.
std::unique_ptr drukt exclusief eigendom uit; de virtuele destructor maakt correct verwijderen via een pointer naar Strategy mogelijk. AddOne vereist een niet-nulle pointer. De referentie in Runner is niet-eigenaar: de strategie waarnaar wordt verwezen moet langer leven dan de client die haar gebruikt. Het voorbeeld voldoet aan beide voorwaarden en levert voor 3 de waarde 7 op.
Een singleton beperkt een klasse tot één instantie en biedt een globaal toegangspunt. Hier is dat niet nodig: de objecten worden samengesteld in main. Een functie-lokaal static-object kan zo’n implementatie ondersteunen; gelijktijdige initialisatie wacht tot deze is voltooid, maar latere bewerkingen op het object worden daardoor niet automatisch threadveilig. Globale toegang kan afhankelijkheden verbergen en testisolatie bemoeilijken.
Voorbeelden
#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';
}
Resultaat
7
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.