Implementación de Polimorfismo y Clases Abstractas en C++: Herencia y Funciones Virtuales

Configuración Inicial del Entorno C++

Este código fuente demuestra los principios fundamentales de la Programación Orientada a Objetos (POO) en C++, centrándose en la herencia, las clases abstractas y el polimorfismo mediante el uso de funciones virtuales.

#include <iostream>
#include <string>

using namespace std;

Implementación de Clases para POO

Clase Base Abstracta: ClaseBase

La ClaseBase actúa como un contrato o interfaz. Al contener una función virtual pura (= 0), se convierte en una clase abstracta, lo que impide la instanciación directa de objetos de este tipo. Define los datos y comportamientos comunes que todas las clases derivadas deben poseer o implementar.

Definición de Miembros y Funciones Virtuales

class ClaseBase {
public:
    // [MARCADOR 1] Variables comunes a todas las clases derivadas
    string ID_Objeto;
    int dato_base;

    // FUNCIÓN VIRTUAL PURA (Polimorfismo y Abstracción):
    // Debe ser implementada obligatoriamente por las clases derivadas.
    virtual void capturarDatos() = 0;

    // Función virtual simple (puede tener implementación o ser sobrescrita)
    virtual void mostrarInfo() const {
        cout << "ID Base: " << ID_Objeto << endl;
        cout << "Dato Base: " << dato_base << endl;
    }

    // Destructor virtual (Buena práctica esencial para el polimorfismo)
    virtual ~ClaseBase() {}
};

Clase Derivada: ClaseDerivada

La ClaseDerivada hereda de ClaseBase e implementa los métodos virtuales puros, además de añadir su propia lógica y atributos específicos.

Implementación de Métodos y Sobrescritura (override)

class ClaseDerivada : public ClaseBase {
private:
    // [MARCADOR 2] Variables específicas para esta clase
    string dato_derivado_privado;
    float valor_calculado;

public:
    // SOBRESCRITURA (override) de la Función Virtual Pura:
    void capturarDatos() override {
        cout << "\n--- Captura de Clase Derivada ---\n";
        // Captura de datos heredados de ClaseBase
        cout << "Ingrese ID del Objeto: ";
        getline(cin, ID_Objeto);
        cout << "Ingrese Dato Base (entero): ";
        cin >> dato_base;
        cin.ignore(); // Limpia el buffer después de leer el entero

        // Captura de datos propios
        cout << "Ingrese Dato Específico (string): ";
        getline(cin, dato_derivado_privado);

        // [MARCADOR 3] Lógica de cálculo o asignación
        valor_calculado = dato_base * 1.5;
    }

    // SOBRESCRITURA (override) de la Función Virtual simple:
    void mostrarInfo() const override {
        ClaseBase::mostrarInfo(); // Llama a la versión de la clase base
        cout << "Dato Derivado (Privado): " << dato_derivado_privado << endl;
        cout << "Valor Calculado: " << valor_calculado << endl;
    }
};

Función Principal y Demostración de Polimorfismo

La función main ilustra cómo se utiliza la herencia y, crucialmente, cómo el polimorfismo permite tratar objetos derivados a través de punteros de la clase base, invocando la implementación correcta en tiempo de ejecución.

int main() {
    // 1. Crear un objeto de la clase derivada
    ClaseDerivada objeto_A;

    // 2. Capturar sus datos usando el método sobrescrito
    objeto_A.capturarDatos();

    // 3. Mostrar sus datos (Llamada simple)
    cout << "\n--- Resultado Simple ---\n";
    objeto_A.mostrarInfo();

    // 4. DEMOSTRACIÓN DE POLIMORFISMO
    cout << "\n--- Resultado Polimórfico ---\n";
    
    // Crear un puntero a la clase base, apuntando al objeto derivado.
    // Esto es posible gracias a las funciones virtuales.
    ClaseBase* ptr_objeto = &objeto_A;
    
    // Llamada polimórfica: el compilador determina qué versión de mostrarInfo()
    // debe ejecutar en tiempo de ejecución (la de ClaseDerivada).
    ptr_objeto->mostrarInfo();

    return 0;
}