CKTIS / C++
Architettura dei programmi: responsabilità e dipendenze
L’architettura dei programmi definisce responsabilità, direzione delle dipendenze e proprietà degli oggetti. L’esempio combina strategy pattern, factory registry, dependency injection e decorator; singleton è trattato come una decisione distinta su accesso e durata di vita.
Versione: C++23; repository compiler flag, production runtime not attested
Sintassi
struct Interface { virtual ~Interface() = default; virtual int apply(int) const = 0; };L’architettura dei programmi descrive i confini dei componenti, le loro responsabilità, dipendenze e durate di vita. Non è una parola chiave C++. I pattern seguenti sono convenzioni di progettazione, non funzionalità della libreria standard. Le fonti descrivono i meccanismi del linguaggio, non un catalogo di pattern. La bozza di lavoro fornita è in evoluzione e non è una specifica C++23 definitiva; un’opzione del compilatore in un repository non certifica l’ambiente di produzione.
Lo strategy pattern separa un algoritmo sostituibile dal suo client: Double implementa Strategy e Runner usa l’interfaccia. Dependency injection significa fornire una dipendenza dall’esterno; il costruttore di Runner riceve un riferimento invece di creare da sé la strategia. Il dispatch virtuale seleziona l’implementazione in base al tipo dinamico; override consente di rilevare in compilazione una dichiarazione non corrispondente.
Una factory registry associa chiavi a funzioni che creano oggetti. Qui, registry.at("double")() crea una strategia; una chiave sconosciuta causa std::out_of_range. Un decorator avvolge un oggetto mantenendone l’interfaccia: AddOne delega alla strategia e poi aggiunge uno. Il registro seleziona la creazione, la strategia seleziona l’algoritmo e il decorator estende il comportamento.
std::unique_ptr esprime la proprietà esclusiva; il distruttore virtuale consente la corretta eliminazione tramite un puntatore a Strategy. AddOne richiede un puntatore non nullo. Il riferimento in Runner non possiede l’oggetto: la strategia referenziata deve vivere più a lungo del client che la usa. L’esempio soddisfa entrambe le condizioni e produce 7 per 3.
Un singleton limita una classe a una sola istanza e fornisce un punto di accesso globale. Qui non è necessario: la composizione degli oggetti avviene in main. Un oggetto static locale a una funzione può supportare questa implementazione; l’inizializzazione concorrente attende il completamento, ma le operazioni successive sull’oggetto non diventano automaticamente thread-safe. L’accesso globale può nascondere dipendenze e rendere più difficile isolare i test.
Esempi
#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';
}
Risultato
7
Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.