CKTIS / C++
Arquitetura de programas: responsabilidades e dependências
A arquitetura de programas define responsabilidades, a direção das dependências e a propriedade dos objetos. O exemplo combina strategy pattern, factory registry, dependency injection e decorator; singleton é tratado como uma decisão separada sobre acesso e duração de vida.
Versão: C++23; repository compiler flag, production runtime not attested
Sintaxe
struct Interface { virtual ~Interface() = default; virtual int apply(int) const = 0; };A arquitetura de programas descreve os limites dos componentes, as respetivas responsabilidades, dependências e durações de vida. Não é uma palavra-chave de C++. Os padrões abaixo são convenções de conceção, não funcionalidades da biblioteca-padrão. As fontes descrevem mecanismos da linguagem, não um catálogo de padrões. O projeto de norma fornecido está em evolução e não é uma especificação C++23 definitiva; uma opção do compilador num repositório não atesta o ambiente de produção.
O strategy pattern separa um algoritmo substituível do seu cliente: Double implementa Strategy e Runner utiliza a interface. Dependency injection significa fornecer uma dependência externamente; o construtor de Runner recebe uma referência em vez de criar a estratégia. O despacho virtual seleciona a implementação pelo tipo dinâmico; override permite detetar durante a compilação uma declaração incompatível.
Uma factory registry associa chaves a funções de criação de objetos. Aqui, registry.at("double")() cria uma estratégia; uma chave desconhecida causa std::out_of_range. Um decorator envolve um objeto sem alterar a sua interface: AddOne delega na estratégia e, em seguida, adiciona um. O registo escolhe a criação, a estratégia escolhe o algoritmo e o decorator alarga o comportamento.
std::unique_ptr exprime propriedade exclusiva; o destrutor virtual permite a eliminação correta através de um ponteiro para Strategy. AddOne exige um ponteiro não nulo. A referência em Runner não é proprietária: a estratégia referenciada tem de durar mais do que o cliente que a utiliza. O exemplo cumpre ambas as condições e produz 7 para 3.
Um singleton restringe uma classe a uma única instância e fornece um ponto de acesso global. Não é necessário aqui: a composição dos objetos ocorre em main. Um objeto static local a uma função pode apoiar esta implementação; a inicialização concorrente aguarda pela conclusão, mas as operações posteriores no objeto não se tornam automaticamente seguras para utilização concorrente. O acesso global pode ocultar dependências e dificultar o isolamento dos testes.
Exemplos
#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
O código apresentado e o resultado declarado foram verificados num ambiente isolado pelo método registado na prova de verificação desta versão exata.