Injeção de Dependência em C++: um guia simples para iniciantes

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

Quando você começa a aprender C++, escreve programas simples onde as classes criam suas dependências diretamente. Por exemplo, a classe Car cria sozinha um objeto Engine. Isso funciona para projetos pequenos, mas quando o código cresce, essa abordagem leva a sérios problemas: o código se torna fortemente acoplado, difícil de testar e modificar.

Injeção de Dependência (DI) é um padrão de projeto no qual um objeto recebe suas dependências de fora, em vez de criá-las por conta própria. Este é um dos princípios-chave do SOLID, especificamente o Princípio da Inversão de Dependência (Dependency Inversion Principle).

Neste artigo, vamos explorar o que é Injeção de Dependência em C++, por que ela é necessária e como aplicá-la na prática. Você verá como esse padrão torna o código flexível, testável e de fácil manutenção.

Por que sem DI é ruim: o problema do acoplamento forte

Imagine que você está escrevendo um sistema de gerenciamento de casa inteligente. Existe uma classe SmartLight que controla uma lâmpada. Em uma implementação ingênua, ela mesma cria um objeto Bulb:

#include <iostream>#include <string>

class Bulb {public:    void turnOn() { std::cout << "Lâmpada ligada"; }    void turnOff() { std::cout << "Lâmpada desligada"; }};

class SmartLight {private:    Bulb bulb;  // Dependência rígidapublic:    void activate() { bulb.turnOn(); }    void deactivate() { bulb.turnOff(); }};

int main() {    SmartLight light;    light.activate();    return 0;}

Quais são os problemas aqui?

• Acoplamento forte: SmartLight está inextricavelmente ligado a Bulb. Se você quiser usar outra lâmpada (por exemplo, uma LED inteligente ou Phillips Hue), terá que alterar o código da classe.
• Dificuldade de teste: Você não pode substituir a lâmpada real por um "mock" (simulacro) em testes unitários.
• Violação do SRP: A classe SmartLight faz duas coisas: gerencia a lâmpada e a cria.

Este é um exemplo clássico de acoplamento forte (tight coupling), que a Injeção de Dependência visa eliminar.

O que é Injeção de Dependência em C++: conceitos principais

Injeção de Dependência (DI) é uma técnica na qual um objeto recebe suas dependências (geralmente através do construtor, setter ou interface) de uma fonte externa, em vez de criá-las ele mesmo. A ideia principal é: "Não pergunte o que você precisa — eles lhe darão".

Em C++, a DI é implementada através de:

• Interfaces (classes abstratas): As dependências são declaradas através de tipos abstratos, não classes concretas.
• Construtor com parâmetros: As dependências são passadas através do construtor (a maneira mais comum).
• Setters: As dependências são definidas após a criação do objeto.
• Contêineres de dependência: Bibliotecas especiais que criam e injetam dependências automaticamente (por exemplo, boost.di).

Vamos reescrever o exemplo da luz inteligente usando DI:

#include <iostream>#include <memory>

// Interface abstrata para a lâmpadaclass IBulb {public:    virtual void turnOn() = 0;    virtual void turnOff() = 0;    virtual ~IBulb() = default;};

// Implementação concreta: lâmpada comumclass Bulb : public IBulb {public:    void turnOn() override { std::cout << "Lâmpada ligada"; }    void turnOff() override { std::cout << "Lâmpada desligada"; }};

// Outra implementação: lâmpada LEDclass LedBulb : public IBulb {public:    void turnOn() override { std::cout << "Lâmpada LED ligada"; }    void turnOff() override {