PI ENTREGA 5.1

#include <iostream> //LIBRERIA IOSTREAM permite ingresar y mostrar en pantalla texto.
#include <cstring>  //LIBRERIA CSTRING facilita el uso de strings, con comandos como lenght.
#include <stdlib.h> //LIBRERIA STDLIB es una biblioteca estandar, se agrego para la funcion limpiar().
#include <conio.h>  //LIBRERIA CONIO.H permite usar la funcion getch(), hace que no se cierre la terminal al ser ejecutado el programa.
using namespace std;

// Funcion del programa
// Sistema para registrar, administrar y consultar prestamos

/*
===================
     VARIABLES
===================
*/

const int dFisica = 100; // DIMENSION FISICA DE LOS ARREGLOS

int cantidad_categorias = 0;   // Variable para saber la dimension logica de las categorias
int cantidad_prestamos = 0;    // Lo mismo que la anterior para los prestamos
int cantidad_prestatarios = 0; // Lo mismo para los prestatarios

/*
================
     STRUCS
================
*/

struct categoria
{ // Plantilla del struct para las categorias
    int codigo_categoria;
    string descripcion;
};

struct prestamo
{ // Plantilla del struct para los prestamos
    int codigo_categoria;
    int prestatario;
    string descripcion;
    bool estado;
};

struct prestatario
{ // Plantilla del struct para prestatarios
    int codigo_prestatario;
    string apellido;
    string nombre;
};
struct nodoprestamo{
    //Plantilla del struct para cada nodo de prestamos
    prestamo prestamo;
    nodoprestamo* siguiente;
};

categoria categorias[dFisica]; //Definicion de los arreglos estaticos para las categorias y los prestatarios
prestatario prestatarios[dFisica];

/*
===================
     FUNCIONES
===================
*/

void limpiar()
{
    // Funcion limpiar
    // PROPOSITO: Limpiar la pantalla mediante system("cls")
    // PARAMETROS: No pide ningun parametro
    // RETORNO:No retorna nada ya que es del tipo void

    system("cls");
}

string mayuscula(string cadena)
{
    // Funcion mayuscula
    // PROPOSITO: Hacer que el string ingresado, retorne en mayusculas, sirve para normalizar los string que se utilicen y evitar errores al compararlos
    // PARAMETROS: Un string deseado para convertirlo en mayusculas
    // RETORNO: Retorna un string que es el mismo que el ingresado, pero con todas sus letras en mayusculas
    int largo=cadena.length(); //Se busca el largo de la cadena

    for (int i = 0; i < largo; i++) //Se recorre la cadena haciendo que sus elementos se transformen en su version toupper(mayuscula)
    {
        cadena[i] = toupper(cadena[i]);
    }
    return cadena; //Se retorna la cadena
}

string title(string frase)
{
    // FUNCION: title
    // PROPOSITO: visual, retornar una cadena de caracteres en formato titulo
    // PARAMETROS: string
    // RETORNO: retorna un string en formato titulo

    string frase_aux = frase; //Se crea una cadena auxiliar
    int largo=frase_aux.length(); //Se almacena el largo de la cadena en la variable "largo"
    frase_aux[0] = toupper(frase_aux[0]); //Se pone la primera letra en mayuscula
    for (int i = 1; i < largo; i++) //Se recorre la cadena desde la segunda letra poniendo las letras en minuscula
    {
        frase_aux[i] = tolower(frase_aux[i]);
    }
    return (frase_aux); //Se retorna la cadena
}

string agregarCategoria(string descripcion)
{
    // Funcion agregar_categoria
    // PROPOSITO: Agregar una categoria al struct categorias, le asigna un codigo interno a la categoria y revisa que la categoria no este repetida
    // PARAMETROS: Descripcion de la categoria a agregar
    // RETORNO: Retorna un string que dice si se agrego o no la categoria

    for (int i = 0; i <= cantidad_categorias; i++)
    {
        if (mayuscula(descripcion) == mayuscula(categorias[i].descripcion))
        {
            return ("La categoria que desea agregar ya existe!"); //Se comprueba recorriendo el arreglo de categorias, si la categoria ya se encuentra registrada
        }
    }
    for (int i = 0; i <= cantidad_categorias; i++)
    {
        if (mayuscula(descripcion) != mayuscula(categorias[i].descripcion)) //Se recorre el arreglo
        {
            for (int j = cantidad_categorias; j < dFisica; j++)
            {
                categorias[j].codigo_categoria = cantidad_categorias; //Se almacena los datos de la categoria
                categorias[j].descripcion = descripcion;
                cantidad_categorias++; //Se aumenta el numero de categorias
                return ("Categoria agregada satisfatoriamente!"); //Se retorna el mensaje de exito
            }
        }
    }
    return ("default");
}

string modificarCategoria(string descripcion)
{
    // Funcion modificar_categoria
    // PROPOSITO: Modificar una categoria existente en el struct categorias
    // PARAMETROS: Descripcion de la categoria a modificar
    // RETORNO: Retorna un string que dice si la modificacion fue satisfatoria o no

    string categoria_modif;
    string aux = descripcion;

    for (int i = 0; i <= cantidad_categorias; i++)
    {
        if (mayuscula(categorias[i].descripcion) == mayuscula(aux)) //Se recorre el arreglo para ver si existe la categoria a modificar
        {
            cout << "La categoria a modificar ingresada es correcta!" << endl; //Se informa que xiste
            cout << "\nA continuacion ingrese el nuevo nombre para la categoria: "; //Se pide que se ingrese el nuevo nombre
            cin >> categoria_modif;
            categorias[i].descripcion = categoria_modif; //Se cambia
            limpiar();
            return ("Categoria modificada satisfactoriamente!"); //Se retorna el mensaje de exito
        }
    }
    for (int i = 0; i <= cantidad_categorias; i++)
    {
        if (mayuscula(categorias[i].descripcion) != mayuscula(aux))
        {
            return ("La categoria que desea modificar no existe!"); //Se recorre en diferido para evitar que se informe mas de una vez que no es igual
        }
    }
    return ("default");
}

