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 resulta especialmente útil al integrar código heredado o bibliotecas de terceros que no coinciden con la interfaz de tu 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;
};

// Adapter envuelve 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);  // Traduce la llamada
    }
};

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

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

Usa Adapter cuando quieras utilizar 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

Construyamos un sistema de adaptador de reproductor multimedia que conecte diferentes interfaces de bibliotecas de audio. Imagina que estás integrando una biblioteca de audio heredada en una aplicación moderna de reproductor multimedia: la biblioteca antigua funciona perfectamente, pero su interfaz no coincide con lo que espera tu reproductor. Este es exactamente el escenario en el que brilla el patrón Adapter.

Organizarás tu código en cuatro archivos:

MediaPlayer.h: Define la interfaz objetivo que espera tu reproductor multimedia 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 [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 [percentage] (muestra el valor decimal)
AudioAdapter.h: Construye el adaptador que conecta las dos interfaces.
Tu clase AudioAdapter debe heredar de MediaPlayer y contener 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), así que tendrás que convertirlo
main.cpp: Demuestra el adaptador en funcionamiento.
Lee dos entradas:
1. Un nombre de archivo para reproducir (cadena)
2. Un nivel de volumen (entero, 0-100)
Crea una instancia de LegacyAudioLib y un AudioAdapter que la envuelva. Después, utiliza el adaptador mediante la interfaz MediaPlayer (guárdalo como un puntero MediaPlayer) para:
1. Establecer el volumen al nivel introducido
2. Reproducir el nombre de archivo introducido
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 cliente trabaja completamente con la interfaz MediaPlayer. No tiene idea de que una biblioteca heredada está realizando el trabajo real por debajo. El adaptador gestiona toda la traducción, incluida la conversión del volumen entero a un decimal. Esta es la esencia del patrón Adapter: hacer que interfaces incompatibles trabajen juntas sin modificar ninguno de los dos lados.

Pruébalo tú mismo

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

using namespace std;

int main() {
    // Lee las entradas
    string filename;
    int volumeLevel;
    cin >> filename;
    cin >> volumeLevel;
    
    // TODO: Crea una instancia de LegacyAudioLib
    
    // TODO: Crea un AudioAdapter que envuelva la biblioteca heredada
    
    // TODO: Almacena el adaptador como un puntero a MediaPlayer
    
    // TODO: Usa la interfaz MediaPlayer para:
    // 1. Establece el volumen al nivel de entrada
    // 2. Reproduce el nombre de archivo de entrada
    // 3. Detén la reproducción
    
    return 0;
}