CKTIS / C++
Architecture d’un programme : responsabilités et dépendances
L’architecture d’un programme définit les responsabilités, le sens des dépendances et la propriété des objets. L’exemple associe strategy pattern, factory registry, dependency injection et decorator, tandis que singleton est présenté comme une décision distincte sur l’accès et la durée de vie.
Version : C++23; repository compiler flag, production runtime not attested
Syntaxe
struct Interface { virtual ~Interface() = default; virtual int apply(int) const = 0; };L’architecture d’un programme décrit les limites des composants, leurs responsabilités, leurs dépendances et leur durée de vie. Ce n’est pas un mot-clé C++. Les modèles ci-dessous sont des conventions de conception, pas des fonctionnalités de la bibliothèque standard. Les sources décrivent les mécanismes du langage, pas un catalogue de modèles. Le projet de norme fourni évolue et n’est pas une spécification C++23 figée ; une option de compilateur dans un dépôt ne certifie pas l’environnement de production.
Le strategy pattern sépare un algorithme remplaçable de son client : Double implémente Strategy, et Runner utilise l’interface. La dependency injection consiste à fournir une dépendance de l’extérieur ; le constructeur de Runner reçoit une référence au lieu de créer lui-même sa stratégie. La répartition dynamique sélectionne l’implémentation selon le type dynamique ; override permet de détecter à la compilation une déclaration incompatible.
Une factory registry associe des clés à des fonctions de création d’objets. Ici, registry.at("double")() crée une stratégie ; une clé inconnue provoque std::out_of_range. Un decorator enveloppe un objet tout en conservant son interface : AddOne délègue à la stratégie, puis ajoute un. Le registre choisit la création, la stratégie choisit l’algorithme et le décorateur étend le comportement.
std::unique_ptr exprime une propriété exclusive ; le destructeur virtuel permet une suppression correcte via un pointeur vers Strategy. AddOne exige un pointeur non nul. La référence dans Runner n’est pas propriétaire : la stratégie référencée doit vivre plus longtemps que le client qui l’utilise. L’exemple respecte ces deux conditions et produit 7 pour 3.
Un singleton limite une classe à une seule instance et fournit un point d’accès global. Il est inutile ici : l’assemblage des objets a lieu dans main. Un objet static local à une fonction peut servir à cette implémentation ; l’initialisation concurrente attend son achèvement, mais les opérations ultérieures sur l’objet ne deviennent pas automatiquement sûres en concurrence. Un accès global peut masquer les dépendances et compliquer l’isolation des tests.
Exemples
#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';
}
Résultat
7
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.