EJERCICIO 3 (POO SECC.03)

#include <iostream>
#include <iomanip>
#include <string>
using namespace std;
// Declaracion de la clase y sus miembros privados y publicos
class TipoAlimento
{
private:
    string tipo;
    string clas;
    int i = 0;
    int j = 0;

public:
    TipoAlimento(string tipo = "Ninguno", string clas = "Ninguno");
    void ingresardatos();
    void añadiralimento();
    void modificaralimento();
    void borraralimento();
    void salirmenu();
    void desplegardatos();
};

TipoAlimento alimentos[15]; // Arreglo con una capacidad maxima de 15 entradas para los datos

int cant = 0; // Variable de control para la cantidad de alimentos que vaya a ingresar un usuario

// Definicion de el miembro constructor de la clase TipoAlimento
TipoAlimento::TipoAlimento(string t, string c)
{
    tipo = t;
    clas = c;
}

void TipoAlimento::ingresardatos() // Objeto para ingresar los respectivos datos para las caracteristicas de cada alimento
{
    cout << "\nIngrese el tipo del alimento, si es basico o procesado: ";
    cin >> tipo;
    if (tipo == "Basico" || tipo == "basico")
    {
        cout << "\n---------------------------------------------------------------------------------" << endl;
        cout << "| Usted ha ingresado un alimento de tipo basico, por lo tanto, ingrese su clase:|" << endl
             << "---------------------------------------------------------------------------------" << endl
             << "|    Lacteo    |    Carne    |    Fruta    |    Vegetal    |       Cereal       |" << endl
             << "---------------------------------------------------------------------------------\n";
        cin >> clas;
    }
    cout << "\nLos datos se han guardado exitosamente!\n";
}

void TipoAlimento::añadiralimento() // Objeto para añadir un nuevo alimento dentro de la memoria del arreglo
{
    if (cant >= 15)
    {
        cout << "Usted ha alcanzado la cantidad maxima de alimentos para ingresar...\n";
    }
    else
    {
        alimentos[cant].ingresardatos();
        cant++;
    }
}

void TipoAlimento::borraralimento() // Objeto para borrar un alimento ingresado dentro de la memoria del arreglo
{
    int opc;
    string aux;
    cout << "\nUsted ha elegido la opcion para borrar los datos de un alimento" << endl;
    cout << "Elija cual alimento desea borrar:\n";
    if (cant == 0)
    {
        cout << "Usted no ha añadido ningun alimento hasta ahora, por favor vuelta a intentarlo mas tarde..." << endl
             << "\n";
    }
    else
    {
        for (int i = 1; i <= cant; i++)
        {
            cout << "Alimento " << i << endl;
        }
        do
        {
            cin >> opc;
            if (opc <= 0 || opc > cant)
            {
                cout << "Porfavor, ingrese una de las opciones establecidas por el programa...\n";
            }
        } while (opc <= 0 || opc > cant);
        opc = opc - 1;
        for (i = 0; i < cant; i++)
        {
            if (i == opc)
            {
                // Metodo inspirado en el metodo burbuja para ordenar los respectivos indices y eliminar el indice ingresado
                for (j = i; j < cant - 1; j++)
                {
                    alimentos[j] = alimentos[j + 1];
                }
                cant = cant - 1;
            }
        }
        cout << "\nDatos eliminados correctamente!" << endl;
    }
}

void TipoAlimento::modificaralimento() // Objeto para modificar algun dato ingresado para cualquier alimento existente
{
    int opc;
    cout << "\nUsted ha elegido la opcion para modificar los datos del alimento" << endl;
    cout << "Elija cual alimento desea cambiar:\n";
    if (cant == 0)
    {
        cout << "Usted no ha añadido ningun alimento hasta ahora, por favor vuelta a intentarlo mas tarde...\n";
    }
    else
    {
        for (int i = 1; i <= cant; i++)
        {
            cout << "Alimento " << i << endl;
        }
        do
        {
            cin >> opc;
            if (opc <= 0 || opc > cant)
            {
                cout << "Porfavor, ingrese una de las opciones establecidas por el programa...\n";
            }
        } while (opc <= 0 || opc > cant);
        opc = opc - 1;
        for (i = 0; i < cant; i++)
        {
            if (i == opc)
            {
                cout << "\nReingrese el tipo de alimento:\n";
                cin >> alimentos[i].tipo;
                if (alimentos[i].tipo == "Basico" || alimentos[i].tipo == "basico")
                {
                    cout << "\n---------------------------------------------------------------------------------" << endl
                         << "| Usted ha ingresado un alimento de tipo basico, por lo tanto, ingrese su clase:|" << endl
                         << "---------------------------------------------------------------------------------" << endl
                         << "|    Lacteo    |    Carne    |    Fruta    |    Vegetal    |       Cereal       |" << endl
                         << "---------------------------------------------------------------------------------\n";
                    cin >> alimentos[i].clas;
                }
                else
                {
                    // Si el tipo de dato que se reingresa es procesado, su clase se volvera un string con texto nulo
                    alimentos[i].clas = "\0";
                }
            }
        }
        cout << "\nDatos modificados exitosamente!" << endl;
    }
}

void TipoAlimento::salirmenu() // Objeto para salir del menu, desplegar los datos y salir del programa
{
    i = 0;
    if (cant == 0)
    {
        cout << "\nUsted no ingreso ningun alimento, por lo tanto no se ha desplegado ningun dato..." << endl;
    }
    else
    {
        cout << "\n";
        for (int x = 1; x <= cant; x++)
        {
            cout << "Para el alimento " << x << " sus caracteristicas son: " << endl;
            alimentos[i].desplegardatos();
            cout << "\n";
            i = i + 1;
        }
    }
}

void TipoAlimento::desplegardatos()
{
    cout << "Tipo: " << tipo << endl
         << "Clase: " << clas;
}

// Flujo principal
int main()
{
    int opc, opcmenu;
    string t, c;
    TipoAlimento alimentos("Ninguno", "Ninguno");
    cout << "Bienvenido a el examinador de alimentos, porfavor elija una de las opciones establecidas por el programa." << endl;
    do
    {
        cout << "\n-------------------------------------------------------------------" << endl
             << "|                            Menu                                 |" << endl
             << "-------------------------------------------------------------------" << endl
             << "| 1. Ingresar datos para el alimento                              |" << endl
             << "| 2. Modificar datos para el alimento                             |" << endl
             << "| 3. Eliminar alguno de los datos ingresados                      |" << endl
             << "| 4. Salir del programa y desplegar los datos ingresados          |" << endl
             << "-------------------------------------------------------------------\n";
        cout << "Porfavor, elija una de las opciones que se muestran la pantalla...\n";
        cin >> opcmenu;
        switch (opcmenu)
        {
        case 1:
            alimentos.añadiralimento();
            break;
        case 2:
            alimentos.modificaralimento();
            break;
        case 3:
            alimentos.borraralimento();
            break;
        case 4:
            alimentos.salirmenu();
            return 0;
        default:
            cout << "\nLa opcion ingresada no se encuentra en el rango establecido..." << endl
                 << "Vuelta a intentarlo" << endl
                 << "\n";
        }
    } while (opcmenu != 4);
}