Dependency Injection v C++: Jednoduché vysvětlení s příkladem

Dependency Injection v C++: Jednoduché vysvětlení s příkladem

Dependency Injection (DI) je návrhový vzor, který pomáhá oddělit závislosti mezi třídami a zlepšit testovatelnost, čitelnost a udržovatelnost kódu. V tomto článku si vysvětlíme základní principy DI a ukážeme jednoduchý příklad v jazyce C++.

Co je Dependency Injection?

Dependency Injection je technika, při které třída neinstanciuje své závislosti sama, ale dostává je zvenčí (například prostřednictvím konstruktoru, metody nebo vlastnosti). Tento přístup umožňuje snadno měnit implementace závislostí, což je užitečné například při testování nebo rozšiřování funkcionality.

Hlavní výhody DI:

Oddělení odpovědností: Třída se soustředí na svou hlavní funkci a neřeší vytváření závislostí.
Snadné testování: Závislosti lze snadno nahradit mocky nebo stubs.
Flexibilita: Implementace závislostí lze snadno měnit bez úprav hlavní třídy.

Jednoduchý příklad v C++

Představme si scénář, kde máme třídu Logger, která zapisuje zprávy, a třídu Application, která využívá logger k logování událostí.

Bez Dependency Injection

#include <iostream>
#include <string>

class Logger {
public:
    void log(const std::string& message) {
        std::cout << "Log: " << message << std::endl;
    }
};

class Application {
private:
    Logger logger; // Přímá závislost na Logger
public:
    void run() {
        logger.log("Application is running");
    }
};

int main() {
    Application app;
    app.run();
    return 0;
}

V tomto příkladu třída Application přímo vytváří instanci Logger. To znamená, že pokud bychom chtěli použít jiný typ loggeru (např. zapisující do souboru), museli bychom upravit kód třídy Application.

S Dependency Injection

#include <iostream>
#include <string>
#include <memory>

// Abstraktní rozhraní pro Logger
class ILogger {
public:
    virtual void log(const std::string& message) = 0;
    virtual ~ILogger() = default;
};

// Implementace konzolového loggeru
class ConsoleLogger : public ILogger {
public:
    void log(const std::string& message) override {
        std::cout << "Log: " << message << std::endl;
    }
};

// Třída Application s Dependency Injection
class Application {
private:
    std::shared_ptr<ILogger> logger; // Závislost je injektována
public:
    Application(std::shared_ptr<ILogger> logger) : logger(logger) {}

    void run() {
        logger->log("Application is running");
    }
};

int main() {
    // Vytvoření loggeru a injektování do Application
    std::shared_ptr<ILogger> logger = std::make_shared<ConsoleLogger>();
    Application app(logger);
    app.run();
    return 0;
}

V tomto příkladu jsme vytvořili abstraktní rozhraní ILogger a konkrétní implementaci ConsoleLogger. Třída Application nyní přijímá logger jako závislost prostřednictvím konstruktoru. To znamená, že můžeme snadno nahradit ConsoleLogger jinou implementací, aniž bychom museli měnit kód třídy Application.

Závěr

Dependency Injection je mocný nástroj, který zlepšuje modularitu a testovatelnost kódu. V C++ je běžné používat DI ve spojení s polymorfismem a chytrými ukazateli, což umožňuje snadnou správu životního cyklu objektů. Tento přístup je obzvláště užitečný v rozsáhlých projektech, kde je potřeba udržovat čistý a flexibilní kód.