Brunoroman

Untitled

Sep 27th, 2021
1,319
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <iostream> //LIBRERIA IOSTREAM permite ingresar y mostrar en pantalla texto
  2. #include <cstring> //LIBRERIA CSTRING facilita el uso de strings, con comandos como lenght
  3. #include <stdlib.h> //LIBRERIA STDLIB es una biblioteca estandar, se agrego para la funcion limpiar()
  4.  
  5. using namespace std;
  6.  
  7. //Funcion del programa
  8. //Sistema para registrar, administrar y consultar prestamos
  9.  
  10. //VARIABLES
  11. int cantidad_categorias=0;//Variable para saber la dimension logica de las categorias
  12. int cantidad_prestamos=0;//Lo mismo que la anterior para los prestamos
  13. int cantidad_prestatarios=0;//Lo mismo para los prestatarios
  14.  
  15.  
  16. struct c{                   //Plantilla del struct para las categorias
  17.      int codigo_categoria;
  18.      string descripcion;
  19. };
  20.  
  21. struct pr{                 //Plantilla del struct para los prestamos
  22.      int codigo_categoria;
  23.      int prestatario;
  24.      string descripcion;
  25.      bool estado;
  26. };
  27.  
  28. struct pres{                 //Plantilla del struct para prestatarios
  29.     int codigo_prestatario;
  30.     string apellido;
  31.     string nombre;
  32. };
  33.  
  34. c categorias[100];
  35. pr prestamos[100];             //Definicion de los 3 struct para almacenar categorias,prestamos y prestatarios respectivamente
  36. pres prestatarios[100];
  37.  
  38. //Funciones
  39.  
  40. string agregar_categoria(string descripcion);
  41. //Funcion agregar_categoria
  42. //PROPOSITO: Agregar una categoria al struct categorias, le asigna un codigo interno a la categoria y revisa que la categoria no este repetida
  43. //PARAMETROS: Descripcion de la categoria a agregar
  44. //RETORNO: Retorna un string que dice si se agrego o no la categoria
  45. string modificar_categoria(string descripcion);
  46. //Funcion modificar_categoria
  47. //PROPOSITO: Modificar una categoria existente en el struct categorias
  48. //PARAMETROS: Descripcion de la categoria a modificar
  49. //RETORNO: Retorna un string que dice si la modificacion fue satisfatoria o no
  50. string eliminar_categoria(string descripcion);
  51. //Funcion eliminar_categoria
  52. //PROPOSITO: Eliminar una categoria del struct antes nombrado, si y solo si la categoria no tiene un prestamo en activo
  53. //PARAMETROS: Descripcion de la categoria a eliminar
  54. //RETORNO: Retorna un string que dice si se pudo eliminar o no la categoria
  55. string agregar_prestatario(string nombre,string apellido);
  56. //Funcion agregar_prestatario
  57. //PROPOSITO: Agregar un prestatario al struct prestatarios, le asigna un codigo y revisa que el prestatario no este ya registrado
  58. //PARAMETROS: Nombre y Apellido del prestatario a agregar
  59. //RETORNO: Retorna un string que dice si se registro satisfactoriamente el nuevo prestatario o no
  60. string modificar_prestatario(string nombre,string apellido);
  61. //Funcion modificar_prestatario
  62. //PROPOSITO: Modificar el nombre o apellido de un prestatario ya registrado, en caso de que no retorna el error
  63. //PARAMETROS: Nombre y apellido del prestatario a modificar
  64. //RETORNO: Retorna un string que indica si la modificacion fue satisfactoria o no
  65. string eliminar_prestatario(string nombre,string apellido);
  66. //Funcion eliminar_prestatario
  67. //PROPOSITO: Eliminar un prestatario ya inscripto, como las anteriores que dependen de que este inscripto o no, notifica al usuario si el prestatario ya se encuentra registrado
  68. //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
  69. //PARAMETROS: Nombre y apellido del prestatario a modificar
  70. //RETORNO: Retorna un string que indica si se elimino o no al prestatario que se desea
  71. string agregar_prestamo(string categoria,string nombre,string apellido,string descripcion);
  72. //Funcion agregar_prestamo
  73. //PROPOSITO: Agregar un prestamo al struct de los mismos, generando un booleano que indica el estado del prestamo, TRUE=prestamo activo, FALSE=prestamo finalizado
  74. //PARAMETROS: Categoria del prestamo(aclaracion es un string ya que no se usara el codigo de la categoria, sino la descripcion del primer struct
  75. //llamado categorias para hacer mas facil al usuario el ingreso), aparte de este, se pide nombre y apellido del prestatario
  76. //y por ultimo una descripcion del prestamo
  77. //RETORNO: Retorna un string que indica si se agrego o no satisfatoriamente el prestamo a la base de datos
  78. string modificar_prestamo(string descripcion);
  79. //Funcion modificar_prestamo
  80. //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
  81. //PARAMETROS: Descripcion del prestamo a modificar
  82. //RETORNO: Retorna un string informando al usuario sobre el estado de la operacion realizada, en otras palabras si la modificacion salio bien o no
  83. string eliminar_prestamo(string descripcion);
  84. //Funcion eliminar_prestamo
  85. //PROPOSITO: Eliminar un prestamo de la base de datos
  86. //PARAMETROS: Se pide la descripcion del prestamo a eliminar
  87. //RETORNO: Retorna un string que indica el estado de la operacion realizada
  88. string terminar_prestamo(string descripcion);
  89. //Funcion terminar_prestamo
  90. //PROPOSITO: Terminar un prestamo en activo, cambiando su parte booleana de true a false
  91. //PARAMETROS: La descripcion del prestamo a terminar
  92. //RETORNO: Retorna un string y como todas las anteriores, este string indica si la operacion fue satisfatoria o no
  93. string mayuscula(string cadena);
  94. //Funcion mayuscula
  95. //PROPOSITO: Hacer que el string ingresado, retorne en mayusculas, sirve para normalizar los string que se utilicen y evitar errores al compararlos
  96. //PARAMETROS: Un string deseado para convertirlo en mayusculas
  97. //RETORNO: Retorna un string que es el mismo que el ingresado, pero con todas sus letras en mayusculas
  98. void limpiar();
  99. //Funcion limpiar
  100. //PROPOSITO: Limpiar la pantalla mediante system("cls")
  101. //PARAMETROS: No pide ningun parametro
  102. //RETORNO:No retorna nada ya que es del tipo void
  103.  
  104. //Codigo principal
  105. int main(){
  106.     int opcion; //Variable local al main para comprobar si se elije bien la opcion deseada en los menus
  107.     int fin; //Variable local al main para controlar los while
  108.     string eleccion;//Variable local al main para S/N en administracion de prestamos
  109.     //Menu principal, loopeado mediante un do/while
  110.     do{ //Do del menu principal, para permitir volver al menu tras realizada cualquier opcion del menu
  111.     cout << "Bienvenido"<< endl;
  112.     cout << "Elija el numero correspondiente a la opcion que desea"<< endl;
  113.     cout << "1: Administrar y consultar Categorias y Prestatarios"<< endl; //Hace aparecer en pantalla el menu
  114.     cout << "2: Administrar Prestamos"<< endl;
  115.     cout << "3: Consultar Prestamos"<< endl;
  116.     cin>> opcion; //Se ingresa la opcion
  117.     while(opcion!=1 && opcion!=2 && opcion!=3){ //Bucle while, que solo funciona siempre y cuando se ingrese una opcion que no este en el menu
  118.         cout << "La opcion ingresada es incorrecta"<< endl; //Al detectar que la opcion ingresada no existe en el menu
  119.         cout << "Vuelva a ingresar un numero correspondiente a las siguientes opciones"<< endl;  //Se le muestran al usuario los siguientes mensajes
  120.         cout << "1: Administrar y consultar Categorias y Prestatarios"<< endl;                 //Mostrando devuelta una parte del menu
  121.         cout << "2: Administrar Prestamos"<< endl;                                            //Y permitiendole ingresar devuelta una opcion valida
  122.         cout << "3: Consultar Prestamos"<< endl;                                             //En caso de que la opcion sea otra vez incorrecta
  123.         cin>> opcion;                                                                      //El loop sigue en activo
  124.         limpiar(); //Limpia la pantalla tras pedir que se ingrese la opcion
  125.     }
  126.     do{
  127.     switch (opcion) { //Switch como principal forma de que funcione el menu
  128.     case 1:{ // Case para la opcion 1 del menu principal
  129.         cout << "Administracion y consulta de Categorías y Prestatarios"<< endl;
  130.         cout << "Elija el numero correspondiente a la opcion que desea"<< endl;
  131.         cout << "1: Agregar categoria"<< endl;
  132.         cout << "2: Modificar categoria"<< endl;                             //Se pone en pantalla las opciones del apartado
  133.         cout << "3: Eliminar categoria"<< endl;                             //Administracion y consultas de categorias
  134.         cout << "4: Agregar prestatario"<< endl;                           //Con un funcionamiento casi igual al principal
  135.         cout << "5: Modificar prestatario"<< endl;                        //Permite ingresar al usuario otra opcion del menu
  136.         cout << "6: Eliminar prestatario"<< endl;                        //Y como en el principal se comprueba si la opcion ingresada
  137.         cin>> opcion;                                                   //Es o no correcta
  138.         while(opcion!=1 && opcion!=2 && opcion!=3 && opcion!=4 && opcion!=5 && opcion!=6){ //Este while solo se activa en caso de que sea incorrecta
  139.             limpiar(); //Se limpia la pantalla                                            //la opcion ingresada
  140.             cout << "La opcion ingresada es incorrecta"<< endl;
  141.             cout << "Vuelva a ingresar un numero correspondiente a las siguientes opciones"<< endl;
  142.             cout << "1: Agregar categoria"<< endl;
  143.             cout << "2: Modificar categoria"<< endl;    //Se procede a mostrar el submenu devuelta
  144.             cout << "3: Eliminar categoria"<< endl;    //Para que el usuario pueda ver devuelta las opciones
  145.             cout << "4: Agregar prestatario"<< endl;  //Y como en el caso del menu principal se le permite ingresar una opcion que sea correcta
  146.             cout << "5: Modificar prestatario"<< endl;//De igual manera como en el menu principal el loop no termina hasta que el usuario
  147.             cout << "6: Eliminar prestatario"<< endl; //Ingrese una opcion que sea correcta
  148.             cin>> opcion;  //Ingreso de la opcion por parte del usuario
  149.         }
  150.         switch(opcion){ //Switch que controla el menu interno de la opcion 1 del menu principal
  151.         case 1:{//CASO AGREGAR CATEGORIA
  152.             cout << "Ingrese la categoria a agregar"<< endl; //Se le pregunta al usuario la descripcion de la categoria a agregar
  153.             string categoria_agregar_modificar_eliminar; //Variable local de la opcion 1-1, que guarda el dato de la descripcion de la categoria
  154.             cin>>categoria_agregar_modificar_eliminar; //Se ingresa la descripcion
  155.             cout<<agregar_categoria(categoria_agregar_modificar_eliminar)<<endl; //Se llama a la funcion agregar_categoria
  156.             cout << "------------------------------------------------------------------"<< endl;
  157.             cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl; //Se le pregunta al usuario si desea volver al menu principal
  158.             cout << "S/N"<<endl;                                                                 //Para seguir operando con el programa
  159.             cin>> eleccion; //EL usuario ingresa la opcion
  160.             if(mayuscula(eleccion)=="S"){ //Se llama a la funcion mayuscula para no tener errores como en caso de que el usuario ingrese s y no S
  161.                 limpiar(); //Llama a la funcion limpiar para limpiar la pantalla
  162.                 fin=1; //Hace que fin sea 1 para cortar do/while
  163.                 continue; //Y continua la ejecucion del anterior do while
  164.             }
  165.             else{
  166.                 if (mayuscula(eleccion)=="N"){ //Caso no, se hace lo mismo que en el if del caso si
  167.                     return 0; // Pero en vez de continue y demas, realiza un return 0 finalizando la ejecucion del main
  168.                 }
  169.  
  170.             }
  171.         }
  172.         case 2:{ //CASO MODIFICAR CATEGORIA
  173.             cout << "Ingrese la categoria a modificar"<< endl; //Se pide al usuario la descripcion categoria a modificar
  174.             string categoria_agregar_modificar_eliminar; //Se define la variable local que permite almacenar la descripcion
  175.             cin>>categoria_agregar_modificar_eliminar; //Se ingresa la descripcion guardandola en la variable anterior
  176.             cout<<modificar_categoria(categoria_agregar_modificar_eliminar)<<endl; //Se llama la funcion que modifica categoria, y esta devuelve si se pudo o no realizar la operacion
  177.             cout << "------------------------------------------------------------------"<< endl;
  178.             cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl; //Se realiza lo mismo que en el anterior caso
  179.             cout << "S/N"<<endl;                                                                //Para en caso de que el usuario quiera seguir operando, pueda volver al menu principal
  180.             cin>> eleccion;
  181.             if(eleccion=="S" || eleccion=="s"){
  182.                 limpiar();
  183.                 fin=1;
  184.                 continue;
  185.             }
  186.             else{
  187.                 if (eleccion=="N" || eleccion=="n"){
  188.                     return 0;
  189.                 }
  190.             }
  191.         }
  192.         case 3:{ //CASO ELIMINAR CATEGORIA
  193.             cout << "Ingrese la categoria a eliminar"<< endl; //Se pide al usuario la descripcion de la categoria a eliminar
  194.             string categoria_agregar_modificar_eliminar; //Se define una variable local para almacenar el dato pedido
  195.             cin>>categoria_agregar_modificar_eliminar; //Se pide el dato al usuario
  196.             cout <<eliminar_categoria(categoria_agregar_modificar_eliminar)<<endl; //Se llama a la funcion y con el cout se muestra si se realizo satisfactoriamente o no
  197.             cout << "------------------------------------------------------------------"<< endl; //Separador
  198.             cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl; //Como en los anteriores casos
  199.             cout << "S/N"<<endl;                                              //Permite volver al menu principal
  200.             cin>> eleccion;                                                  //Para que el usuario siga operando
  201.             if(mayuscula(eleccion)=="S"){
  202.                 limpiar();
  203.                 fin=1;
  204.                 continue;
  205.             }
  206.             else{
  207.                 if (mayuscula(eleccion)=="N"){
  208.                     return 0;
  209.                 }
  210.             }
  211.         }
  212.         case 4:{ //CASO AGREGAR PRESTATARIO
  213.             string nombre_agg_modif_delete; //Variable local para el nombre del prestatario a agregar
  214.             string apellido_agg_modif_delete; //Variable local para el apellido del prestatario a agregar
  215.             cout << "Ingrese el nombre del prestatario a agregar"<< endl; //Se pide al usuario que ingrese el nombre a agregar
  216.             cin>>nombre_agg_modif_delete; //Se ingresa el nombre a agregar
  217.             cout << "Ingrese el apellido del prestatario a agregar"<< endl;//Se pide al usuario que ingrese el apellido a agregar
  218.             cin>>apellido_agg_modif_delete; //Se ingresa el apellido
  219.             cout<<agregar_prestatario(nombre_agg_modif_delete,apellido_agg_modif_delete)<<endl; //Se llama a la funcion para agregar prestatarios
  220.             cout << "------------------------------------------------------------------"<< endl; //Separador
  221.             cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl; //Mismo procedimiento que las anteriores
  222.             cout << "S/N"<<endl;                                                          //Permite volver a el menu principal
  223.             cin>> eleccion;
  224.             if(mayuscula(eleccion)=="S"){
  225.                 limpiar();
  226.                 fin=1;
  227.                 continue;
  228.             }
  229.             else{
  230.                 if (mayuscula(eleccion)=="N"){
  231.                     return 0;
  232.                 }
  233.             }
  234.         }
  235.         case 5:{ //CASO MODIFICACION DE PRESTATARIO
  236.             string nombre_agg_modif_delete; //Variable local para guardar el nombre del prestatario a modificar
  237.             string apellido_agg_modif_delete;//Variable local parecida a la anterior pero con el apellido
  238.             cout << "Ingrese el nombre del prestatario a modificar"<< endl; //Se pide el nombre
  239.             cin>>nombre_agg_modif_delete;//Se ingresa el nombre
  240.             cout << "Ingrese el apellido del prestatario a modificar"<< endl;//Se pide el apellido
  241.             cin>>apellido_agg_modif_delete;//Se ingresa el apellido
  242.             cout <<modificar_prestatario(nombre_agg_modif_delete,apellido_agg_modif_delete)<<endl;//Se llama a la funcion que modifica prestatarios y devuelve si se modifico bien o no
  243.             cout << "------------------------------------------------------------------"<< endl; //Separador
  244.             cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl;
  245.             cout << "S/N"<<endl;                                   //Se realiza lo mismo que el codigo anterior, permite volver al menu principal
  246.             cin>> eleccion;                                       //Mediante una estructura if
  247.             if(mayuscula(eleccion)=="S"){
  248.                 limpiar();
  249.                 fin=1;
  250.                 continue;
  251.             }
  252.             else{
  253.                 if (mayuscula(eleccion)=="N"){
  254.                     return 0;
  255.                 }
  256.             }
  257.         }
  258.         case 6:{ //CASO ELIMINACION DE PRESTATARIO
  259.             string nombre_agg_modif_delete; //Variable local,almacenara el nombre del prestatario a eliminar
  260.             string apellido_agg_modif_delete;//Variable local,almacenara el apellido del prestatario a eliminar
  261.             cout << "Ingrese el nombre del prestatario a eliminar"<< endl; //Se pide el nombre
  262.             cin>>nombre_agg_modif_delete;//Se ingresa el nombre
  263.             cout << "Ingrese el apellido del prestatario a eliminar"<< endl;//Se pide el apellido
  264.             cin>>apellido_agg_modif_delete; //Se ingresa el nombre
  265.             cout <<eliminar_prestatario(nombre_agg_modif_delete,apellido_agg_modif_delete)<<endl; //Se llama a la funcion eliminar prestatario, con un cout para que retorne el mensaje de error o no
  266.             cout << "------------------------------------------------------------------"<< endl; //Separador
  267.             //Se repite la misma parte de codigo anterior para volver(no se agrego como funcion por que una funcion no permite el continue)
  268.             cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl;
  269.             cout << "S/N"<<endl;
  270.             cin>> eleccion;
  271.             if(mayuscula(eleccion)=="S"){
  272.                 limpiar();
  273.                 fin=1;
  274.                 continue;
  275.             }
  276.             else{
  277.                 if (mayuscula(eleccion)=="N"){
  278.                     return 0;
  279.                 }
  280.             }
  281.         }
  282.         }
  283.     }
  284.     case 2:{ //SUBMENU 2 Administracion de prestamos
  285.         cout << "Administracion de Préstamos"<< endl;
  286.         cout << "Elija el numero correspondiente a la opcion que desea"<< endl;
  287.         cout << "1: Agregar préstamo"<< endl;
  288.         cout << "2: Modificar préstamo"<< endl;                                   //Se ponen en pantalla las opciones del submenu 2
  289.         cout << "3: Eliminar préstamo"<< endl;
  290.         cout << "4: Devolver préstamo"<< endl;
  291.         cin>> opcion; //Se ingresa la opcion
  292.         while (opcion!=1 && opcion!=2 && opcion!=3 && opcion!=4){ //Se crea un bucle en caso de que la opcion ingresada sea incorrecta
  293.             limpiar();
  294.             cout << "La opcion ingresada es incorrecta"<< endl;  //Siempre y cuando se ingresen opciones incorrectas el bucle estara activo
  295.             cout << "Vuelva a ingresar un numero correspondiente a las siguientes opciones"<< endl;
  296.             cout << "1: Agregar préstamo"<< endl;
  297.             cout << "2: Modificar préstamo"<< endl;                         //Se muestra el menu otra vez
  298.             cout << "3: Eliminar préstamo"<< endl;                         //Para que el usuario pueda ver devuelta las opciones
  299.             cout << "4: Devolver préstamo"<< endl;
  300.             cin>> opcion;
  301.         }
  302.             switch (opcion) { //SWITCH PARA EL SUBMENU 2
  303.             case 1:{ //CASO AGREGAR PRESTAMO
  304.                 string categoria_agg_modif_delete;
  305.                 string nombre_agg_modif_delete;     //Variables locales para almacenar categoria, nombre, apellido
  306.                 string apellido_agg_modif_delete;   //y descripcion del prestamo a agregar
  307.                 string descripcion_prestamo_agg_modif_delete;
  308.                 cout << "Desea ver las categorias actuales para su Prestamo?"<<endl; //Se pregunta al usuario si desea ver las categorias existentes para su prestamo
  309.                 cout << "S/N"<<endl;
  310.                 cin>> eleccion; // Se ingresa s o n para si o no respectivamente
  311.                 if (mayuscula(eleccion)=="S"){ //Se comprueba que se elija si
  312.                     //Se realizaria la muestra de las categorias para los prestamos
  313.                     cout << "Ingrese una categoria para el prestamo"<<endl;
  314.                     cin>> categoria_agg_modif_delete;//Y le permite ingresar la descripcion de la categoria
  315.                 }
  316.                 else if(mayuscula(eleccion)=="N"){ //Se comprueba si eligio no
  317.                     cout << "Ingrese una categoria para el prestamo"<<endl; //En caso de que no se le da la opcion a ingresar
  318.                     cin>> categoria_agg_modif_delete;                       //una categoria sin ver todas
  319.                 }
  320.                 cout << "Desea ver los prestatarios ya inscriptos?"<<endl; //Se realiza lo mismo que en la pregunta anterior pero con los prestatarios
  321.                 cout << "S/N"<<endl;
  322.                 cin>> eleccion;
  323.                 if (mayuscula(eleccion)=="S"){//Caso Si
  324.                     //Se realizaria la muestra de los prestatarios
  325.                     cout << "Ingrese el nombre del prestatario para el prestamo"<<endl; //Se pide el nombre del prestatario
  326.                     cin>> nombre_agg_modif_delete; //Se ingresa
  327.                     cout << "Ingrese el apellido para el prestamo"<<endl; //Se pide el apellido del prestatario
  328.                     cin>> apellido_agg_modif_delete;//Se ingresa
  329.                 }                                                 //ACLARACION, en la funcion se busca el codigo del prestatario y el codigo de la categoria, para poder almacenar en el struct prestamos
  330.                 else if(mayuscula(eleccion)=="N"){//Caso No
  331.                     cout << "Ingrese el nombre del prestatario para el prestamo"<<endl; //Se piden e ingresan directamente nombre y apellido del prestatario para el prestamo
  332.                     cin>> nombre_agg_modif_delete;
  333.                     cout << "Ingrese el apellido del prestatario para el prestamo"<<endl;
  334.                     cin>> apellido_agg_modif_delete;
  335.                 }
  336.                 cout << "Ingrese una descripcion para el prestamo"<<endl; // Se pide ingresar una descripcion al prestamo
  337.                 cin>> descripcion_prestamo_agg_modif_delete; //Se ingresa
  338.                 cout <<agregar_prestamo(categoria_agg_modif_delete,nombre_agg_modif_delete,apellido_agg_modif_delete,descripcion_prestamo_agg_modif_delete)<<endl;//Se llama a la funcion para agregar prestamo y con el cout se impreme el retorno de la funcion que es un mensaje de error o no error
  339.                 cout << "------------------------------------------------------------------"<< endl; //Separador
  340.                 limpiar();
  341.                 cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl; //Se realiza lo mismo que en los otros casos para volve
  342.                 cout << "S/N"<<endl;                                                                //Al menu principal, como aclare antes no se pudo modularizar por el continue
  343.                 cin>> eleccion;
  344.                 if(mayuscula(eleccion)=="S"){
  345.                     limpiar();
  346.                     fin=1;
  347.                     continue;
  348.                 }
  349.                 else{
  350.                     if (mayuscula(eleccion)=="N"){
  351.                         return 0;
  352.                     }
  353.                 }
  354.  
  355.             }
  356.             case 2:{ // CASO MODIFICAR PRESTAMO
  357.                 string descripcion_prestamo_agg_modif_delete;//Variable local para almacenar la descripcion del prestamo a modificar
  358.                 cout << "Ingrese la descripcion del prestamo a modificar"<<endl;//Se le pide al usuario ingresarla
  359.                 cin>> descripcion_prestamo_agg_modif_delete;//Se ingresa
  360.                 cout<<modificar_prestamo(descripcion_prestamo_agg_modif_delete)<<endl;//Se llama a la funcion modificar_prestamo y con el cout se imprime el mensaje de error o no que devuelve la funcion
  361.                 limpiar();
  362.                 cout << "------------------------------------------------------------------"<< endl; //Separador
  363.                 cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl;
  364.                 cout << "S/N"<<endl;
  365.                 cin>> eleccion;
  366.                 if(mayuscula(eleccion)=="S"){ //Realiza lo mismo que antes para volver al menu principal en caso de que se desee hacerlo
  367.                     limpiar();
  368.                     fin=1;
  369.                     continue;
  370.                 }
  371.                 else{
  372.                     if (mayuscula(eleccion)=="N"){
  373.                         return 0;
  374.                     }
  375.                 }
  376.             }
  377.             case 3:{//CASO ELIMINAR PRESTAMO
  378.                 string descripcion_prestamo_agg_modif_delete; //Variable local para almancenar la descripcion del prestamo a eliminar
  379.                 cout << "Ingrese la descripcion del prestamo a eliminar"<<endl; //Se pide al usuario
  380.                 cin>>descripcion_prestamo_agg_modif_delete;//Se elimina
  381.                 cout<< eliminar_prestamo(descripcion_prestamo_agg_modif_delete)<<endl; //Se llama a la funcion con un cout como en los anteriores casos para poder devolver el mensaje de error o lo contrario
  382.                 limpiar();
  383.                 cout << "------------------------------------------------------------------"<< endl; //Separador
  384.                 cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl;
  385.                 cout << "S/N"<<endl;
  386.                 cin>> eleccion;
  387.                 if(mayuscula(eleccion)=="S"){ //Eealiza lo mismo que antes para volver al menu principal en caso de que se desee hacerlo
  388.                     limpiar();
  389.                     fin=1;
  390.                     continue;
  391.                 }
  392.                 else{
  393.                     if (mayuscula(eleccion)=="N"){
  394.                         return 0;
  395.                     }
  396.                 }
  397.             }
  398.             case 4:{//CASO DEVOLUCION DE PRESTAMO
  399.                 string descripcion_prestamo_agg_modif_delete;//Variable local para almacenar la descripcion
  400.                 cout << "Ingrese la descripcion del prestamo a devolver"<<endl; //Se pide al usuario
  401.                 cin>>descripcion_prestamo_agg_modif_delete; //Se ingresa
  402.                 cout <<terminar_prestamo(descripcion_prestamo_agg_modif_delete)<<endl;//Se llama a la funcion con el parametro de la descripcion ingresada y se devuelve el mensaje de correcto o error
  403.                 limpiar();
  404.                 cout << "------------------------------------------------------------------"<< endl; //Separador
  405.                 cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl;
  406.                 cout << "S/N"<<endl;
  407.                 cin>> eleccion;
  408.                 if(mayuscula(eleccion)=="S"){ //Realiza lo mismo que antes para volver al menu principal en caso de que se desee hacerlo
  409.                     limpiar();
  410.                     fin=1;
  411.                     continue;
  412.                 }
  413.                 else{
  414.                     if (mayuscula(eleccion)=="N"){
  415.                         return 0;
  416.                     }
  417.                 }
  418.             }
  419.             }
  420.         }
  421.     case 3:{ //Switch 3er SUBMENU Consultas
  422.             cout << "Consultas de Prestamos"<< endl;
  423.             cout << "Elija el numero correspondiente a la opcion que desea"<< endl;
  424.             cout << "1: Cantidad de objetos prestados por categoría"<< endl;
  425.             cout << "2: Listado de prestamos por categoría"<< endl;                     //Se ponen en pantalla las opciones
  426.             cout << "3: Listado de préstamos ordenados por categoría o prestatario"<< endl;
  427.             cout << "4: Prestatarios con objetos en prestamo"<< endl;
  428.             cin>> opcion; //Se ingresa el numero de opcion
  429.             while(opcion!=1 && opcion!=2 && opcion!=3 && opcion!=4){ //While para el caso de que el usuario ingrese una opcion incorrecta
  430.                 cout << "La opcion ingresada es incorrecta"<< endl;//Hace un bucle hasta que el usuario ingrese un opcion correcta
  431.                 cout << "Vuelva a ingresar un numero correspondiente a las siguientes opciones"<< endl;
  432.                 cout << "1: Cantidad de objetos prestados por categoría"<< endl;
  433.                 cout << "2: Listado de prestamos por categoría"<< endl;                            //Se realiza un proceso parecido al de los case 1 y 2
  434.                 cout << "3: Listado de préstamos ordenados por categoría o prestatario"<< endl;
  435.                 cout << "4: Prestatarios con objetos en prestamo"<< endl;
  436.                 cin>> opcion;//Se ingresa nuevamente la opcion
  437.             }
  438.                 switch(opcion){//Switch del submenu 3
  439.                 case 1:{//CASO CANTIDAD DE OBJETOS POR CATEGORIA
  440.                     cout << "------------------------------------------------------------------"<< endl; //Separador
  441.                     cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl;
  442.                     cout << "S/N"<<endl;
  443.                     cin>> eleccion;
  444.                     if(mayuscula(eleccion)=="S"){ //realiza lo mismo que antes para volver al menu principal en caso de que se desee hacerlo
  445.                         fin=1;
  446.                         continue;
  447.                     }
  448.                     else{
  449.                         if (mayuscula(eleccion)=="N"){
  450.                             return 0;
  451.                         }
  452.                     }
  453.                 }
  454.                 case 2:{//CASO LISTA DE PRESTAMOS POR CATGORIA
  455.                     cout << "Los prestamos por categoria son"<<endl;
  456.                     //Se realizaria la actividad deseada
  457.                     cout << "------------------------------------------------------------------"<< endl; //Separador
  458.                     cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl;
  459.                     cout << "S/N"<<endl;
  460.                     cin>> eleccion;
  461.                     if(mayuscula(eleccion)=="S"){ //realiza lo mismo que antes para volver al menu principal en caso de que se desee hacerlo
  462.                         limpiar();
  463.                         fin=1;
  464.                         continue;
  465.                     }
  466.                     else{
  467.                         if (mayuscula(eleccion)=="N"){
  468.                             return 0;
  469.                         }
  470.                     }
  471.                 }
  472.                 case 3:{//CASO PRESTAMOS POR CATEGORIA O POR PRESTATARIO
  473.                     cout << "Desea ver los prestamos ordenados por categoria o por prestatario?" << endl;
  474.                     cin >>eleccion;
  475.                     do{
  476.                     if(mayuscula(eleccion)=="CATEGORIA"){
  477.                         //Se realizaria el ordenado por categoria, genera error al todavia no estar definida la funcion mayuscula
  478.                     }
  479.                     else{
  480.                         if(mayuscula(eleccion)=="PRESTATARIO"){
  481.                             //Se realizaria el ordenado por prestatario, genera error al todavia no estar definida la funcion mayuscula
  482.                         }
  483.                         else{
  484.                             cout <<"Ingreso una opcion no valida, vuelva a ingresar una opcion que si lo sea"<< endl;
  485.  
  486.                         }
  487.                     }
  488.                     }while(mayuscula(eleccion)!="CATEGORIA" && mayuscula(eleccion)!="PRESTATARIO");
  489.                     cout << "------------------------------------------------------------------"<< endl; //Separador
  490.                     cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl;
  491.                     cout << "S/N"<<endl;
  492.                     cin>> eleccion;
  493.                     if(mayuscula(eleccion)=="S"){ //realiza lo mismo que antes para volver al menu principal en caso de que se desee hacerlo
  494.                         limpiar();
  495.                         fin=1;
  496.                         continue;
  497.                     }
  498.                     else{
  499.                         if (mayuscula(eleccion)=="N"){
  500.                             return 0;
  501.                         }
  502.                     }
  503.                 }
  504.                 case 4:{//CASO PRESTATARIOS CON OBJETOS EN PRESTAMO
  505.                     cout << "Los prestatarios con objetos en prestamo son"<< endl;
  506.                     //Se realizaria la opcion deseada
  507.                     cout << "------------------------------------------------------------------"<< endl; //Separador
  508.                     cout << "Desea volver al menu principal para seguir utilizando el programa?"<< endl;
  509.                     cout << "S/N"<<endl;
  510.                     cin>> eleccion;
  511.                     if(mayuscula(eleccion)=="S"){ //realiza lo mismo que antes para volver al menu principal en caso de que se desee hacerlo
  512.                         limpiar();
  513.                         fin=1;
  514.                         continue;
  515.                     }
  516.                     else{
  517.                         if (mayuscula(eleccion)=="N"){
  518.                             return 0;
  519.                         }
  520.                     }
  521.                 }
  522.                 }
  523.             }
  524.         }
  525.     }while(fin!=1);     //este while permite iterar al menu principal siempre y cuando se requiera, cuando el usuiario eliga voler, la variable fin sera "1" y se reiniciara el programa
  526. }while(fin==1);
  527. }
  528.  
  529. //Cuerpo de las funciones WIP
  530.  
  531. string agregar_categoria(string descripcion){
  532.     for(int i=0;i<=cantidad_categorias;i++){
  533.         if(mayuscula(descripcion)==mayuscula(categorias[i].descripcion)){
  534.             return ("La categoria que desea agregar ya existe");
  535.         }
  536.         else if(mayuscula(descripcion)!=mayuscula(categorias[i].descripcion)){
  537.             categorias[i].codigo_categoria=cantidad_categorias;
  538.             categorias[i].descripcion=descripcion;
  539.             cantidad_categorias++;
  540.             return ("Categoria agregada satisfatoriamente");
  541.         }
  542.     }
  543.     return("default");
  544. }
  545. string modificar_categoria(string descripcion){
  546.      string categoria_modif;
  547.      string aux=descripcion;
  548.      for(int i=0;i<cantidad_categorias;i++){
  549.          if (mayuscula(categorias[i].descripcion)==mayuscula(aux)){
  550.              cout <<"La descripcion de la categoria ingresada es correcta"<< endl;
  551.              cout <<"A continuacion ingrese la nueva descripcion para la categoria" <<endl;
  552.              cin>> categoria_modif;
  553.              categorias[i].descripcion=categoria_modif;
  554.              return("Categoria modificada satisfactoriamente");
  555.          }
  556.          else{
  557.              return("La categoria que desea modificar no existe");
  558.          }
  559.      }
  560.      return("default");
  561. }
  562. string eliminar_categoria(string descripcion){
  563.        string descripcion_aux=descripcion;
  564.        int posicion=0;
  565.        int codigo_cat=0;
  566.        int codigoexiste=0;
  567.        int codigoocupado=0;
  568.        for(int i=0;i<cantidad_categorias;i++){
  569.            if(mayuscula(descripcion_aux)==mayuscula(categorias[i].descripcion)){
  570.                codigoexiste=1;
  571.                codigo_cat=categorias[i].codigo_categoria;
  572.            }
  573.            else{
  574.                codigoexiste=0;
  575.            }
  576.  
  577.        }
  578.        for(int i=0;i<cantidad_prestamos;i++){
  579.             if(codigo_cat==prestamos[i].codigo_categoria){
  580.                  codigoocupado=1;
  581.             }
  582.             else{
  583.                  codigoocupado=0;
  584.             }
  585.        }
  586.        if(codigoexiste==1 && codigoocupado==0){
  587.            for(int i=posicion;i<cantidad_categorias;i++){
  588.                categorias[i].descripcion=categorias[i+1].descripcion;
  589.                categorias[i].codigo_categoria=categorias[i+1].codigo_categoria;
  590.                return("La categoria se ha eliminado satisfactoriamente");
  591.            }
  592.            }
  593.        else if(codigoexiste==1 && codigoocupado==1){
  594.            return("La categoria que desea eliminar existe pero esta adjudicada a un prestamo");
  595.        }
  596.        else if(codigoexiste==0){
  597.            return("La categoria que desea eliminar no existe");
  598.        }
  599. }
  600. string agregar_prestatario(string nombre,string apellido){
  601.     for(int i=0;i<=cantidad_categorias;i++){
  602.         if(mayuscula(nombre)==mayuscula(prestatarios[i].nombre) && mayuscula(apellido)==mayuscula(prestatarios[i].apellido)){
  603.             return ("El prestatario que desea agregar ya existe");
  604.         }
  605.         else if(mayuscula(nombre)!=mayuscula(prestatarios[i].nombre) && mayuscula(apellido)!=mayuscula(prestatarios[i].apellido)){
  606.             prestatarios[i].nombre=nombre;
  607.             prestatarios[i].apellido=apellido;
  608.             prestatarios[i].codigo_prestatario=cantidad_prestatarios;
  609.             cantidad_prestatarios++;
  610.             return ("Prestatario agregado satisfatoriamente");
  611.         }
  612.     }
  613.     return("default");
  614. }
  615. string modificar_prestatario(string nombre,string apellido){
  616.     string nombre_modif;
  617.     string apellido_modif;
  618.     string nombre_aux=nombre;
  619.     string apellido_aux=apellido;
  620.      for(int i=0;i<cantidad_prestatarios;i++){
  621.          if(mayuscula(nombre_aux)==prestatarios[i].nombre && mayuscula(apellido_aux)==prestatarios[i].apellido){
  622.              cout <<"El prestatario a modificar es correcto"<< endl;
  623.              cout <<"Ingrese el nuevo nombre del prestatario" <<endl;
  624.              cin>>nombre_modif;
  625.              cout <<"Ingrese el nuevo apellido del prestatario" <<endl;
  626.              cin>>apellido_modif;
  627.              prestatarios[i].nombre=nombre_modif;
  628.              prestatarios[i].apellido=apellido_modif;
  629.              return("Prestatario modificado satisfactoriamente");
  630.          }
  631.          else{
  632.              return("El prestatario que desea modificar no existe");
  633.          }
  634.      }
  635.      return("default");
  636. }
  637. string eliminar_prestatario(string nombre,string apellido){
  638.  
  639. }
  640. string agregar_prestamo(string categoria,string nombre,string apellido,string descripcion){
  641.        string categoria_aux=categoria;
  642.        string nombre_aux=nombre;
  643.        string apellido_aux=apellido;
  644.        string descripcion_aux=descripcion;
  645.        for(int i=0;i<cantidad_categorias;i++){
  646.            if(mayuscula(categoria_aux)==mayuscula(categorias[i].descripcion)){
  647.                for(int j=0;i<cantidad_prestatarios;j++){
  648.                    if(mayuscula(nombre_aux)==mayuscula(prestatarios[j].nombre) && mayuscula(apellido_aux)==mayuscula(prestatarios[j].apellido)){
  649.                        prestamos[i].codigo_categoria=categorias[i].codigo_categoria;
  650.                        prestamos[i].prestatario=prestatarios[i].codigo_prestatario;
  651.                        prestamos[i].descripcion=descripcion_aux;
  652.                        prestamos[i].estado=true;
  653.                        cantidad_prestamos++;
  654.                        return("Prestamo agregado satisfactoriamente");
  655.  
  656.                    }
  657.                    else{
  658.                        return("El prestatario al que desea adjudicar el prestamo no existe");
  659.                        }
  660.                }
  661.            }
  662.            else{
  663.                return("La categoria a la que adjudica el prestamo no existe");
  664.                }
  665.        }
  666.        return("default");
  667. }
  668. string modificar_prestamo(string descripcion){
  669.  
  670. }
  671. string eliminar_prestamo(string descripcion){
  672.  
  673. }
  674. string terminar_prestamo(string descripcion){
  675.        string descripcion_aux=descripcion;
  676.        for(int i=0;i<cantidad_prestamos;i++){
  677.            if(mayuscula(descripcion_aux)==mayuscula(prestamos[i].descripcion)){
  678.                prestamos[i].estado=false;
  679.                eliminar_prestamo(descripcion_aux);
  680.                return("El prestamo ha terminado satisfactoriamente");
  681.            }
  682.            else{
  683.                return("El prestamo que desea finalizar no existe");
  684.            }
  685.        }
  686.        return("default");
  687. }
  688. string mayuscula(string cadena){
  689.       for(int i=0;i<cadena.length();i++){
  690.           cadena[i]=toupper(cadena[i]);
  691.       }
  692.       return cadena;
  693. }
  694.  
  695. void limpiar(){
  696.     system("cls");
  697. }
  698.  
RAW Paste Data