Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / C++

Arhitektura programa: odgovornosti i ovisnosti

Arhitektura programa određuje odgovornosti, smjer ovisnosti i vlasništvo nad objektima. Primjer kombinira strategy pattern, factory registry, dependency injection i decorator; singleton obrađuje kao zasebnu odluku o pristupu i životnom vijeku.

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

Sintaksa

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

Arhitektura programa opisuje granice komponenti, njihove odgovornosti, ovisnosti i životni vijek. Nije ključna riječ C++. Sljedeći obrasci su konvencije dizajna, a ne značajke standardne biblioteke. Izvori opisuju mehanizme jezika, a ne katalog obrazaca. Dostavljeni radni nacrt razvija se i nije nepromjenjiva specifikacija C++23; zastavica prevoditelja u repozitoriju ne potvrđuje produkcijsko okruženje.

Strategy pattern odvaja zamjenjiv algoritam od njegova klijenta: Double implementira Strategy, a Runner koristi sučelje. Dependency injection znači da se ovisnost osigurava izvana; konstruktor Runner prima referencu umjesto da sam stvara strategiju. Virtualni poziv odabire implementaciju prema dinamičkom tipu; override omogućuje otkrivanje neusklađene deklaracije tijekom prevođenja.

Factory registry preslikava ključeve u funkcije za stvaranje objekata. Ovdje registry.at("double")() stvara strategiju; nepoznat ključ uzrokuje std::out_of_range. Decorator omata objekt uz očuvanje njegova sučelja: AddOne delegira strategiji, a zatim dodaje jedan. Registar bira stvaranje, strategija bira algoritam, a dekorator proširuje ponašanje.

std::unique_ptr izražava isključivo vlasništvo; virtualni destruktor omogućuje ispravno brisanje putem pokazivača na Strategy. AddOne zahtijeva pokazivač koji nije null. Referenca u Runner nije vlasnička: referencirana strategija mora živjeti dulje od klijenta koji je koristi. Primjer ispunjava oba uvjeta i za 3 daje 7.

Singleton ograničava klasu na jednu instancu i pruža globalnu pristupnu točku. Ovdje nije potreban: sastavljanje objekata odvija se u main. Lokalni objekt static unutar funkcije može podržati takvu implementaciju; istodobna inicijalizacija čeka da se dovrši, ali kasnije operacije nad objektom time ne postaju automatski sigurne za niti. Globalni pristup može skrivati ovisnosti i otežati izolaciju testova.

Primjeri

#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

Prikazani kôd i navedeni rezultat provjereni su u izoliranom okruženju metodom zabilježenom u dokazu provjere za ovu točnu verziju.

Izvori