Injeção de Dependência (Dependency Injection) em C++: guia completo

Introdução à Injeção de Dependência em C++

Injeção de Dependência (DI) é um dos padrões de design fundamentais que implementa o princípio de inversão de controle (Inversion of Control, IoC). No contexto de C++, a DI permite criar aplicações fracamente acopladas, testáveis e facilmente mantíveis. Em vez de a classe criar suas próprias dependências (objetos dos quais depende), essas dependências são passadas (injetadas) externamente.

Imagine um exemplo clássico: a classe Car usa um motor. Sem DI, Car cria ela mesma uma instância específica de Engine. Com DI, Car recebe um Engine pronto através do construtor. Isso muda radicalmente a arquitetura, tornando o código flexível e adequado para testes unitários.

Por que a Injeção de Dependência é importante para projetos C++?

A aplicação de DI em C++ resolve vários problemas críticos que surgem no desenvolvimento de sistemas complexos.

Vantagens de usar DI

• Baixo Acoplamento (Loose Coupling): As classes dependem de abstrações (interfaces), não de implementações concretas. Isso permite substituir facilmente uma implementação por outra (por exemplo, substituir um banco de dados real por um objeto mock para testes).
• Simplificação de Testes: Você pode inserir objetos mock ou objetos stub para isolar a classe sendo testada. Esta é a pedra angular dos testes unitários.
• Aumento da Reutilização de Código: Os componentes tornam-se modulares e podem ser reutilizados em diferentes contextos.
• Suporte aos Princípios SOLID: A DI suporta diretamente o princípio da inversão de dependência (Dependency Inversion Principle, DIP) — módulos de alto nível não devem depender de módulos de baixo nível; ambos devem depender de abstrações.

Problemas resolvidos pela DI

• Alto Acoplamento: Sem DI, alterar a implementação de uma dependência (por exemplo, mudar de SGBD) requer alterar o código em todas as classes que a utilizam.
• Dificuldade de Teste: É impossível testar uma classe que cria internamente um objeto que interage com o sistema de arquivos ou a rede.
• Dificuldades com Configuração: É difícil gerenciar o ciclo de vida dos objetos e sua configuração em projetos grandes.

Formas de Implementar Injeção de Dependência em C++

Em C++, existem três formas principais de injetar dependências. Vamos examinar cada uma com exemplos de código.

1. Injeção via Construtor (Constructor Injection)

A forma mais comum e preferida. As dependências são passadas para o construtor da classe. Isso garante que o objeto esteja sempre em um estado válido.

#include <iostream>#include <memory>

// Abstração (interface)class ILogger {public:    virtual ~ILogger() = default;    virtual void log(const std::string& message) = 0;};

// Implementação concreta 1class ConsoleLogger : public ILogger {public:    void log(const std::string& message) override {        std::cout << "Console: " << message << std::endl;    }};

// Implementação concreta 2 (para testes)class MockLogger : public ILogger {public:    void log(const std::string& message) override {        // Não faz nada, apenas um stub    }};

// Classe que usa DIclass UserService {private:    std::unique_ptr<ILogger> logger_; // Dependência da abstraçãopublic:    // Injeção via construtor    explicit UserService(std::unique_ptr<ILogger> logger) : logger_(std::move(logger)) {}

    void createUser(const std::string& name) {        // ... lógica de negócios ...        logger_->log("User created: " + name);    }};

int main() {    // Injetando o logger real    auto service = UserService(std::m
```