Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / C++

Architektura programu: odpovědnosti a závislosti

Architektura programu určuje odpovědnosti, směr závislostí a vlastnictví objektů. Příklad kombinuje strategy pattern, factory registry, dependency injection a decorator; singleton je samostatným rozhodnutím o přístupu a životnosti.

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

Syntaxe

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

Architektura programu popisuje hranice komponent, jejich odpovědnosti, závislosti a životnost. Není to klíčové slovo C++. Následující vzory jsou návrhové konvence, nikoli funkce standardní knihovny. Zdroje popisují mechanismy jazyka, nikoli katalog vzorů. Dodaný pracovní návrh se vyvíjí a není neměnnou specifikací C++23; příznak kompilátoru v repozitáři nepotvrzuje produkční prostředí.

Strategy pattern odděluje zaměnitelný algoritmus od jeho klienta: Double implementuje Strategy a Runner používá rozhraní. Dependency injection znamená dodání závislosti zvenčí; konstruktor Runner obdrží referenci, místo aby si strategii sám vytvořil. Virtuální dispatch vybírá implementaci podle dynamického typu; override umožňuje odhalit neodpovídající deklaraci při kompilaci.

Factory registry mapuje klíče na funkce vytvářející objekty. Zde registry.at("double")() vytvoří strategii; neznámý klíč způsobí std::out_of_range. Decorator obalí objekt a zachová jeho rozhraní: AddOne deleguje na strategii a poté přičte jedničku. Registr vybírá způsob vytvoření, strategie algoritmus a dekorátor rozšiřuje chování.

std::unique_ptr vyjadřuje výhradní vlastnictví; virtuální destruktor umožňuje správné mazání přes ukazatel na Strategy. AddOne vyžaduje nenulový ukazatel. Reference v Runner objekt nevlastní: odkazovaná strategie musí žít déle než klient, který ji používá. Příklad splňuje obě podmínky a pro 3 vrátí 7.

Singleton omezuje třídu na jedinou instanci a poskytuje globální přístupový bod. Zde není potřeba: objekty se skládají v main. Lokální objekt static ve funkci může takovou implementaci podporovat; souběžná inicializace čeká na dokončení, ale pozdější operace s objektem se tím automaticky nestávají bezpečnými pro více vláken. Globální přístup může skrývat závislosti a komplikovat izolaci testů.

Pří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ýsledek

7

Zobrazený kód a uvedený výsledek byly ověřeny v izolovaném prostředí metodou zaznamenanou v dokladu o ověření této přesné verze.

Zdroje