Patrón Adapter

Parte de la sección Programación Orientada a Objetos del Journey de C++ de Coddy — lección 97 de 104.

El patrón Adapter permite que interfaces incompatibles trabajen juntas. Actúa como un puente entre dos clases, convirtiendo la interfaz de una clase en una interfaz que los clientes esperan. Esto es particularmente útil al integrar código heredado o bibliotecas de terceros que no coinciden con la interfaz de su sistema.

Imagina que tienes una clase existente que hace lo que necesitas, pero su interfaz no coincide con lo que tu código espera. En lugar de modificar cualquiera de los dos lados, creas un adaptador que envuelve la clase existente y traduce las llamadas:

#include <iostream>
#include <string>

// Clase existente con interfaz incompatible
class LegacyPrinter {
public:
    void printMessage(const std::string& msg) {
        std::cout << "Legacy: " << msg << "\n";
    }
};

// Interfaz objetivo que el cliente espera
class Printer {
public:
    virtual void print(const std::string& text) = 0;
    virtual ~Printer() = default;
};

// El Adaptador envuelve a LegacyPrinter e implementa la interfaz Printer
class PrinterAdapter : public Printer {
    LegacyPrinter& legacy;
public:
    PrinterAdapter(LegacyPrinter& lp) : legacy(lp) {}
    
    void print(const std::string& text) override {
        legacy.printMessage(text);  // Traducir la llamada
    }
};

int main() {
    LegacyPrinter oldPrinter;
    PrinterAdapter adapter(oldPrinter);
    
    // El cliente utiliza la interfaz esperada
    adapter.print("Hello World");
}

El adaptador mantiene una referencia al LegacyPrinter e implementa la interfaz Printer. Cuando se llama a print(), este delega en printMessage(). El código del cliente trabaja con la interfaz Printer sin conocer la implementación heredada subyacente.

Utiliza Adapter cuando quieras usar una clase existente pero su interfaz no coincida con lo que necesitas, o cuando necesites crear una clase reutilizable que coopere con clases que tienen interfaces incompatibles.

Desafío

Fácil

Vamos a construir un sistema de Adaptador de Reproductor de Medios que conecte diferentes interfaces de bibliotecas de audio. Imagina que estás integrando una biblioteca de audio heredada (legacy) en una aplicación de reproducción de medios moderna: la biblioteca antigua funciona perfectamente, pero su interfaz no coincide con lo que espera tu reproductor. Aquí es exactamente donde brilla el patrón Adapter.

Organizarás tu código en cuatro archivos:

MediaPlayer.h: Define la interfaz objetivo que espera tu reproductor de medios moderno.
Crea una clase abstracta MediaPlayer con estos métodos virtuales puros:
- play(const std::string& filename) — reproduce el archivo especificado
- stop() — detiene la reproducción
- setVolume(int level) — establece el volumen (0-100)
Incluye un destructor virtual.
LegacyAudioLib.h: Crea la biblioteca de audio "heredada" existente con una interfaz incompatible.
Tu clase LegacyAudioLib representa una biblioteca antigua que funciona de manera diferente a lo que espera tu reproductor. Debe tener:
- loadAudio(const std::string& path) — imprime "Legacy: Loading " seguido de path
- startPlayback() — imprime "Legacy: Playback started"
- stopPlayback() — imprime "Legacy: Playback stopped"
- adjustVolume(double percentage) — recibe un decimal (0.0 a 1.0) e imprime "Legacy: Volume set to " seguido de percentage (muestra el valor decimal)
AudioAdapter.h: Construye el adaptador que conecta las dos interfaces.
Tu clase AudioAdapter debe heredar de MediaPlayer y mantener una referencia a un objeto LegacyAudioLib. El adaptador traduce las llamadas de la interfaz moderna a la heredada:
- play() debe llamar tanto a loadAudio() como a startPlayback() en la biblioteca heredada
- stop() debe delegar en stopPlayback()
- setVolume() recibe un entero (0-100) pero la biblioteca heredada espera un decimal (0.0-1.0), por lo que deberás convertirlo
main.cpp: Demuestra el adaptador en acción.
Lee dos entradas:
1. Un nombre de archivo para reproducir (string)
2. Un nivel de volumen (entero, 0-100)
Crea una instancia de LegacyAudioLib y un AudioAdapter que la envuelva. Luego usa el adaptador a través de la interfaz MediaPlayer (almacénalo como un puntero MediaPlayer) para:
1. Establecer el volumen al nivel de entrada
2. Reproducir el nombre de archivo de entrada
3. Detener la reproducción

