Baza znanjaIzpitno središče
SLSlovenščina
Izberi jezik13

CKTIS / C++

Arhitektura programa: odgovornosti in odvisnosti

Arhitektura programa določa odgovornosti, smer odvisnosti in lastništvo objektov. Primer združuje strategy pattern, factory registry, dependency injection in decorator; singleton obravnava kot ločeno odločitev o dostopu in življenjski dobi.

Različica: C++23; repository compiler flag, production runtime not attested

Sintaksa

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

Arhitektura programa opisuje meje komponent, njihove odgovornosti, odvisnosti in življenjske dobe. Ni ključna beseda C++. Spodnji vzorci so načrtovalske konvencije, ne funkcije standardne knjižnice. Viri opisujejo mehanizme jezika, ne kataloga vzorcev. Priloženi delovni osnutek se razvija in ni nespremenljiva specifikacija C++23; zastavica prevajalnika v repozitoriju ne potrjuje produkcijskega okolja.

Strategy pattern loči zamenljiv algoritem od njegovega odjemalca: Double implementira Strategy, Runner pa uporablja vmesnik. Dependency injection pomeni, da odvisnost zagotovimo od zunaj; konstruktor Runner prejme referenco, namesto da bi strategijo ustvaril sam. Pri klicu navidezne funkcije se implementacija izbere glede na dinamični tip objekta; override omogoča, da prevajalnik zazna neujemajočo se deklaracijo.

Factory registry preslika ključe v funkcije za ustvarjanje objektov. Tukaj registry.at("double")() ustvari strategijo; neznan ključ povzroči std::out_of_range. Decorator ovije objekt in ohrani njegov vmesnik: AddOne delegira strategiji, nato pa prišteje ena. Register izbere ustvarjanje, strategija algoritem, dekorator pa razširi vedenje.

std::unique_ptr izraža izključno lastništvo; navidezni destruktor omogoča pravilno brisanje prek kazalca na Strategy. AddOne zahteva neničelni kazalec. Referenca v Runner ni lastniška: referenčna strategija mora živeti dlje od odjemalca, ki jo uporablja. Primer izpolnjuje oba pogoja in za 3 vrne 7.

Singleton omeji razred na en primerek in zagotovi globalno dostopno točko. Tukaj ni potreben: sestavljanje objektov poteka v main. Lokalni objekt static v funkciji lahko podpira takšno izvedbo; sočasna inicializacija počaka na dokončanje, vendar poznejše operacije na objektu zaradi tega samodejno niso varne za niti. Globalni dostop lahko skrije odvisnosti in oteži izolacijo testov.

Primeri

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

Rezultat

7

Prikazana koda in navedeni rezultat sta bila preverjena v izoliranem okolju z metodo, zapisano v dokazilu o preverjanju te natančne različice.

Viri