string eliminarCategoria(string descripcion,nodoprestamo* inicio)
{
    // Funcion eliminar_categoria
    // PROPOSITO: Eliminar una categoria del struct antes nombrado, si y solo si la categoria no tiene un prestamo en activo
    // PARAMETROS: Descripcion de la categoria a eliminar y el inicio de la lista de prestamos
    // RETORNO: Retorna un string que dice si se pudo eliminar o no la categoria

    string descripcion_aux = descripcion;
    int posicion = 0;
    int codigo_cat = 0;
    bool ocupado=false;
    bool existe=false;
    for(int i=0;i<cantidad_categorias;i++){
        if(mayuscula(descripcion_aux)==mayuscula(categorias[i].descripcion)){  //Se recorre el arreglo para ver si existe la categoria
            codigo_cat=categorias[i].codigo_categoria;
            posicion=i;
            existe=true;
            break;
        }
    }
    if(existe==true){ //Si existe se pasa a recorrer la lista de prestamos para ver si se encuentra utilizada la categoria
        nodoprestamo* aux=new nodoprestamo;
        aux=inicio;
        if(aux!=NULL){
            while(aux!=NULL && ocupado==false){
                if(codigo_cat==aux->prestamo.codigo_categoria){
                    ocupado=true; //Si se encuentra, el bool ocupado toma el valor true
                }
                aux=aux->siguiente;
            }
        }
        if(ocupado!=true){ //Si no esta ocupada la categoria, se pasa a eliminar la categoria
            for(int i=posicion;i<cantidad_categorias;i++){
                categorias[i]=categorias[i+1];
                cantidad_categorias--;
                return("Categoria eliminada satisfactoriamente!");
            }
        }
        else if(ocupado==true){ // Si se encuentra ocupada se informa que no es posible eliminar
            return("La categoria que desea eliminar se encuentra registrada en un prestamo, no es posible eliminarla");
        }
    }
    else{ //Si el bool existe sigue en false, se informa que no existe la categoria
        return("La categoria que desea eliminar no existe");
    }
    return("Default");
}

string agregarPrestatario(string nombre, string apellido)
{
    // Funcion agregarPrestatario
    // PROPOSITO: Agregar un prestatario al struct prestatarios
    // PARAMETROS: Nombre y Apellido del prestatario a agregar
    // RETORNO: Retorna un string que dice si se agrego o no el prestatario

    int repetidos = 0;
    for (int i = 0; i <= cantidad_prestatarios; i++)
    {
        if (mayuscula(nombre) == mayuscula(prestatarios[i].nombre) && mayuscula(apellido) == mayuscula(prestatarios[i].apellido))
        {
            repetidos++; //Se recorre el arreglo de prestatarios para comprobar que el prestatario a agregar se encuentra o no registrado ya
        }
    }
    if (repetidos == 0) //Si repetidos es igual a 0(lo que indica que no se encuentra registrado ya, se pasa a agregar el prestatario al arreglo
    {
        prestatarios[cantidad_prestatarios].nombre = nombre;
        prestatarios[cantidad_prestatarios].apellido = apellido;
        prestatarios[cantidad_prestatarios].codigo_prestatario = cantidad_prestatarios;
        cantidad_prestatarios++;
        return ("Prestatario agregado satisfatoriamente!");
    }
    else{//Si repetido es diferente de 0, el prestatario ya se encuentra registrado, por lo tanto se informa que no se puede agregar
        return ("El prestatario que desea agregar ya existe!");
    }
}

string modificarPrestatario(string nombre, string apellido)
{
    // Funcion modificarPrestatario
    // PROPOSITO: modificar prestatario ya agregado
    // PARAMETROS: Nombre y apellido del prestatario a modificar
    // RETORNO: Retorna un string que indica si se modifico o no al prestatario que se desea

    string nombre_modif;
    string apellido_modif;
    string nombre_aux = nombre;
    string apellido_aux = apellido;
    for (int i = 0; i < cantidad_prestatarios; i++)
    {
        if (mayuscula(nombre_aux) == mayuscula(prestatarios[i].nombre) && mayuscula(apellido_aux) == mayuscula(prestatarios[i].apellido))
        {   //Se recorre el arreglo para comprobar si el prestatario existe
            cout << "El prestatario a modificar es correcto!" << endl; //Si existe se pasa a pedir al usuario el nuevo nombre y apellido para el prestatario
            cout << "Ingrese el nuevo nombre del prestatario: ";
            cin >> nombre_modif;
            cout << "Ingrese el nuevo apellido del prestatario: ";
            cin >> apellido_modif;
            prestatarios[i].nombre = nombre_modif; //Se cambian los dos parametros, por los nuevos
            prestatarios[i].apellido = apellido_modif;
            return ("Prestatario modificado satisfactoriamente!"); //Se retorna para informar al usuario el exito de la operacion
        }
    }
    for (int i = 0; i < cantidad_prestatarios; i++) //Se recorre el arreglo
    {
        if (mayuscula(nombre_aux) != mayuscula(prestatarios[i].nombre) && mayuscula(apellido_aux) != mayuscula(prestatarios[i].apellido))
        {
            return ("El prestatario que desea modificar no existe!"); //Para poder avisar que el prestatario a modificar no existe, retornando el mensaje de error
        }
    }
    return ("default");
}

string eliminarPrestatario(string nombre, string apellido, nodoprestamo* inicio)
{
    // Funcion eliminarPrestatario
    // PROPOSITO: Eliminar un prestatario ya inscripto, como las anteriores que dependen de que este inscripto o no, notifica al usuario si el prestatario no se encuentra registrado
    // tambien checkea si el prestatario a eliminar no tiene un prestamo en activo, en caso de ser asi permite elminarlo, en caso de que tenga un prestamo no lo permite
    // PARAMETROS: Nombre y apellido del prestatario a modificar y el comienzo de la lista de prestamos.
    // RETORNO: Retorna un string que indica si se elimino o no al prestatario que se desea.

    string nombre_aux=nombre;
    string apellido_aux=apellido;
    int posicion = 0;
    int codigo_presta = 0;
    bool ocupado=false;
    bool existe=false;
    for(int i=0;i<cantidad_prestatarios;i++){ //Con el mismo funcionamiento que eliminarCategoria
        if(mayuscula(nombre_aux)==mayuscula(prestatarios[i].nombre)&&mayuscula(apellido_aux)==mayuscula(prestatarios[i].apellido)){
            codigo_presta=prestatarios[i].codigo_prestatario;
            posicion=i;
            existe=true;  //Se revisa el arreglo de prestatarios para ver si existe, en caso de que si se pone existe en true
            break;
        }

    }
    if(existe==true){      //En caso de que existe sea true, se pasa a ver si tiene un prestamo registrado el prestatario
        nodoprestamo* aux=new nodoprestamo;
        aux=inicio;
        if(aux!=NULL){
            while(aux!=NULL && ocupado==false){
                if(codigo_presta==aux->prestamo.prestatario){
                    ocupado=true;
                }
                aux=aux->siguiente;
            }
        }
        if(ocupado!=true){ //En caso de que ocupado sea false(no tiene prestamos registrados) se para a eliminar del arreglo el prestatario
            for(int i=posicion;i<cantidad_prestatarios;i++){
                prestatarios[i]=prestatarios[i+1];
                cantidad_prestatarios--;
                return("Prestatario eliminado satisfactoriamente!");  //Y se informa al usuario del exito de la operacion
            }
        }
        else if(ocupado==true){ //Si ocupado es true, se avisa al usuario del error
            return("El prestatario que desea eliminar esta registrado en un prestamo, no es posible eliminarlo!");
        }
    }
    else{ //Si existe no es true, el prestatario no existe, por lo tanto se avisa al usuario
        return("El prestatario que desea eliminar no existe!");
    }
    return("Default");
}



