//HERENCIA (SIMPLE/MULTIPLE)
#include <iostream>
#include <cmath>
using namespace std;
//****************CIRCULO.H**********************/
class Circulo 
{
  public:
    Circulo();
    Circulo(float _r);
    void Calcular_perimetro();
    void Calcular_area();
    float area, perimetro; //para menu
    ~Circulo();

protected:
    float radio;
};

//****************CONO.H**********************/
class Cono : public Circulo 
{
public:
    Cono();
    Cono(float _r, float _h);
    void Calcular_volumen();
    void Imprimir_Cono();
    ~Cono();

private:
    float altura, volumen;
};

//****************ESFERA.H**********************/
class Esfera : public Circulo 
{
public:
    Esfera();
    Esfera(float _r);
    void Calcular_volumen();
    void Imprimir_Esfera();
    ~Esfera();

private:
    float volumen;
};

//****************CILINDRO.H**********************/
class Cilindro : public Circulo 
{
public:
    Cilindro();
    Cilindro(float _r, float _h);
    void Calcular_volumen();
    void Imprimir_Cilindro();
    ~Cilindro();

private:
    float altura, volumen;
};

//****************CIRCULO.CPP*********************/
Circulo::Circulo() 
{
    radio = 1.0;
    area = perimetro = 0.0;
}

Circulo::Circulo(float _r) 
{
    radio = _r;
    area = perimetro = 0.0;
}

void Circulo::Calcular_perimetro() 
{
    perimetro = 2 * radio * M_PI;
}

void Circulo::Calcular_area() 
{
    area = M_PI * pow(radio, 2);
}

Circulo::~Circulo() 
{
    cout << "Fin Objeto Circulo" << endl;
}

//****************CONO.CPP***********************/
Cono::Cono() : Circulo() 
{
    volumen = 0.0;
    altura = 2.5;
}

Cono::Cono(float _r, float _h) : Circulo(_r) 
{
    altura = _h;
    volumen = 0.0;
}

void Cono::Calcular_volumen() 
{
    volumen = altura * area / 3;
}

void Cono::Imprimir_Cono() 
{
    cout << "Radio de la Base: "     << radio     << endl;
    cout << "Altura de la Base: "    << altura    << endl;
    cout << "Perimetro de la Base: " << perimetro << endl;
    cout << "Area de la Base: "      << area      << endl;
    cout << "Volumen del Cono: "     << volumen   << endl;
}

Cono::~Cono() 
{
    cout << "Fin Objeto Cono" << endl;
}

//****************ESFERA.CPP*********************/
Esfera::Esfera() : Circulo() 
{
    volumen = 0.0;
}

Esfera::Esfera(float _r) : Circulo(_r) 
{
    volumen = 0.0;
}

void Esfera::Calcular_volumen() 
{
    volumen = (4/3) * M_PI * pow(radio, 3);
}

void Esfera::Imprimir_Esfera() 
{
    cout << "Radio de la Esfera: "   << radio   << endl;
    cout << "Volumen de la Esfera: " << volumen << endl;
}

Esfera::~Esfera() 
{
    cout << "Fin Objeto Esfera" << endl;
}

//****************CILINDRO.CPP*********************
Cilindro::Cilindro() : Circulo() 
{
    altura = 1.0;
    volumen = 0.0;
}

Cilindro::Cilindro(float _r, float _h) : Circulo(_r) 
{
    altura = _h;
    volumen = 0.0;
}

void Cilindro::Calcular_volumen() 
{
    volumen = area * altura;
}

void Cilindro::Imprimir_Cilindro() 
{
    cout << "Radio de la Base del Cilindro: " << radio << endl;
    cout << "Altura del Cilindro: " << altura << endl;
    cout << "Volumen del Cilindro: " << volumen << endl;
}

Cilindro::~Cilindro() 
{
    cout << "Fin Objeto Cilindro" << endl;
}

//****************MAIN.CPP**********************
void mostrar_menu() 
{
    int opcion;
    do {
        cout << "=====================================" << endl;
        cout << "            MENU PRINCIPAL           " << endl;
        cout << "=====================================" << endl;
        cout << "1. Crear un Circulo"                   << endl;
        cout << "2. Crear un Cono"                      << endl;
        cout << "3. Crear una Esfera"                   << endl;
        cout << "4. Crear un Cilindro"                  << endl;
        cout << "0. Salir"                              << endl;
        cout << "Seleccione una opcion: "               <<endl;
        cin >> opcion;

        switch (opcion) 
		{
            case 1: 
			{
                /*float radio;
                cout << "Ingrese el radio del circulo: ";
                cin >> radio;
                Circulo circulo(radio);
                circulo.Calcular_perimetro();
                circulo.Calcular_area();
                cout << "Perimetro del circulo: " << circulo.perimetro << endl;
                cout << "Area del circulo: "      << circulo.area << endl;
                break;*/
                
            }
            case 2: 
			{
                float radio, altura;
                cout << "Ingrese el radio de la base del cono: ";
                cin >> radio;
                cout << "Ingrese la altura del cono: ";
                cin >> altura;
                Cono cono(radio, altura);
                cono.Calcular_perimetro();
                cono.Calcular_area();
                cono.Calcular_volumen();
                cono.Imprimir_Cono();
                break;
                
                cout << "**********************"<<endl;
                Cono *Cono1 = new Cono();
                Cono1->Calcular_perimetro();
                Cono1->Calcular_area();
                Cono1->Calcular_volumen();
                Cono1->Imprimir_Cono();
                delete Cono1;
                
                cout << "**********************"<<endl;
                Cono *Cono2 = new Cono(5, 5.3);
                Cono2->Calcular_perimetro();
                Cono2->Calcular_area();
                Cono2->Calcular_volumen();
                Cono2->Imprimir_Cono();
                delete Cono2;
            }
            case 3: 
			{
                /*float radio;
                cout << "Ingrese el radio de la esfera: ";
                cin >> radio;
                Esfera esfera(radio);
                esfera.Calcular_volumen();
                esfera.Imprimir_Esfera();
                break;*/
                //void herencia_multiple() 
                //{
                  cout << "**********************"<<endl;
                  Esfera *esfera = new Esfera(3);
				  esfera->Calcular_volumen();
				  esfera->Imprimir_Esfera();
				  delete esfera;
                  cout << "**********************"<<endl;
				  Cilindro *cilindro = new Cilindro(3, 7);
				  cilindro->Calcular_volumen();
				  cilindro->Imprimir_Cilindro();
				  delete cilindro;
				  //}
            }
            case 4: 
			{
                float radio, altura;
                cout << "Ingrese el radio de la base del cilindro: ";
                cin >> radio;
                cout << "Ingrese la altura del cilindro: ";
                cin >> altura;
                Cilindro cilindro(radio, altura);
                cilindro.Calcular_perimetro();
                cilindro.Calcular_area();
                cilindro.Calcular_volumen();
                cilindro.Imprimir_Cilindro();
                break;
            }
            case 0:
                cout << "Saliendo del programa..." << endl;
                break;
            default:
                cout << "Opción inválida. Intente nuevamente." << endl;
                break;
        }
    } while (opcion != 0);
}

int main() 
{
    mostrar_menu();
    return 0;
}