Baza wiedzyCentrum egzaminacyjne
PLPolski
Wybierz język13

CKTIS / C++

Architektura programu: odpowiedzialności i zależności

Architektura programu określa podział odpowiedzialności, kierunek zależności i własność obiektów. Przykład łączy strategy pattern, factory registry, dependency injection i decorator, a singleton omawia jako osobną decyzję dotyczącą dostępu i czasu życia.

Wersja: C++23; repository compiler flag, production runtime not attested

Składnia

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

Architektura programu (program architecture) opisuje granice komponentów, ich odpowiedzialności, zależności i czas życia. Nie jest słowem kluczowym C++. Wzorce poniżej są konwencjami projektowymi, nie funkcjami biblioteki standardowej. Źródła opisują mechanizmy języka, nie katalog wzorców. Podany szkic standardu jest aktualizowany i nie stanowi zamrożonej specyfikacji C++23; flaga kompilatora w repozytorium nie potwierdza środowiska produkcyjnego.

strategy pattern oddziela wymienny algorytm od klienta: Double implementuje Strategy, a Runner korzysta z interfejsu. dependency injection oznacza dostarczenie zależności z zewnątrz; konstruktor Runner otrzymuje referencję zamiast samodzielnie tworzyć strategię. Wywołanie wirtualne wybiera implementację według typu dynamicznego; override pozwala wykryć niezgodną deklarację podczas kompilacji.

factory registry mapuje klucze na funkcje tworzące obiekty. Tutaj registry.at("double")() tworzy strategię; nieznany klucz powoduje std::out_of_range. decorator opakowuje obiekt zachowując jego interfejs: AddOne deleguje do strategii, a następnie dodaje jeden. Rejestr wybiera sposób tworzenia, strategia wybiera algorytm, a dekorator rozszerza zachowanie.

std::unique_ptr wyraża wyłączną własność; wirtualny destruktor umożliwia poprawne usuwanie przez wskaźnik do Strategy. AddOne wymaga niepustego wskaźnika. Referencja w Runner nie jest właścicielem: wskazywana strategia musi żyć dłużej niż korzystający z niej klient. Przykład spełnia oba warunki i dla 3 daje 7.

singleton ogranicza klasę do jednej instancji i udostępnia do niej globalny punkt dostępu. Nie jest tu potrzebny: składanie obiektów odbywa się w main. Lokalny obiekt static może wspierać taką implementację; współbieżna inicjalizacja czeka na jej zakończenie, ale późniejsze operacje na obiekcie nie stają się przez to automatycznie bezpieczne wątkowo. Globalny dostęp może ukrywać zależności i utrudniać izolację testów.

Przykłady

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

Wynik

7

Wyświetlony kod i zadeklarowany wynik zweryfikowano w odizolowanym środowisku metodą zapisaną w dowodzie weryfikacji tej dokładnej wersji.

Źródła