nodoprestamo* agregarPrestamo(string categoria, string nombre, string apellido, string descripcion,nodoprestamo* inicio1)
{
    // Funcion agregarPrestamo
    // PROPOSITO: Agregar un prestamo al struct de los mismos, generando un booleano que indica el estado del prestamo, TRUE=prestamo activo, FALSE=prestamo finalizado
    // PARAMETROS: Categoria del prestamo(aclaracion es un string ya que no se usara el codigo de la categoria, sino la descripcion del primer struct
    // llamado categorias para hacer mas facil al usuario el ingreso), aparte de este, se pide nombre y apellido del prestatario
    // se ingresa tambien la descripcion para el prestamo que va a ser la principal forma de detectar prestamos y para poder agregarlo
    // se pasa como parametro el puntero que va al comienzo de la lista
    // RETORNO: retorna el inicio de la lista

    int posicioncategoria=0;
    int posicionprestatario=0;
    bool existe1=false;
    bool existe2=false;
    if(cantidad_categorias==0 && cantidad_prestatarios==0){
        cout<<"No se encuentran categorias ni prestararios registrados"<<endl; //Se comprueba que haya por lo menos una categoria
        cout<<"Sera devuelto al menu"<<endl;                                  //y un prestatario antes de pasar a registrar el
        return(inicio1);                                                     //para evitar posibles errores
    }
    else if(cantidad_categorias==0 && cantidad_prestatarios!=0){
        cout<<"No se encuentran categorias registradas"<<endl;
        cout<<"Sera devuelto al menu"<<endl;
        return(inicio1);
    }
    else if(cantidad_categorias!=0 && cantidad_prestatarios==0){
        cout<<"No se encuentran prestatarios registrados"<<endl;
        cout<<"Sera devuelto al menu"<<endl;
        return(inicio1);
    }
    else{ //En caso que haya categorias y prestatarios disponibles se pasa a anidar dos for, para recorrer sus arreglos y tener los codigos de categoria y prestatario para el prestamo
        for(int i=0;i<cantidad_categorias;i++){
            if(mayuscula(categorias[i].descripcion)==mayuscula(categoria)){
                existe1=true;
                posicioncategoria=i;
                break;
            }
        }
        for(int j=0;j<cantidad_prestatarios;j++){
           if(mayuscula(prestatarios[j].nombre)==mayuscula(nombre) && mayuscula(prestatarios[j].apellido)==mayuscula(apellido)){
               existe2=true;
               posicionprestatario=j;
               break;
           }
        }
        if(existe1==true && existe2==true){
            limpiar();
            nodoprestamo* nuevo=new nodoprestamo(); //Se crea el nuevo nodo
            nuevo->prestamo.codigo_categoria=categorias[posicioncategoria].codigo_categoria; //Se le asignan los valores al struct dentro del nodo
            nuevo->prestamo.prestatario=prestatarios[posicionprestatario].codigo_prestatario;
            nuevo->prestamo.descripcion=descripcion;
            nuevo->prestamo.estado=true;
            nodoprestamo* aux1=inicio1; //nodos auxiliares
            nodoprestamo* aux2;
            while(aux1!=NULL){
                 aux2=aux1;
                 aux1=aux1->siguiente;
            }
            if(inicio1==aux1){
                inicio1=nuevo; //Se lo ubica donde tenga que ir, ya sea que es el primer nodo agregado, o el segundo, o otro
            }
            else{
                aux2->siguiente=nuevo;
            }
            nuevo->siguiente=aux1;
            cout<<"Prestamo agregado satisfactoriamente"<<endl; //Se avisa al usuario del exito
            cantidad_prestamos++; //Se aumenta la cantidad de prestamos
            return(inicio1); //Se retorna el inicio
        }
        else if(existe1==true && existe2==false){
            cout<<"El prestatario deseado no existe"<<endl;
            return(inicio1);
        }
        else if(existe1==false && existe2==true){
            cout<<"La categoria que desea no existe"<<endl;
        }
    }
    return(inicio1);
}
void modificarPrestamo(string descripcion,nodoprestamo* inicio)
{
    // Funcion modificar_prestamo
    // PROPOSITO: Modificar la descripcion de un prestamo que se encuentre en la base de datos, en caso de que no se encuentre se informa al usuario
    // PARAMETROS: Descripcion del prestamo a modificar y el inicio de la lista enlazada
    // RETORNO: void, no retorna nada

       string descripcion_aux=descripcion;
       string nueva_descripcion;          //Se crean variables, auxiliares, una variable para la nueva descripcion, un nodo para recorrer la lista
       nodoprestamo* aux=new nodoprestamo;//Y un bool para ver si el prestamo buscado existe en la lista
       bool existe=false;
       aux=inicio; //Se iguala el auxiliar al inicio de la lista
       if(inicio!=NULL){
           while(aux!=NULL && existe==false){
               if(aux->prestamo.descripcion==descripcion_aux && aux->prestamo.estado==true){
                   limpiar();
                   cout<<"El prestamo buscado existe"<<endl;
                   cout<<"Ingrese la nueva descripcion para el prestamo: "; //Se recorre y se marca existe como true para salir del while
                   cin>>nueva_descripcion; //Aparte de lo anterior se pide el ingreso de la nueva descripcion y se cambia, todo esto en caso que exista el prestamo
                   aux->prestamo.descripcion=nueva_descripcion;
                   existe=true;
                   cout<<"Prestamo modificado satisfactoriamente!"<<endl; //Y se avisa al usuario del exito de la operacion
               }
               aux=aux->siguiente;
           }
           if(existe==false){ //En caso que no exista un prestamo con la descripcion dada se avisa al usuario
               cout<<"El prestamo que desea modificar no existe"<<endl;
           }
       }
       else{ //Si inicio es igual a NULL, no existen prestamos registrados por lo que se pasa a avisar al usuario de esto
           cout<<"No existen prestamos registrados!"<<endl;
}
}
string eliminarPrestamo(string descripcion,nodoprestamo* inicio) //ERROR AL QUERER ELIMINAR CUANDO SE BORRO UN ELEMENTO DE LA LISTA PERO YA SE BORRO EL PRIMER ELEMENTO
{
    // Funcion eliminar_prestamo
    // PROPOSITO: Eliminar un prestamo de la base de datos
    // PARAMETROS: Se pide la descripcion del prestamo a eliminar para poder identificarlo y el inicio de la lista
    // RETORNO: Retorna un string que indica el estado de la operacion realizada

    string descripcion_aux=descripcion;
    if(cantidad_prestamos==0){ //Se revisa si existen prestamos registrados
        return("No se encuentran prestamos registrados");
    }
    if(inicio!=NULL){
        nodoprestamo* aux;
        nodoprestamo* anterior=NULL;
        aux=inicio;
        while(aux!=NULL && mayuscula(aux->prestamo.descripcion)!= mayuscula(descripcion_aux)){
            anterior=aux;
            aux=aux->siguiente;
        }
        if(aux==NULL){
            return("El prestamo que desea eliminar no existe"); //Si aux llego al final de la lista y no se cumplio la condicion, no existe el prestamo buscado y se avisa
            delete aux;
        }
        else if(anterior==NULL){ //Si el prestamo existe, se pasa a eliminarlo
            inicio=inicio->siguiente;
            delete aux;
            return("Prestamo eliminado satisfactoriamente");
        }
        else{
            anterior->siguiente=aux->siguiente; //Mismo caso que el anterior pero cuando se encuentra en diferente posicion
            delete aux;
            return("Prestamo eliminado satisfactoriamente");
        }
    }
    return("default");
}

