KennisbankExamencentrum
NL · NLNederlands (Nederland)
Taal kiezen13

CKTIS / C++

Programma-architectuur: verantwoordelijkheden en afhankelijkheden

Programma-architectuur bepaalt verantwoordelijkheden, de richting van afhankelijkheden en het eigendom van objecten. Het voorbeeld combineert strategy pattern, factory registry, dependency injection en decorator; singleton wordt apart behandeld als een keuze over toegang en levensduur.

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

Syntax

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

Programma-architectuur beschrijft componentgrenzen, verantwoordelijkheden, afhankelijkheden en levensduren. Het is geen C++-trefwoord. De patronen hieronder zijn ontwerpconventies, geen functies van de standaardbibliotheek. De bronnen beschrijven mechanismen van de taal, geen catalogus van patronen. Het meegeleverde werkdocument wordt bijgewerkt en is geen definitieve C++23-specificatie; een compileroptie in een repository bevestigt niet de productieomgeving.

Het strategy pattern scheidt een vervangbaar algoritme van de client: Double implementeert Strategy, en Runner gebruikt de interface. Dependency injection betekent dat een afhankelijkheid van buitenaf wordt aangeleverd; de constructor van Runner ontvangt een referentie in plaats van zelf een strategie te maken. Virtuele dispatch kiest de implementatie op basis van het dynamische type; override kan een niet-passende declaratie tijdens het compileren opsporen.

Een factory registry koppelt sleutels aan functies die objecten maken. Hier maakt registry.at("double")() een strategie; een onbekende sleutel veroorzaakt std::out_of_range. Een decorator omhult een object met behoud van de interface: AddOne delegeert aan de strategie en telt daarna één op. Het register kiest de creatie, de strategie kiest het algoritme en de decorator breidt het gedrag uit.

std::unique_ptr drukt exclusief eigendom uit; de virtuele destructor maakt correct verwijderen via een pointer naar Strategy mogelijk. AddOne vereist een niet-nulle pointer. De referentie in Runner is niet-eigenaar: de strategie waarnaar wordt verwezen moet langer leven dan de client die haar gebruikt. Het voorbeeld voldoet aan beide voorwaarden en levert voor 3 de waarde 7 op.

Een singleton beperkt een klasse tot één instantie en biedt een globaal toegangspunt. Hier is dat niet nodig: de objecten worden samengesteld in main. Een functie-lokaal static-object kan zo’n implementatie ondersteunen; gelijktijdige initialisatie wacht tot deze is voltooid, maar latere bewerkingen op het object worden daardoor niet automatisch threadveilig. Globale toegang kan afhankelijkheden verbergen en testisolatie bemoeilijken.

Voorbeelden

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

Resultaat

7

De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.

Bronnen