Por ejemplo, con las entradas "song.mp3" y 75:

Legacy: Volume set to 0.75
Legacy: Loading song.mp3
Legacy: Playback started
Legacy: Playback stopped

Con las entradas "podcast.wav" y 50:

Legacy: Volume set to 0.5
Legacy: Loading podcast.wav
Legacy: Playback started
Legacy: Playback stopped

Observa cómo el código del cliente trabaja completamente con la interfaz MediaPlayer; no tiene idea de que una biblioteca heredada está realizando el trabajo real por debajo. El adaptador se encarga de toda la traducción, incluyendo la conversión del volumen entero a decimal. Esta es la esencia del patrón Adapter: hacer que interfaces incompatibles trabajen juntas sin modificar ninguna de las partes.

Hoja de referencia

El patrón Adapter permite que interfaces incompatibles trabajen juntas actuando como un puente entre dos clases. Convierte la interfaz de una clase en una interfaz que los clientes esperan.

Utilice el patrón Adapter cuando desee usar una clase existente pero su interfaz no coincida con lo que necesita, o al integrar código heredado o bibliotecas de terceros.

Estructura

El patrón consta de tres componentes principales:

Target Interface (Interfaz de Destino): La interfaz que el cliente espera
Adaptee (Adaptado): La clase existente con una interfaz incompatible
Adapter (Adaptador): Envuelve al adaptee e implementa la interfaz de destino, traduciendo las llamadas entre ellos

Ejemplo

#include <iostream>
#include <string>

// Clase existente con interfaz incompatible (Adaptee)
class LegacyPrinter {
public:
    void printMessage(const std::string& msg) {
        std::cout << "Legacy: " << msg << "\n";
    }
};

// Interfaz de destino que el cliente espera
class Printer {
public:
    virtual void print(const std::string& text) = 0;
    virtual ~Printer() = default;
};

// El Adapter envuelve a LegacyPrinter e implementa la interfaz Printer
class PrinterAdapter : public Printer {
    LegacyPrinter& legacy;
public:
    PrinterAdapter(LegacyPrinter& lp) : legacy(lp) {}
    
    void print(const std::string& text) override {
        legacy.printMessage(text);  // Traducir la llamada
    }
};

int main() {
    LegacyPrinter oldPrinter;
    PrinterAdapter adapter(oldPrinter);
    
    // El cliente utiliza la interfaz esperada
    adapter.print("Hello World");
}

El adaptador mantiene una referencia al adaptee e implementa la interfaz de destino. Cuando se llaman a los métodos en el adaptador, este delega en los métodos del adaptee, traduciendo las llamadas según sea necesario. El código del cliente trabaja con la interfaz de destino sin conocer la implementación heredada.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "MediaPlayer.h"
#include "LegacyAudioLib.h"
#include "AudioAdapter.h"

using namespace std;

int main() {
    // Leer entradas
    string filename;
    int volumeLevel;
    cin >> filename;
    cin >> volumeLevel;
    
    // TODO: Crear una instancia de LegacyAudioLib
    
    // TODO: Crear un AudioAdapter que envuelva la biblioteca heredada
    
    // TODO: Almacenar el adaptador como un puntero de MediaPlayer
    
    // TODO: Usar la interfaz MediaPlayer para:
    // 1. Establecer el volumen al nivel de entrada
    // 2. Reproducir el filename de entrada
    // 3. Detener la reproducción
    
    return 0;
}