CKTIS / C++
Arquitectura de programas: responsabilidades y dependencias
La arquitectura de programas define las responsabilidades, la dirección de las dependencias y la propiedad de los objetos. El ejemplo combina strategy pattern, factory registry, dependency injection y decorator; singleton se trata como una decisión aparte sobre el acceso y el ciclo de vida.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
struct Interface { virtual ~Interface() = default; virtual int apply(int) const = 0; };La arquitectura de programas describe los límites entre componentes, sus responsabilidades, dependencias y ciclos de vida. No es una palabra clave de C++. Los patrones siguientes son convenciones de diseño, no características de la biblioteca estándar. Las fuentes describen mecanismos del lenguaje, no un catálogo de patrones. El borrador de trabajo proporcionado evoluciona y no es una especificación C++23 definitiva; una opción del compilador en un repositorio no acredita el entorno de producción.
El strategy pattern separa un algoritmo intercambiable de su cliente: Double implementa Strategy, y Runner usa la interfaz. Dependency injection significa proporcionar una dependencia desde fuera; el constructor de Runner recibe una referencia en lugar de crear su propia estrategia. El despacho virtual selecciona la implementación según el tipo dinámico; override permite detectar en compilación una declaración incompatible.
Una factory registry asocia claves con funciones que crean objetos. Aquí, registry.at("double")() crea una estrategia; una clave desconocida provoca std::out_of_range. Un decorator envuelve un objeto y conserva su interfaz: AddOne delega en la estrategia y después suma uno. El registro elige cómo crear, la estrategia elige el algoritmo y el decorador amplía el comportamiento.
std::unique_ptr expresa propiedad exclusiva; el destructor virtual permite eliminar correctamente mediante un puntero a Strategy. AddOne requiere un puntero no nulo. La referencia de Runner no es propietaria: la estrategia referenciada debe vivir más que el cliente que la utiliza. El ejemplo cumple ambas condiciones y produce 7 para 3.
Un singleton limita una clase a una instancia y proporciona un punto de acceso global. Aquí no hace falta: la composición de objetos ocurre en main. Un objeto static local a una función puede servir para esa implementación; la inicialización concurrente espera a que termine, pero las operaciones posteriores sobre el objeto no se vuelven seguras para hilos automáticamente. El acceso global puede ocultar dependencias y dificultar el aislamiento de pruebas.
Ejemplos
#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';
}
Resultado
7
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.