CKTIS / C++
Arhitektura programa: odgovornosti i ovisnosti
Arhitektura programa određuje odgovornosti, smjer ovisnosti i vlasništvo nad objektima. Primjer kombinira strategy pattern, factory registry, dependency injection i decorator; singleton obrađuje kao zasebnu odluku o pristupu i životnom vijeku.
Verzija: C++23; repository compiler flag, production runtime not attested
Sintaksa
struct Interface { virtual ~Interface() = default; virtual int apply(int) const = 0; };Arhitektura programa opisuje granice komponenti, njihove odgovornosti, ovisnosti i životni vijek. Nije ključna riječ C++. Sljedeći obrasci su konvencije dizajna, a ne značajke standardne biblioteke. Izvori opisuju mehanizme jezika, a ne katalog obrazaca. Dostavljeni radni nacrt razvija se i nije nepromjenjiva specifikacija C++23; zastavica prevoditelja u repozitoriju ne potvrđuje produkcijsko okruženje.
Strategy pattern odvaja zamjenjiv algoritam od njegova klijenta: Double implementira Strategy, a Runner koristi sučelje. Dependency injection znači da se ovisnost osigurava izvana; konstruktor Runner prima referencu umjesto da sam stvara strategiju. Virtualni poziv odabire implementaciju prema dinamičkom tipu; override omogućuje otkrivanje neusklađene deklaracije tijekom prevođenja.
Factory registry preslikava ključeve u funkcije za stvaranje objekata. Ovdje registry.at("double")() stvara strategiju; nepoznat ključ uzrokuje std::out_of_range. Decorator omata objekt uz očuvanje njegova sučelja: AddOne delegira strategiji, a zatim dodaje jedan. Registar bira stvaranje, strategija bira algoritam, a dekorator proširuje ponašanje.
std::unique_ptr izražava isključivo vlasništvo; virtualni destruktor omogućuje ispravno brisanje putem pokazivača na Strategy. AddOne zahtijeva pokazivač koji nije null. Referenca u Runner nije vlasnička: referencirana strategija mora živjeti dulje od klijenta koji je koristi. Primjer ispunjava oba uvjeta i za 3 daje 7.
Singleton ograničava klasu na jednu instancu i pruža globalnu pristupnu točku. Ovdje nije potreban: sastavljanje objekata odvija se u main. Lokalni objekt static unutar funkcije može podržati takvu implementaciju; istodobna inicijalizacija čeka da se dovrši, ali kasnije operacije nad objektom time ne postaju automatski sigurne za niti. Globalni pristup može skrivati ovisnosti i otežati izolaciju testova.
Primjeri
#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';
}
Rezultat
7
Prikazani kôd i navedeni rezultat provjereni su u izoliranom okruženju metodom zabilježenom u dokazu provjere za ovu točnu verziju.