Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / C++

Architektúra programu: zodpovednosti a závislosti

Architektúra programu určuje zodpovednosti, smer závislostí a vlastníctvo objektov. Príklad kombinuje strategy pattern, factory registry, dependency injection a decorator; singleton je samostatným rozhodnutím o prístupe a životnosti.

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

Syntax

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

Architektúra programu opisuje hranice komponentov, ich zodpovednosti, závislosti a životnosť. Nie je to kľúčové slovo C++. Nasledujúce vzory sú návrhové konvencie, nie funkcie štandardnej knižnice. Zdroje opisujú mechanizmy jazyka, nie katalóg vzorov. Dodaný pracovný návrh sa vyvíja a nie je nemennou špecifikáciou C++23; príznak kompilátora v repozitári nepotvrdzuje produkčné prostredie.

Strategy pattern oddeľuje vymeniteľný algoritmus od jeho klienta: Double implementuje Strategy a Runner používa rozhranie. Dependency injection znamená dodanie závislosti zvonka; konštruktor Runner dostane referenciu namiesto toho, aby si stratégiu vytvoril sám. Pri volaní virtuálnej funkcie sa implementácia vyberá podľa dynamického typu objektu; override umožňuje odhaliť nezhodnú deklaráciu počas kompilácie.

Factory registry mapuje kľúče na funkcie vytvárajúce objekty. Tu registry.at("double")() vytvorí stratégiu; neznámy kľúč spôsobí std::out_of_range. Decorator obalí objekt a zachová jeho rozhranie: AddOne deleguje na stratégiu a potom pripočíta jeden. Register vyberá vytváranie, stratégia algoritmus a dekorátor rozširuje správanie.

std::unique_ptr vyjadruje výhradné vlastníctvo; virtuálny deštruktor umožňuje správne mazanie cez ukazovateľ na Strategy. AddOne vyžaduje nenulový ukazovateľ. Referencia v Runner objekt nevlastní: referovaná stratégia musí žiť dlhšie než klient, ktorý ju používa. Príklad spĺňa obe podmienky a pre 3 vytvorí 7.

Singleton obmedzuje triedu na jedinú inštanciu a poskytuje globálny prístupový bod. Tu nie je potrebný: objekty sa skladajú v main. Lokálny objekt static vo funkcii môže takúto implementáciu podporiť; súbežná inicializácia čaká na dokončenie, ale neskoršie operácie s objektom sa tým automaticky nestávajú bezpečnými pre viac vlákien. Globálny prístup môže skrývať závislosti a sťažovať izoláciu testov.

Príklady

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

Výsledok

7

Zobrazený kód a uvedený výsledok boli overené v izolovanom prostredí metódou zaznamenanou v dôkaze o overení tejto presnej verzie.

Zdroje