void imprimirPrestatarioActivo(nodoprestamo* inicio)
{
    // Funcion imprimirPrestatarioActivo
    // PROPOSITO: Imprimir lista de prestatarios con prestamos activos
    // PARAMETROS: El inicio de la lista
    // RETORNO: Void, no retorna

    cout << "\nLista de prestatarios con prestamos activos: " << endl; //Se imprime
    cout << endl;
    nodoprestamo* aux=new nodoprestamo; //Se crea aux para reocrrer la lista
    aux=inicio;
    int cantidad=0;//cantidad para comprobaciones
    for(int i=0;i<cantidad_prestatarios;i++){//Se recorre el arreglo de prestatarios
        aux=inicio;
        cantidad=0;
        if(aux!=NULL){//Si aux!=NULL la lista de prestamos no esta vacia

            while(aux!=NULL){ //Se recorre la lista
                if(aux->prestamo.prestatario==prestatarios[i].codigo_prestatario && aux->prestamo.estado==true){
                    cantidad++; //Si el prestatario tien prestamos cantidad+1
                }
                aux=aux->siguiente;
            }
            if(cantidad!=0){ //Si cantidad no es 0 el prestatario tiene prestamos, por lo tanto se imprime su nombre y apellido y cuandos prestamos tiene
                cout<<"El prestatario "<<title(prestatarios[i].nombre)<<" "<<title(prestatarios[i].apellido)<<" con codigo "<<prestatarios[i].codigo_prestatario<<" tiene "<<cantidad<< " prestamos"<<endl;
            }
        }
        else{ //Si la lista esta vacia, aux==NULL se imprime
            cout<<"La lista de prestamos se encuentra vacia!"<<endl;
        }
    }

}

string terminar_prestamo(nodoprestamo* inicio)
{
    // Funcion terminar_prestamo
    // PROPOSITO: Terminar un prestamo en activo, cambiando su parte booleana de true a false
    // PARAMETROS: La descripcion del prestamo a terminar y el puntero al comienzo de la lista
    // RETORNO: Retorna un string y como todas las anteriores, este string indica si la operacion fue satisfatoria o no

    int codigoprestatario=0;
    string descripciones[dFisica]={"\0"};
    imprimirPrestatarioActivo(inicio);
    cout<<"Ingrese el codigo del prestatario del cual desea ver sus prestamos:"<<endl;
    cin>>codigoprestatario;
    nodoprestamo* aux=new nodoprestamo();
    aux=inicio;
    int cantidad=1;
    if(aux!=NULL){
        while(aux!=NULL){
            if(aux->prestamo.estado==true && aux->prestamo.prestatario==codigoprestatario){
                cout<<"Prestamo "<<cantidad<<" : "<<aux->prestamo.descripcion<<endl;
                descripciones[cantidad-1]=aux->prestamo.descripcion;
                cantidad++;
            }
            aux=aux->siguiente;
        }
    }
    else{
        return("La lista de prestamos se encuentra vacia");
    }
    aux=inicio;
    bool existe=false;
    cout<<"Ingrese el numero de prestamo a terminar"<<endl;
    cin>>codigoprestatario;
    if(aux!=NULL){
        while(aux!=NULL && existe==false){
            if(aux->prestamo.estado==true && descripciones[codigoprestatario-1]==aux->prestamo.descripcion){
                aux->prestamo.estado=false;
                existe=true;
            }
            aux=aux->siguiente;
        }
    }
    if(existe==true){
        return("Prestamo terminado satisfactoriamente");
    }
    else{
        return("Prestamo ingresado incorrectamente");
    }

}

void imprimirObjetos_Categoria(categoria categorias[], int cantidad_categorias)
{
    // Funcion imprimirObjetos_Categoria
    // PROPOSITO: Imprimir lista de objetos prestados
    // PARAMETROS: Struct de categorias
    // RETORNO: Void, no retorna

    for (int i = 0; i < cantidad_categorias; i++) //Se recorre el arreglo de categorias
        {
            cout<<"Objeto Prestado: "<<title(categorias[i].descripcion)<<endl; //Se imprimen las descripciones de cada una
        }

}

void imprimirPrestatarios(prestatario prestatarios[], int cantidad_prestatarios)
{
    // Funcion imprimirPrestatarios
    // PROPOSITO: Imprimir lista de prestatarios
    // PARAMETROS: Struct prestatarios
    // RETORNO: Void, no retorna

    for (int i = 0; i < cantidad_prestatarios; i++) //Se recorre el arreglo de prestatarios
    {
        cout << "Prestatario: " << title(prestatarios[i].nombre) << " " << title(prestatarios[i].apellido) <<endl; //Se imprimen nombre y apellido de cada prestatario
    }
}

void imprimirCategorias(categoria categorias[], int cantidad_categorias)
{
    // Funcion imprimirCategorias
    // PROPOSITO: Imprimir lista de categorias
    // PARAMETROS: Struct categorias, int cantegorias
    // RETORNO: Void, no retorna

    cout << "\nCategorias:" << endl;
    cout << endl;
    for (int i = 0; i < cantidad_categorias; i++) //Se recorre el arreglo categorias y se imprimen las categorias existentes
    {
        cout << i + 1 << ". " << categorias[i].descripcion <<endl;
    }
    cout << endl;
}

