Clases abstractas

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

Una clase abstracta es cualquier clase que contiene al menos una función virtual pura. Debido a que tiene una interfaz incompleta, no se pueden crear objetos de una clase abstracta directamente; existe únicamente para ser heredada.

class Shape {
public:
    virtual double area() = 0;      // Virtual pura - hace que Shape sea abstracta
    virtual double perimeter() = 0; // Otra función virtual pura
    
    void printInfo() {              // Método regular - tiene implementación
        std::cout << "Area: " << area() << std::endl;
    }
    
    virtual ~Shape() = default;
};

Shape s;  // Error: no se puede instanciar una clase abstracta

Las clases abstractas pueden contener una mezcla de funciones virtuales puras (sin implementación), funciones virtuales regulares (con implementación por defecto) y funciones no virtuales. Esto le permite definir un comportamiento común mientras requiere que las clases derivadas implementen una funcionalidad específica.

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    
    double area() override { return 3.14159 * radius * radius; }
    double perimeter() override { return 2 * 3.14159 * radius; }
};

Circle c(5.0);      // OK: Circle implementa todas las funciones virtuales puras
c.printInfo();      // Usa printInfo() heredado, llama a area() de Circle

Una clase derivada debe implementar todas las funciones virtuales puras para volverse concreta (instanciable). Si deja alguna sin implementar, seguirá siendo abstracta. Este mecanismo asegura que cada clase concreta en su jerarquía proporcione la funcionalidad requerida.

Desafío

Fácil

Vamos a construir un sistema de reproductor de medios que demuestre cómo las clases abstractas definen contratos para diferentes tipos de medios. Crearás una clase base abstracta que establezca lo que cada reproductor de medios debe hacer, y luego implementarás reproductores concretos para contenido de audio y video.

Organizarás tu código en tres archivos:

MediaPlayer.h: Define una clase abstracta MediaPlayer que sirva como plano para todos los tipos de medios. Tu clase abstracta debe tener:
- Un miembro protegido std::string title
- Un miembro protegido int duration (en segundos)
- Un constructor que inicialice ambos valores
- Un método virtual puro play() — cada tipo de medio se reproducirá de manera diferente
- Un método virtual puro getMediaType() que devuelva un std::string
- Un método regular (no virtual) showInfo() que imprima: <title> (<duration>s) - Type: <mediaType> — este método debe llamar a getMediaType() para obtener el tipo
- Un destructor virtual
Players.h: Implementa dos reproductores de medios concretos que hereden de MediaPlayer:
AudioPlayer:
- Un miembro privado std::string artist
- Un constructor que reciba title, duration y artist
- Implementa play() para imprimir: Playing audio: <title> by <artist>
- Implementa getMediaType() para devolver "Audio"
VideoPlayer:
- Un miembro privado std::string resolution
- Un constructor que reciba title, duration y resolution
- Implementa play() para imprimir: Playing video: <title> in <resolution>
- Implementa getMediaType() para devolver "Video"
main.cpp: Lee cuatro entradas (cada una en una línea separada):
1. Título de la pista de audio
2. Duración del audio (entero)
3. Título del video
4. Duración del video (entero)
Crea un AudioPlayer con el artista "Unknown Artist" y un VideoPlayer con la resolución "1080p". Almacena ambos en un arreglo de punteros MediaPlayer*.

Recorre el arreglo y para cada reproductor, primero llama a showInfo(), luego llama a play(). Imprime una línea en blanco entre cada elemento multimedia. Limpia tus objetos asignados dinámicamente cuando hayas terminado.

Por ejemplo, con las entradas Summer Vibes, 180, Nature Documentary, y 3600:

Summer Vibes (180s) - Type: Audio
Playing audio: Summer Vibes by Unknown Artist

Nature Documentary (3600s) - Type: Video
Playing video: Nature Documentary in 1080p

Observa cómo el método showInfo() se define una vez en la clase base abstracta pero llama al método virtual puro getMediaType() — esto demuestra cómo las clases abstractas pueden mezclar implementaciones concretas con métodos que las clases derivadas deben proporcionar. Recuerda usar la palabra clave override en todos los métodos sobrescritos.

Hoja de referencia

Una clase abstracta contiene al menos una función virtual pura y no puede ser instanciada directamente. Existe para ser heredada y definir una interfaz para las clases derivadas.

Definición de una clase abstracta

Use = 0 para declarar una función virtual pura:

class Shape {
public:
    virtual double area() = 0;      // Función virtual pura
    virtual double perimeter() = 0; // Hace que Shape sea abstracta
    
    void printInfo() {              // Método regular con implementación
        std::cout << "Area: " << area() << std::endl;
    }
    
    virtual ~Shape() = default;     // Destructor virtual
};

Las clases abstractas pueden contener:

Funciones virtuales puras (sin implementación)
Funciones virtuales regulares (con implementación por defecto)
Funciones no virtuales

Implementación de clases concretas

Una clase derivada debe implementar todas las funciones virtuales puras para poder ser instanciada:

class Circle : public Shape {
    double radius;
public:
    Circle(double r) : radius(r) {}
    
    double area() override { return 3.14159 * radius * radius; }
    double perimeter() override { return 2 * 3.14159 * radius; }
};

Circle c(5.0);      // Correcto: todas las funciones virtuales puras están implementadas
c.printInfo();      // El método heredado llama a area() de Circle

Si una clase derivada no implementa todas las funciones virtuales puras, sigue siendo abstracta y no puede ser instanciada.

Pruébalo tú mismo

#include <iostream>
#include <string>
#include "MediaPlayer.h"
#include "Players.h"

int main() {
    // Leer entradas
    std::string audioTitle;
    int audioDuration;
    std::string videoTitle;
    int videoDuration;
    
    std::getline(std::cin, audioTitle);
    std::cin >> audioDuration;
    std::cin.ignore();
    std::getline(std::cin, videoTitle);
    std::cin >> videoDuration;
    
    // TODO: Crear un AudioPlayer con el artista "Unknown Artist"
    
    // TODO: Crear un VideoPlayer con la resolución "1080p"
    
    // TODO: Almacenar ambos en un arreglo de punteros MediaPlayer*
    
    // TODO: Recorrer el arreglo y para cada reproductor:
    //       1. Llamar a showInfo()
    //       2. Llamar a play()
    //       3. Imprimir una línea en blanco entre cada elemento multimedia
    
    // TODO: Limpiar los objetos asignados dinámicamente
    
    return 0;
}