База знанияИзпитен център
BGБългарски
Избери език13

CKTIS / C++

Архитектура на програмата: отговорности и зависимости

Архитектурата на програмата определя отговорностите, посоката на зависимостите и собствеността върху обектите. Примерът съчетава strategy pattern, factory registry, dependency injection и decorator; singleton е отделно решение за достъпа и жизнения цикъл.

Версия: C++23; repository compiler flag, production runtime not attested

Синтаксис

struct Interface { virtual ~Interface() = default; virtual int apply(int) const = 0; };

Архитектурата на програмата описва границите на компонентите, техните отговорности, зависимости и жизнен цикъл. Това не е ключова дума в C++. Следващите шаблони са конвенции за проектиране, а не функции на стандартната библиотека. Източниците описват механизмите на езика, а не каталог с шаблони. Предоставеният работен проект се развива и не е окончателна спецификация на C++23; флаг за компилатора в хранилище не удостоверява производствената среда.

Strategy pattern отделя заменяем алгоритъм от неговия клиент: Double реализира Strategy, а Runner използва интерфейса. Dependency injection означава зависимостта да се предостави отвън; конструкторът на Runner получава референция, вместо сам да създава стратегия. Виртуалното извикване избира реализацията според динамичния тип; override позволява несъответстваща декларация да бъде открита по време на компилация.

Factory registry свързва ключове с функции за създаване на обекти. Тук registry.at("double")() създава стратегия; непознат ключ причинява std::out_of_range. Decorator обвива обект, като запазва интерфейса му: AddOne делегира на стратегията и след това добавя едно. Регистърът избира създаването, стратегията избира алгоритъма, а декораторът разширява поведението.

std::unique_ptr изразява изключителна собственост; виртуалният деструктор позволява правилно изтриване чрез указател към Strategy. AddOne изисква ненулев указател. Референцията в Runner не е собственик: реферираната стратегия трябва да съществува по-дълго от клиента, който я използва. Примерът изпълнява и двете условия и за 3 дава 7.

Singleton ограничава класа до един екземпляр и предоставя глобална точка за достъп. Тук не е необходим: обектите се съставят в main. Локален за функцията обект static може да подпомогне такава реализация; едновременната инициализация изчаква завършването ѝ, но последващите операции върху обекта не стават автоматично безопасни за нишки. Глобалният достъп може да скрива зависимости и да затрудни изолирането на тестовете.

Примери

#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';
}

Резултат

7

Показаният код и заявеният резултат са проверени в изолирана среда по метода, записан в доказателството за проверка на тази точна версия.

Източници