void imprimir_prestamos_por_categoria(string descripcion,nodoprestamo* inicio)
{
    // Funcion imprimir_prestamos_por_categoria
    // PROPOSITO: Imprimir los prestamos que presentan la categoria deseada
    // Parametro: La descripcion de la categoria y el inicio de la lista de prestamos
    // Retorno: Void, no retorna nada

    string descripcion_categoria=descripcion;
    int codigo_cat=0;
    bool existe=false; //Se crean variables para la descricion a buscar, un int que guarda el codigo de categorias
    int i=0;          // Un bool para guardar si existe o no la categoria, y un int i para iterar con el while
    while(existe==false && i<=cantidad_categorias){
        if(mayuscula(categorias[i].descripcion)==mayuscula(descripcion_categoria)){
            existe=true;
            codigo_cat=categorias[i].codigo_categoria;
        }
        i++;
    }
    if(existe==true){ //Si existe, se pasa a recorrer la lista de prestamos, y se crea un arreglo estatico para almacenar
                     //las descripciones de cada prestamo
        nodoprestamo* aux=new nodoprestamo;
        aux=inicio;
        string lista_p[dFisica]={"\0"};
        int cantidad=0;
        if(aux!=NULL){
            while(aux!=NULL){
                if(aux->prestamo.codigo_categoria==codigo_cat && aux->prestamo.estado==true){
                    lista_p[cantidad]=aux->prestamo.descripcion;
                    cantidad++;
                }
                aux=aux->siguiente;
            }
        }
        else{
            cout<<"No existen prestamos registrados"<<endl; //Si aux es igual a NULL significa que inicio es igual a NULL por lo tanto no hay prestamos registrados
        }
        if(lista_p[0]!="\0"){ //Si el arreglo no se encuentra lleno de "\0"(arreglo vacio para el algoritmo), se pasa a imprimir los miembros del arreglo
            cout<<"Los objetos en prestamo de la categoria ";
            cout<<title(descripcion_categoria);
            cout<<" son:"<<endl;
            for(int i=0;i<cantidad;i++){
                cout<< i+1;
                cout<<". ";
                cout<<lista_p[i]<<endl;
            }
        }
        else if(lista_p[0]=="\0"){ //Si el arreglo sigue con todos los "\0", nunca se cumplio la condicion del if dentro del while por lo tanto la categoria existe
                                  //Pero nunca se registraron prestamos con esa categoria
            limpiar();
            cout<<"La categoria no presenta prestamos registrados o activos"<<endl;
        }
    }
    else{
        cout<<"La categoria que desea buscar no existe!"<<endl;//En caso de existe==false, la categoria que se quiso buscar no existe
    }
}



void cantidad_objetos_categoria(string descripcion,nodoprestamo* inicio)
{
    // Funcion cantidad_objetos_categoria
    // Proposito:Imprimir la cantidad de objetos para una categoria dada
    // Parametros:Descripcion de la categoria a buscar y el puntero al inicio de la lista
    // Retorno:Void, no retorna nada

    string descripcion_categoria=descripcion;
    int codigo_cat=0; //Se crean variables locales para almacenar, la descripcion a buscar
    bool existe=false;//Un bool para ver si existe la categoria buscada
    int i=0;//Un i para iterar con el while
    while(existe==false && i<=cantidad_categorias){
        if(mayuscula(categorias[i].descripcion)==mayuscula(descripcion_categoria)){ //Se recorre el arreglo de categorias buscando la categoria ingresada
            existe=true;                                                            //Para obtener el codigo de categoria y saber si existe
            codigo_cat=categorias[i].codigo_categoria;
        }
        i++;
    }
    if(existe==true){ //Si existe se pasa a recorrer la lista de prestamos
        nodoprestamo* aux=new nodoprestamo;//Nodo auxiliar para recorrer
        aux=inicio; //Se iguala a inicio el nodo aux
        int cantidad=0; //Variable para contar cuantas veces se encuentra un prestamo con la categoria buscada
        if(aux!=NULL){
            while(aux!=NULL){
                if(aux->prestamo.codigo_categoria==codigo_cat && aux->prestamo.estado==true){
                    cantidad++;
                }
                aux=aux->siguiente;
            }
        }
        else{
            cout<<"No existen prestamos registrados"<<endl; //Si aux==NULL, no hay partes de la lista
        }
        delete aux; //Se borra aux tras recorrer la lista
        if(cantidad>0){ //Si cantidad es mayor a 0, hay prestamos registrados con esa categoria
            cout<<"La cantidad de prestamos activos de la categoria ";
            cout<<title(descripcion_categoria);
            cout<<" es: ";                 //Se imprime, la descripcion de la categoria y cuantos prestamos tiene adjudicados
            cout<<cantidad<<endl;
        }
        if(cantidad==0){ //Si cantidad es 0 no hay prestamos registrados con esa categoria
            limpiar(); //Se imprime el mensaje de error
            cout<<"La categoria de la cual desea saber la cantidad de prestamos activos no tiene ninguno"<<endl;
        }
    }
    else if(existe==false){ //Si existe sigue siendo false a este punto, no existe la categoria
        cout<<"La categoria que desea no existe"<<endl;
    }
}

void imprimirOrdenCategoria(nodoprestamo* inicio)
{
    // Funcion imprimirPorCategoria
    // PROPOSITO: Imprimir lista de prestamos por orden categoria
    // PARAMETROS: el inicio de la lista
    // RETORNO: Void, no retorna

    int cantidad=0; //Se crea un int para temas visuales
    nodoprestamo* aux=new nodoprestamo; //Se crea un nodo auxiliar para recorrer la lista de prestamos
    for (int i = 0; i < cantidad_categorias; i++)
    {
        aux=inicio;//Se iguala a inicio, para siempre recorrer la lista desde el principio en cada vuelta del for
        cantidad=1; //Cantidad=1 para grafico
        if(aux!=NULL){//Si la lista no esta vacia
            cout << "Los prestamos de " << categorias[i].descripcion << " son: " << endl;//Se imprime la descripcion de categoria
            while(aux!=NULL){ //Se recorre la lista
                if(aux->prestamo.codigo_categoria==categorias[i].codigo_categoria && aux->prestamo.estado==true){
                    cout<<cantidad; //Y si se cumple la condicion se imprime cantidad y la descripcion de cada prestamo con la categoria deseada
                    cout<<". ";
                    cout<<aux->prestamo.descripcion<<endl;
                    cantidad++;
                }
                aux=aux->siguiente;
            }
            delete aux; //Se borra aux
            if(cantidad==1){
                cout<<"La categoria no presenta ningun prestamo activo registrado!"<<endl;//Si cantidad sigue siendo 1 no hay prestamos de esa categoria
            }
        }
        else{//Si aux==NULL se para a avisar al usuario que no hay prestamos registrados
            cout<<"No se encuentra ningun prestamo registrado!"<<endl;
            delete aux;//Se borra aux
        }
    }
}

