Inyección de Dependencias en C++: Guía Sencilla para Principiantes

Introducción a la Inyección de Dependencias en C++

Cuando recién comienzas a aprender C++, escribes programas simples donde las clases crean sus dependencias directamente. Por ejemplo, la clase Car crea por sí misma un objeto Engine. Esto funciona para proyectos pequeños, pero cuando el código crece, este enfoque conduce a problemas serios: el código se vuelve fuertemente acoplado, es difícil de probar y modificar.

Inyección de Dependencias (DI) es un patrón de diseño en el cual un objeto recibe sus dependencias desde el exterior, en lugar de crearlas por sí mismo. Este es uno de los principios clave de SOLID, específicamente el Principio de Inversión de Dependencias (Dependency Inversion Principle).

En este artículo, analizaremos qué es la Inyección de Dependencias en C++, por qué es necesaria y cómo aplicarla en la práctica. Verás cómo este patrón hace que el código sea flexible, comprobable y mantenible.

Por qué es malo sin DI: el problema del acoplamiento fuerte

Imagina que estás escribiendo un sistema de gestión para un hogar inteligente. Existe una clase SmartLight que controla una bombilla. En una implementación ingenua, ella misma crea un objeto Bulb:

#include <iostream>#include <string>

class Bulb {public:    void turnOn() { std::cout << "Bombilla encendida"; }    void turnOff() { std::cout << "Bombilla apagada"; }};

class SmartLight {private:    Bulb bulb;  // Dependencia fuertepublic:    void activate() { bulb.turnOn(); }    void deactivate() { bulb.turnOff(); }};

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

¿Cuáles son los problemas aquí?

• Acoplamiento fuerte: SmartLight está indisolublemente ligado a Bulb. Si deseas usar otra bombilla (por ejemplo, una LED inteligente o Phillips Hue), tendrás que modificar el código de la clase.
• Dificultad para probar: No puedes reemplazar la bombilla real por un "simulacro" (mock) en las pruebas unitarias.
• Violación del SRP: La clase SmartLight hace dos cosas: gestiona la bombilla y la crea.

Este es un ejemplo clásico de acoplamiento fuerte (tight coupling), que la Inyección de Dependencias busca eliminar.

Qué es la Inyección de Dependencias en C++: conceptos principales

Inyección de Dependencias (DI) es una técnica en la cual un objeto recibe sus dependencias (generalmente a través del constructor, un setter o una interfaz) desde una fuente externa, en lugar de crearlas él mismo. La idea principal: "No preguntes lo que necesitas — te lo darán".

En C++, la DI se implementa a través de:

• Interfaces (clases abstractas): Las dependencias se declaran mediante tipos abstractos, no clases concretas.
• Constructor con parámetros: Las dependencias se pasan a través del constructor (la forma más común).
• Setters: Las dependencias se establecen después de crear el objeto.
• Contenedores de dependencias: Bibliotecas especiales que crean e inyectan dependencias automáticamente (por ejemplo, boost.di).

Reescribamos el ejemplo de la luz inteligente usando DI:

#include <iostream>#include <memory>

// Interfaz abstracta para la bombillaclass IBulb {public:    virtual void turnOn() = 0;    virtual void turnOff() = 0;    virtual ~IBulb() = default;};

// Implementación concreta: bombilla normalclass Bulb : public IBulb {public:    void turnOn() override { std::cout << "Bombilla encendida"; }    void turnOff() override { std::cout << "Bombilla apagada"; }};

// Otra implementación: bombilla LEDclass LedBulb : public IBulb {public:    void turnOn() override { std::cout << "Bombilla LED encendida"; }    void turnOff() override {