#include <iostream>

class Forma {
public:
    // Función virtual pura
    virtual void dibujar() const = 0; // Esto convierte a Forma en una clase abstracta
};

class Circulo : public Forma {
public:
    void dibujar() const override {
        std::cout << "Dibujando un Círculo" << std::endl;
    }
};

class Cuadrado : public Forma {
public:
    void dibujar() const override {
        std::cout << "Dibujando un Cuadrado" << std::endl;
    }
};

int main() {
    Circulo c;
    Cuadrado q;

    // Punteros a la clase base abstracta
    Forma* formas[2] = { &c, &q };

    for (int i = 0; i < 2; ++i) {
        formas[i]->dibujar();
    }

    return 0;
}

/*
La clase `Forma` es una clase abstracta debido a que tiene un método virtual puro, `dibujar`, que se declara con `= 0` y `virtual`. Esto obliga a las clases derivadas a sobreescribir este método. La palabra clave `const` al final de la declaración del método `dibujar` garantiza que el método no modificará el estado del objeto.

Las clases `Circulo` y `Cuadrado` heredan de `Forma` y sobreescriben el método `dibujar` utilizando la palabra clave `override`, lo que asegura que están realmente sobreescribiendo un método virtual de la clase base. Estas clases pueden ser instanciadas, a diferencia de la clase abstracta `Forma`.

En el `main`, se crean objetos de las clases `Circulo` y `Cuadrado`. Luego, se crea un arreglo de punteros a la clase base abstracta `Forma`, y se asignan los objetos derivados a estos punteros. Esto permite que el método `dibujar` apropiado sea llamado en tiempo de ejecución para cada objeto en el arreglo.

La palabra clave `const` es importante en C++ porque permite que los métodos prometan no modificar el objeto en el que son llamados, lo que puede ayudar a prevenir errores y mejorar la claridad del código. Además, permite que los métodos sean llamados en objetos `const` o a través de punteros y referencias `const`, mejorando así la flexibilidad del código.
*/