void imprimirOrdenPrestatario(nodoprestamo* inicio)
{
    // Funcion imprimirPorCategoria
    // PROPOSITO: Imprimir lista de prestamos por orden prestatario
    // PARAMETROS: El puntero al inicio de la lista de prestamos
    // RETORNO: Void, no retorna

    int cantidad = 1; //Cantidad con una funcion parecida a la funcion anterior
    nodoprestamo* aux=new nodoprestamo;//Se crea un nodo aux para recorrer
    for (int i = 0; i < cantidad_prestatarios; i++)
    {
        aux=inicio;//funcionalidad muy parecida a la anterior
        cantidad=1;
        if(aux!=NULL){
            cout << "Los prestamos de " << title(prestatarios[i].nombre) <<" "<< title(prestatarios[i].apellido) << " son: " << endl;
            while(aux!=NULL){ //Lo unico que cambiarira es como se imprimen y que condicion tiene el if
                if(aux->prestamo.prestatario==prestatarios[i].codigo_prestatario && aux->prestamo.estado==true){
                    cout<<cantidad;
                    cout<<". ";
                    cout<<aux->prestamo.descripcion<<endl;
                    cantidad++;
                }
                aux=aux->siguiente;
            }
            delete aux;
            if(cantidad==1){
                cout<<"El prestatario no presenta ningun prestamo activo registrado!"<<endl;
            }
        }
        else{
            cout<<"No se encuentra ningun prestamo registrado!"<<endl;
            delete aux;
        }
    } //La funcion tiene el mismo procedimiento que imprimirOrdenCategoria
}



/*
======================
     FUNCION MAIN
======================
*/

