Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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.

Fontes