int main()
{
    nodoprestamo* inicio=new nodoprestamo; //Se crea el nodo para el inicio de la lista de prestamos
    inicio=NULL; //Se iguala a NULL para expresar que esta vacia
    char seleccion, seleccionA, seleccionB, seleccionC;                                                                  // variables donde se almacenara la opcion del usuario
    string categoriaAgregar, categoriaModificar, categoriaEliminar;                                                      // variables donde se almacenara los datos del usuario del inciso A
    string nombrePrestatario, apellidoPrestatario, nombreModificar, apellidoModificar, nombreEliminar, apellidoEliminar; // variables donde se almacenara los datos del usuario del inciso A
    string seleccionMenuB, ingresarCategoriaB, agregarNombreB, agregarApellidoB, descripcionPrestamoB;                   // Variables utilizadas en inciso B
    string seleccionMenuC, opcion_c;
    ; // Variables usadas en el inciso C

    // Menu principal, loopeado mediante un do/while

    do
    {                                            // Do del menu principal, para permitir volver al menu tras realizada cualquier opcion del menu
        cout << "\nBienvenido al menu!" << endl; // Se muestra el menu mediante un COUT
        cout << "\nA: Administrar y consultar Categorias y Prestatarios." << endl;
        cout << "B: Administrar Prestamos." << endl;
        cout << "C: Consultar Prestamos." << endl;
        cout << "D: Salir." << endl;
        cout << "\nElija la opcion a utilizar: ";
        cin >> seleccion; // CIN ingresa la opcion deseada

        seleccion = toupper(seleccion); // convertimos la letra en mayusculas para que sea indiferente el ingreso de mayuscula o minuscula

        switch (seleccion)
        {
        case 'A':      // PRIMER CASO DEL MENU PRINCIPAL
            limpiar(); // LIMPIA PANTALLA DEL MENU PRINCIPAL
            do
            { // Do del menu de la opcion A, para permitir volver al menu tras realizada cualquier seleccion
                cout << "\nOPCION A: Administracion y consulta de Categorias y Prestatarios!" << endl;
                cout << "\nA: Agregar categoria." << endl;
                cout << "B: Modificar categoria." << endl;   // Se pone en pantalla las opciones del apartado
                cout << "C: Eliminar categoria." << endl;    // Administracion y consultas de categorias
                cout << "\nD: Agregar prestatario." << endl; // Con un funcionamiento casi igual al principal
                cout << "E: Modificar prestatario." << endl; // Permite ingresar al usuario otra opcion del menu
                cout << "F: Eliminar prestatario." << endl;  // Y como en el principal, se comprueba si la opcion ingresada
                cout << "\nG: Volver al menu principal." << endl;
                cout << "\nElija la opcion a utilizar: "; // Es o no correcta.
                cin >> seleccionA;

                seleccionA = toupper(seleccionA);

                switch (seleccionA)
                {
                case 'A':
                    limpiar();
                    cout << "\nOPCION A: Ingrese la categoria a agregar: "; // Se pide la categoria a agregar
                    getline(cin >> ws, categoriaAgregar);                   // Se ingresa en la variable
                    limpiar();                                              // Limpia pantalla
                    cout << agregarCategoria(categoriaAgregar) << endl;     // Se ejecuta la funcion que la agrega en el struct
                    break;
                case 'B':
                    limpiar();
                    if(cantidad_categorias==0){
                        cout<<"No se encuentran categorias registradas"<<endl; //Se comprueba si hay categorias registradas para ahorrar errores
                        break;
                    }
                    else{
                        imprimirCategorias(categorias,cantidad_categorias);       //Se muestran las categorias existentes
                        cout << "\nOPCION B: Ingrese la descripcion de la categoria a modificar: "<<endl; // Se pide categoria a modificar
                        getline(cin >> ws, categoriaModificar);                   // Se ingresa en la variable para ser modificada                                                                   // Limpia pantalla
                        cout << modificarCategoria(categoriaModificar) << endl;   // Se ejecuta la funcion que modifica la categoria
                        break;
                    }
                case 'C':
                    limpiar();
                    if(cantidad_categorias==0){
                        cout<<"No se encuentran categorias registradas"<<endl; //Se comprueba si hay categorias registradas para no querer eliminar algo que no existe
                        break;
                    }
                    else{
                        imprimirCategorias(categorias,cantidad_categorias);         //Se muestran las categorias existentes
                        cout << "\nOPCION C: Ingrese la descripcion de la categoria a eliminar: "<<endl;; // Se pide categoria a eliminar
                        getline(cin >> ws, categoriaEliminar);                // Se ingresa la categoria
                        limpiar();                                            // Se limpia pantalla
                        cout << eliminarCategoria(categoriaEliminar,inicio) << endl; // Se elimina la categoria mediante la funcion
                        break;
                    }
                case 'D':
                    limpiar();
                    cout << "\nOPCION D: Ingrese nombre del prestatario: ";                     // Se pide el nombre del prestatario
                    getline(cin >> ws, nombrePrestatario);                                      // Se ingresa el nombre en la variable
                    cout << "\nIngrese appelido del prestatario: ";                             // Se pide el apellido del prestatario
                    getline(cin >> ws, apellidoPrestatario);                                    // Se ingresa el apellido en la variable
                    limpiar();                                                                  // Se limpia pantalla
                    cout << agregarPrestatario(nombrePrestatario, apellidoPrestatario) << endl; // Se procesan los datos en la funcion
                    break;
                case 'E':
                    limpiar();
                    if(cantidad_prestatarios==0){
                        cout<<"No se encuentran prestatarios registrados"<<endl;
                        break;
                    }
                    else{
                        cout << "\nOPCION E:"<<endl;
                        cout <<" Prestatarios registrados:"<<endl;
                        imprimirPrestatarios(prestatarios,cantidad_prestatarios);
                        cout << "Ingrese nombre a modificar: ";                       // Se pide el nombre del prestatario a modificar
                        getline(cin >> ws, nombreModificar);                                      // Se ingresa el nombre en la variable
                        cout << "\nIngrese apellido a modificar: ";                               // Se pide el apellido del prestatario a modificar
                        getline(cin >> ws, apellidoModificar);                                    // Se ingresa el apellido en la variable
                        limpiar();                                                                // Se limpia pantalla
                        cout << modificarPrestatario(nombreModificar, apellidoModificar) << endl; // Se modifica el nombre y apellido del prestatario mediante la funcion
                        break;
                    }
                case 'F':
                    limpiar();
                    if(cantidad_prestatarios==0){
                        cout<<"No se encuentran prestatarios registrados"<<endl;
                        break;
                    }
                    else{
                        cout<<"OPCION F: "<<endl;
                        cout<<"Prestatarios registrados"<<endl;
                        cout << "Ingrese nombre del prestatario a eliminar: ";       // Se pide el nombre del prestatario a modificar
                        getline(cin >> ws, nombreEliminar);                                    // Se ingresa el nombre en la variable
                        cout << "\nIngrese apellido del prestatario a eliminar: ";             // Se pide el apellido del prestatario a modificar
                        getline(cin >> ws, apellidoEliminar);                                  // Se ingresa el apellido en la variable
                        limpiar();                                                             // Se limpia pantalla
                        cout << eliminarPrestatario(nombreEliminar, apellidoEliminar,inicio) << endl; // Se elimina el prestatario mdeiante la funcion
                        break;
                    }

                case 'G':
                    limpiar();
                    cout << "'G': VOLVIENDO AL MENU PRINCIPAL" << endl; // MUESTRA EN PANTALLA LA OPCION SELECCIONADA Y REGRESA AL MENU PRINCIPAL
                    break;

                default:
                    // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
                    // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
                    limpiar(); // se limpia la pantalla
                    cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
                    break;
                }
            } while (seleccionA != 'G');
            break;

        case 'B':      // SEGUNDO CASO DEL MENU PRINCIPAL
            limpiar(); // LIMPIA PANTALLA DEL MENU PRINCIPAL
            do
            { // Do del menu B, para permitir volver al menu tras realizada cualquier seleccion
                cout << "\nOPCION B: Administracion de Prestamos!" << endl;
                cout << "\nA: Agregar prestamo." << endl;
                cout << "B: Modificar prestamo." << endl; // Se ponen en pantalla las opciones del la opcion B
                cout << "C: Eliminar prestamo." << endl;
                cout << "D: Devolver prestamo." << endl;
                cout << "\nE: Volver al menu principal." << endl;
                cout << "\nElija la opcion a utilizar: ";
                cin >> seleccionB; // Se ingresa la opcion seleccionada

                seleccionB = toupper(seleccionB);

                switch (seleccionB)
                {
                case 'A':
                    limpiar();
                    cout << "Desea ver las categorias actuales para su Prestamo?" << endl; // Se pregunta al usuario si desea ver las categorias existentes para su prestamo
                    cout << "S/N: ";
                    cin >> seleccionMenuB; // Se ingresa s o n para si o no respectivamente
                    if (mayuscula(seleccionMenuB) == "S")
                    { // Se comprueba que se elija si

                        imprimirObjetos_Categoria(categorias, cantidad_categorias); // Se realizaria la muestra de las categorias para los prestamos

                        cout << "Ingrese una categoria para el prestamo: ";
                        cin >> ingresarCategoriaB; // Y le permite ingresar la descripcion de la categoria
                    }
                    else if (mayuscula(seleccionMenuB) == "N")
                    {                                                       // Se comprueba si eligio no
                        cout << "Ingrese una categoria para el prestamo: "; // En caso de que no, se le da la opcion a ingresar una categoria sin ver todas
                        cin >> ingresarCategoriaB;                          // Se ingresa la eleccion
                    }
                    else{
                        cout<<"Ingreso una opcion incorrecta"<<endl;
                        cout<<"Sera devuelto al menu"<<endl;
                        break;
                    }

                    cout << "Desea ver los prestatarios ya inscriptos?" << endl; // Se realiza lo mismo que en la pregunta anterior pero con los prestatarios
                    cout << "S/N: ";
                    cin >> seleccionMenuB;
                    if (mayuscula(seleccionMenuB) == "S")
                    { // Caso Si

                        imprimirPrestatarios(prestatarios, cantidad_prestatarios); // Se realizaria la muestra de los prestatarios

                        cout << "Ingrese el nombre del prestatario para el prestamo: "; // Se pide el nombre del prestatario
                        cin >> agregarNombreB;                                          // Se ingresa el nombre
                        cout << "Ingrese el apellido para el prestamo: ";               // Se pide el apellido del prestatario
                        cin >> agregarApellidoB;                                        // Se ingresa
                    }

                    // ACLARACION, en la funcion se busca el codigo del prestatario y el codigo de la categoria, para poder almacenar en el struct prestamos

                    else if (mayuscula(seleccionMenuB) == "N")
                    {                                                                   // Caso No
                        cout << "Ingrese el nombre del prestatario para el prestamo: "; // Se piden e ingresan directamente nombre y
                        cin >> agregarNombreB;                                          // apellido del prestatario para el prestamo
                        cout << "Ingrese el apellido del prestatario para el prestamo: ";
                        cin >> agregarApellidoB;
                    }
                    else{
                        cout<<"Ingreso una opcion incorrecta"<<endl;
                        cout<<"Sera devuelto al menu"<<endl;
                        break;
                    }
                    cout << "Ingrese una descripcion para el prestamo: "; // Se pide ingresar una descripcion al prestamo
                    cin >> descripcionPrestamoB;                          // Se ingresa
                    limpiar();
                    inicio=agregarPrestamo(ingresarCategoriaB, agregarNombreB, agregarApellidoB, descripcionPrestamoB,inicio);
                    // Se llama a la funcion para agregar prestamo
                    break;

                case 'B':
                    limpiar();
                    if(cantidad_prestamos==0){
                        cout<<"No se encuentran prestamos registrados"<<endl;
                        break;
                    }
                    else{
                        cout << "\nOPCION B: Ingrese la descripcion del prestamo a modificar: "; // Se le pide al usuario ingresarla
                        cin >> descripcionPrestamoB;                                             // Se ingresa
                        limpiar();
                        modificarPrestamo(descripcionPrestamoB,inicio);
                        // Se llama a la funcion modificar_prestamo y con el cout se imprime el mensaje de error o no que devuelve la funcion
                        break;
                    }

                case 'C':
                    limpiar();
                    if(cantidad_prestamos==0){
                        cout<<"No se encuentran prestamos registrados"<<endl;
                        break;
                    }
                    else{
                        cout << "\nOPCION C: Ingrese la descripcion del prestamo a eliminar: "; // Se pide al usuario
                        cin >> descripcionPrestamoB;                                            // Se Ingresa
                        cout << eliminarPrestamo(descripcionPrestamoB,inicio) << endl;                 // Se llama a la funcion con un cout como en los anteriores casos para poder devolver el mensaje de error o lo contrario
                        break;
                    }

                case 'D':
                    limpiar();
                    if(cantidad_prestamos==0){
                        cout<<"No se encuentran prestamos registrados"<<endl;
                        break;
                    }
                    else{
                        cout << terminar_prestamo(inicio) << endl;                // Se llama a la funcion con el parametro de la descripcion ingresada y se devuelve el mensaje de correcto o error
                        break;
                    }

                case 'E':
                    limpiar();
                    cout << "'E': VOLVIENDO AL MENU PRINCIPAL" << endl; // MUESTRA EN PANTALLA LA OPCION SELECCIONADA
                    break;

                default:
                    // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
                    // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
                    limpiar(); // se limpia la pantalla
                    cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
                    break;
                }
            } while (seleccionB != 'E');
            break;

        case 'C':      // TERCER CASO DEL MENU PRINCIPAL
            limpiar(); // LIMPIA PANTALLA DEL MENU PRINCIPAL
            do
            { // Do del menu de la opcion C, para permitir volver al menu tras realizada cualquier seleccion
                cout << "\nOPCION C:Consultas de Prestamos!" << endl;
                cout << "\nA: Cantidad de objetos prestados por categoria." << endl;
                cout << "B: Listado de prestamos por categoria." << endl; // Se ponen en pantalla las opciones
                cout << "C: Listado de prestamos ordenados por prestatario o categoria." << endl;
                cout << "D: Prestatarios con objetos en prestamo." << endl;
                cout << "\nE: Volver al menu principal." << endl;
                cout << "\nElija la opcion a utilizar: ";
                cin >> seleccionC; // Se ingresa el numero de opcion

                seleccionC = toupper(seleccionC);

                switch (seleccionC)
                {
                case 'A':
                    limpiar(); // se limpia pantalla
                    if(cantidad_prestamos==0){
                        cout<<"No se encuentran prestamos registrados"<<endl;
                        break;
                    }
                    else{
                        cout << "OPCION A" << endl;
                        imprimirCategorias(categorias, cantidad_categorias);                                           // imprime las categorias para que los usuarios puedan seleccionar la que desean
                        cout << "\nIngrese la descripcion de la categoria de la que desea conocer la cantidad de objetos en prestamo: "; // se pide al usuario
                        getline(cin >> ws, categoriaAgregar);                                                          // se ingresa
                        cantidad_objetos_categoria(categoriaAgregar,inicio);                                                  // se imprime en pantalla
                        break;
                    }
                case 'B':
                    limpiar(); // se limpia pantalla
                    if(cantidad_prestamos==0){
                        cout<<"No se encuentran prestamos registrados"<<endl;
                        break;
                    }
                    else{
                        cout << "OPCION B" << endl;
                        imprimirCategorias(categorias, cantidad_categorias);                            // imprime las categorias para que los usuarios puedan seleccionar la que desean
                        cout << "Ingrese la descripcion de la categoria de la que desea conocer los prestamos activos: "; // se pide al usuario
                        cin >> categoriaAgregar;                                                        // se ingresa
                        imprimir_prestamos_por_categoria(categoriaAgregar,inicio);                             // se imprime en pantalla
                        break;
                    }
                case 'C':
                    limpiar(); // se limpia pantalla
                    if(cantidad_prestamos==0){
                        cout<<"No se encuentran prestamos registrados"<<endl;
                        break;
                    }
                    else{
                        cout << "OPCION C" << endl;
                        cout << "Desea ver los prestamos ordenados por categoria o por prestatario(C/P): " << endl; // se pregunta al usuario
                        cin >> opcion_c;                                                                            // se ingresa
                        if (mayuscula(opcion_c) == "C")                                                             // se verifica
                        {
                            imprimirOrdenCategoria(inicio); // se imprime
                            break;
                        }
                        else if (mayuscula(opcion_c) == "P")
                        {
                            imprimirOrdenPrestatario(inicio); // se imprime
                            break;
                        }
                        else{
                            cout<<"Ha ingresado una opcion incorrecta"<<endl;
                            cout<<"Sera devuelto al menu principal"<<endl;
                            break;
                        }
                    }
                case 'D':
                    limpiar();                    // LIMPIA LA PANTALLA
                    if(cantidad_prestamos==0){
                        cout<<"No se encuentran prestamos registrados"<<endl;
                        break;
                    }
                    else{
                        cout << "\nOPCION D" << endl; // MUESTRA EN PANTALLA
                        imprimirPrestatarioActivo(inicio);  // SE EJECUTA LA FUNCION QUE MUESTRA LOS PRESTATARIOS ACTIVOS
                        break;
                    }
                case 'E':
                    limpiar();
                    cout << "'E': VOLVIENDO AL MENU PRINCIPAL" << endl; // MUESTRA EN PANTALLA LA OPCION SELECCIONADA
                    break;

                default:
                    // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
                    // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
                    limpiar(); // se limpia la pantalla
                    cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
                    break;
                }
            } while (seleccionC != 'E');
            break;

        case 'D':
            cout << "\nSELECCIONO LA OPCION SALIR." << endl; // MUESTRA EN PANTALLA QUE OPCION SELECCIONO
            break;

        default:
            // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
            // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
            limpiar(); // se limpia la pantalla
            cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
            break;
        }
    } while (seleccion != 'D');

    cout << "\nFIN DEL PROGRAMA." << endl; // MUESTRA EN PANTALLA UN MENSAJE DE FIN

    getch();

    return 0;
}