Brunoroman

PI ENTREGA 3.1

Oct 28th, 2021
626
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. #include <conio.h>  //LIBRERIA CONIO.H permite usar la funcion getch(), hace que no se cierre la terminal al ser ejecutado el programa.
  5. using namespace std;
  6.  
  7. // Funcion del programa
  8. // Sistema para registrar, administrar y consultar prestamos
  9.  
  10. /*
  11. ===================
  12.      VARIABLES
  13. ===================
  14. */
  15.  
  16. const int dFisica = 100; // DIMENSION FISICA DE LOS ARREGLOS
  17.  
  18. int cantidad_categorias = 0;   // Variable para saber la dimension logica de las categorias
  19. int cantidad_prestamos = 0;    // Lo mismo que la anterior para los prestamos
  20. int cantidad_prestatarios = 0; // Lo mismo para los prestatarios
  21.  
  22. /*
  23. ================
  24.      STRUCS
  25. ================
  26. */
  27.  
  28. struct c
  29. { // Plantilla del struct para las categorias
  30.     int codigo_categoria;
  31.     string descripcion;
  32. };
  33.  
  34. struct pr
  35. { // Plantilla del struct para los prestamos
  36.     int codigo_categoria;
  37.     int prestatario;
  38.     string descripcion;
  39.     bool estado;
  40. };
  41.  
  42. struct pres
  43. { // Plantilla del struct para prestatarios
  44.     int codigo_prestatario;
  45.     string apellido;
  46.     string nombre;
  47. };
  48.  
  49. c categorias[dFisica];
  50. pr prestamos[dFisica]; // Definicion de los 3 arreglos para almacenar categorias,prestamos y prestatarios.
  51. pres prestatarios[dFisica];
  52.  
  53. /*
  54. ===================
  55.      FUNCIONES
  56. ===================
  57. */
  58.  
  59. void limpiar()
  60. {
  61.     // Funcion limpiar
  62.     // PROPOSITO: Limpiar la pantalla mediante system("cls")
  63.     // PARAMETROS: No pide ningun parametro
  64.     // RETORNO:No retorna nada ya que es del tipo void
  65.  
  66.     system("cls");
  67. }
  68.  
  69. string mayuscula(string cadena)
  70. {
  71.     // Funcion mayuscula
  72.     // PROPOSITO: Hacer que el string ingresado, retorne en mayusculas, sirve para normalizar los string que se utilicen y evitar errores al compararlos
  73.     // PARAMETROS: Un string deseado para convertirlo en mayusculas
  74.     // RETORNO: Retorna un string que es el mismo que el ingresado, pero con todas sus letras en mayusculas
  75.  
  76.     for (int i = 0; i < cadena.length(); i++)
  77.     {
  78.         cadena[i] = toupper(cadena[i]);
  79.     }
  80.     return cadena;
  81. }
  82.  
  83. string agregarCategoria(string descripcion)
  84. {
  85.     // Funcion agregar_categoria
  86.     // PROPOSITO: Agregar una categoria al struct categorias, le asigna un codigo interno a la categoria y revisa que la categoria no este repetida
  87.     // PARAMETROS: Descripcion de la categoria a agregar
  88.     // RETORNO: Retorna un string que dice si se agrego o no la categoria
  89.     for (int i = 0; i <= cantidad_categorias; i++)
  90.     {
  91.         if (mayuscula(descripcion) == mayuscula(categorias[i].descripcion))
  92.         {
  93.             return ("La categoria que desea agregar ya existe!");
  94.         }
  95.         else
  96.         {
  97.             for (int j = cantidad_categorias; j < dFisica; j++)
  98.             {
  99.                 categorias[j].codigo_categoria = cantidad_categorias;
  100.                 categorias[j].descripcion = descripcion;
  101.                 cantidad_categorias++;
  102.                 return ("Categoria agregada satisfatoriamente!");
  103.             }
  104.         }
  105.     }
  106.     return ("default");
  107. }
  108.  
  109. string modificarCategoria(string descripcion)
  110. {
  111.     // Funcion modificar_categoria
  112.     // PROPOSITO: Modificar una categoria existente en el struct categorias
  113.     // PARAMETROS: Descripcion de la categoria a modificar
  114.     // RETORNO: Retorna un string que dice si la modificacion fue satisfatoria o no
  115.     string categoria_modif;
  116.     string aux = descripcion;
  117.     for (int i = 0; i <= cantidad_categorias; i++)
  118.     {
  119.         if (mayuscula(categorias[i].descripcion) == mayuscula(aux))
  120.         {
  121.             cout << "La categoria a modificar ingresada es correcta!" << endl;
  122.             cout << "\nA continuacion ingrese el nuevo nombre para la categoria: ";
  123.             cin >> categoria_modif;
  124.             categorias[i].descripcion = categoria_modif;
  125.             limpiar();
  126.             return ("Categoria modificada satisfactoriamente!");
  127.         }
  128.         else
  129.         {
  130.             return ("La categoria que desea modificar no existe!");
  131.         }
  132.     }
  133.     return ("default");
  134. }
  135.  
  136. string eliminarCategoria(string descripcion)
  137. {
  138.     // Funcion eliminar_categoria
  139.     // PROPOSITO: Eliminar una categoria del struct antes nombrado, si y solo si la categoria no tiene un prestamo en activo
  140.     // PARAMETROS: Descripcion de la categoria a eliminar
  141.     // RETORNO: Retorna un string que dice si se pudo eliminar o no la categoria
  142.     string descripcion_aux = descripcion;
  143.     int posicion = 0;
  144.     int codigo_cat = 0;
  145.     int codigoexiste = 0;
  146.     int codigoocupado = 0;
  147.     for (int i = 0; i < cantidad_categorias; i++)
  148.     {
  149.         if (mayuscula(descripcion_aux) == mayuscula(categorias[i].descripcion))
  150.         {
  151.             codigoexiste = 1;
  152.             codigo_cat = categorias[i].codigo_categoria;
  153.         }
  154.         else
  155.         {
  156.             codigoexiste = 0;
  157.         }
  158.     }
  159.     for (int i = 0; i < cantidad_prestamos; i++)
  160.     {
  161.         if (codigo_cat == prestamos[i].codigo_categoria)
  162.         {
  163.             codigoocupado = 1;
  164.         }
  165.         else
  166.         {
  167.             codigoocupado = 0;
  168.         }
  169.     }
  170.     if (codigoexiste == 1 && codigoocupado == 0)
  171.     {
  172.         for (int i = posicion; i < cantidad_categorias; i++)
  173.         {
  174.             categorias[i].descripcion = categorias[i + 1].descripcion;
  175.             categorias[i].codigo_categoria = categorias[i + 1].codigo_categoria;
  176.             return ("La categoria se ha eliminado satisfactoriamente!");
  177.         }
  178.     }
  179.     else if (codigoexiste == 1 && codigoocupado == 1)
  180.     {
  181.         return ("La categoria que desea eliminar existe pero esta adjudicada a un prestamo!");
  182.     }
  183.     else if (codigoexiste == 0)
  184.     {
  185.         return ("La categoria que desea eliminar no existe!");
  186.     }
  187. }
  188.  
  189. string agregarPrestatario(string nombre, string apellido)
  190. {
  191.     int repetidos = 0;
  192.     for (int i = 0; i <= cantidad_prestatarios; i++)
  193.     {
  194.         if (mayuscula(nombre) == mayuscula(prestatarios[i].nombre) && mayuscula(apellido) == mayuscula(prestatarios[i].apellido))
  195.         {
  196.             repetidos++;
  197.         }
  198.     }
  199.     if (repetidos == 0)
  200.     {
  201.         prestatarios[cantidad_prestatarios].nombre = nombre;
  202.         prestatarios[cantidad_prestatarios].apellido = apellido;
  203.         prestatarios[cantidad_prestatarios].codigo_prestatario = cantidad_prestatarios;
  204.         cantidad_prestatarios++;
  205.         return ("Prestatario agregado satisfatoriamente!");
  206.     }
  207.     return ("El prestatario que desea agregar ya existe!");
  208. }
  209.  
  210. string modificarPrestatario(string nombre, string apellido)
  211. {
  212.     string nombre_modif;
  213.     string apellido_modif;
  214.     string nombre_aux = nombre;
  215.     string apellido_aux = apellido;
  216.     for (int i = 0; i < cantidad_prestatarios; i++)
  217.     {
  218.         if (mayuscula(nombre_aux) == mayuscula(prestatarios[i].nombre) && mayuscula(apellido_aux) == mayuscula(prestatarios[i].apellido))
  219.         {
  220.             cout << "El prestatario a modificar es correcto!" << endl;
  221.             cout << "Ingrese el nuevo nombre del prestatario: ";
  222.             cin >> nombre_modif;
  223.             cout << "Ingrese el nuevo apellido del prestatario: ";
  224.             cin >> apellido_modif;
  225.             prestatarios[i].nombre = nombre_modif;
  226.             prestatarios[i].apellido = apellido_modif;
  227.             return ("Prestatario modificado satisfactoriamente!");
  228.         }
  229.         else
  230.         {
  231.             return ("El prestatario que desea modificar no existe!");
  232.         }
  233.     }
  234.     return ("default");
  235. }
  236.  
  237. string eliminarPrestatario(string nombre, string apellido)
  238. {
  239.     // Funcion eliminarPrestatario
  240.     // 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
  241.     // 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
  242.     // PARAMETROS: Nombre y apellido del prestatario a modificar
  243.     // RETORNO: Retorna un string que indica si se elimino o no al prestatario que se desea
  244.     for (int i = 0; i <= cantidad_prestatarios; i++)
  245.     {
  246.         if (mayuscula(nombre) == mayuscula(prestatarios[i].nombre) && mayuscula(apellido) == mayuscula(prestatarios[i].apellido))
  247.         {
  248.             for (; i < cantidad_prestatarios; i++)
  249.             {
  250.                 prestatarios[i].nombre = prestatarios[i + 1].nombre;
  251.                 prestatarios[i].apellido = prestatarios[i + 1].apellido;
  252.             }
  253.             return ("Prestatario eliminado correctamente");
  254.         }
  255.     }
  256.     return ("Prestatario no encontrado");
  257. }
  258.  
  259. string agregarPrestamo(string categoria, string nombre, string apellido, string descripcion)
  260. {
  261.     // Funcion agregarPrestamo
  262.     // PROPOSITO: Agregar un prestamo al struct de los mismos, generando un booleano que indica el estado del prestamo, TRUE=prestamo activo, FALSE=prestamo finalizado
  263.     // PARAMETROS: Categoria del prestamo(aclaracion es un string ya que no se usara el codigo de la categoria, sino la descripcion del primer struct
  264.     // llamado categorias para hacer mas facil al usuario el ingreso), aparte de este, se pide nombre y apellido del prestatario
  265.     // y por ultimo una descripcion del prestamo
  266.     // RETORNO: Retorna un string que indica si se agrego o no satisfatoriamente el prestamo a la base de datos
  267.  
  268.     string categoria_aux = categoria;
  269.     string nombre_aux = nombre;
  270.     string apellido_aux = apellido;
  271.     string descripcion_aux = descripcion;
  272.     for (int i = 0; i < cantidad_categorias; i++)
  273.     {
  274.         if (mayuscula(categoria_aux) == mayuscula(categorias[i].descripcion))
  275.         {
  276.             for (int j = 0; i <= cantidad_prestatarios; j++)
  277.             {
  278.                 if (mayuscula(nombre_aux) == mayuscula(prestatarios[j].nombre) && mayuscula(apellido_aux) == mayuscula(prestatarios[j].apellido))
  279.                 {
  280.                     prestamos[i].codigo_categoria = categorias[i].codigo_categoria;
  281.                     prestamos[i].prestatario = prestatarios[i].codigo_prestatario;
  282.                     prestamos[i].descripcion = descripcion_aux;
  283.                     prestamos[i].estado = true;
  284.                     cantidad_prestamos++;
  285.                     return ("Prestamo agregado satisfactoriamente!");
  286.                 }
  287.                 else
  288.                 {
  289.                     return ("El prestatario al que desea adjudicar el prestamo no existe!");
  290.                 }
  291.             }
  292.         }
  293.         else
  294.         {
  295.             return ("La categoria a la que adjudica el prestamo no existe!");
  296.         }
  297.     }
  298.     return ("default");
  299. }
  300.  
  301. string modificarPrestamo(string descripcion)
  302. {
  303.     // Funcion modificar_prestamo
  304.     // 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
  305.     // PARAMETROS: Descripcion del prestamo a modificar
  306.     // RETORNO: Retorna un string informando al usuario sobre el estado de la operacion realizada, en otras palabras si la modificacion salio bien o no
  307.  
  308.     for (int i = 0; i <= cantidad_prestamos; i++)
  309.     {
  310.         string nuevaDescripcion;
  311.         cout << "INGRESE LA DESCRIPCION NUEVA: ";
  312.         getline(cin >> ws, nuevaDescripcion);
  313.         if (mayuscula(descripcion) == mayuscula(prestamos[i].descripcion))
  314.         {
  315.             prestamos[i].descripcion = nuevaDescripcion;
  316.  
  317.             return "LA DESCRIPCION SE ELIMINO CORRECTAMENTE!";
  318.         }
  319.         else
  320.         {
  321.             return "LA DESCRIPCION NO SE PUDO ELIMINAR!";
  322.         }
  323.     }
  324. }
  325.  
  326. string eliminarPrestamo(string descripcion)
  327. {
  328.     // Funcion eliminar_prestamo
  329.     // PROPOSITO: Eliminar un prestamo de la base de datos
  330.     // PARAMETROS: Se pide la descripcion del prestamo a eliminar
  331.     // RETORNO: Retorna un string que indica el estado de la operacion realizada
  332.     for (int i = 0; i <= cantidad_prestamos; i++)
  333.     {
  334.         if (mayuscula(descripcion) == mayuscula(prestamos[i].descripcion) && prestamos[i].estado == false)
  335.         {
  336.             prestamos[i].codigo_categoria = prestamos[i + 1].codigo_categoria;
  337.             prestamos[i].prestatario = prestamos[i + 1].prestatario;
  338.             prestamos[i].descripcion = prestamos[i + 1].descripcion;
  339.             cantidad_prestamos--;
  340.             return "EL PRESTAMO SE ELIMINO CORRECTAMENTE!";
  341.         }
  342.         else
  343.         {
  344.             return "EL PRESTAMO NO SE PUDO ELIMINAR!";
  345.         }
  346.     }
  347. }
  348.  
  349. string terminar_prestamo(string descripcion)
  350. {
  351.     // Funcion terminar_prestamo
  352.     // PROPOSITO: Terminar un prestamo en activo, cambiando su parte booleana de true a false
  353.     // PARAMETROS: La descripcion del prestamo a terminar
  354.     // RETORNO: Retorna un string y como todas las anteriores, este string indica si la operacion fue satisfatoria o no
  355.     string descripcion_aux = descripcion;
  356.     for (int i = 0; i < cantidad_prestamos; i++)
  357.     {
  358.         if (mayuscula(descripcion_aux) == mayuscula(prestamos[i].descripcion))
  359.         {
  360.             prestamos[i].estado = false;
  361.             return ("El prestamo ha terminado satisfactoriamente");
  362.         }
  363.         else
  364.         {
  365.             return ("El prestamo que desea finalizar no existe");
  366.         }
  367.     }
  368.     return ("default");
  369. }
  370. string title(string frase){
  371.     string frase_aux=frase;
  372.     frase_aux[0]=toupper(frase_aux[0]);
  373.     for(int i=1;i<frase_aux.length();i++){
  374.         frase_aux[i]=tolower(frase_aux[i]);
  375.     }
  376.     return(frase_aux);
  377. }
  378.  
  379. void cantidad_objetos_categoria(string descripcion){
  380.     //Funcion cantidad_objetos_categoria
  381.     //Proposito:Imprimir la cantidad de objetos para una categoria dada
  382.     //Parametros:Descripcion de la categoria a buscar
  383.     //Retorno:Void, no retorna nada
  384.     string descripcion_aux=mayuscula(descripcion);
  385.     int codigo_aux=0;
  386.     int cantidad_aux=0;
  387.     bool existe=false;
  388.     for(int i=0;i<cantidad_categorias;i++){
  389.         if(descripcion_aux==mayuscula(categorias[i].descripcion)){
  390.             codigo_aux=categorias[i].codigo_categoria;
  391.             existe=true;
  392.         }
  393.  
  394.     }
  395.     if(existe==true){
  396.         for(int j=0;j<cantidad_prestamos;j++){
  397.             if(codigo_aux==prestamos[j].codigo_categoria){
  398.                 cantidad_aux++;
  399.             }
  400.         }
  401.         cout<<"La cantidad de objetos de la categoria deseada es:" << cantidad_aux <<endl;
  402.     }
  403.     else{
  404.         cout<<"La categoria que desea consultar no existe"<<endl;
  405.     }
  406. }
  407.  
  408. void imprimirObjetos_Categoria(c categorias[], int cantidad_categorias)
  409. {
  410.     // Funcion imprimirObjetos_Categoria
  411.     // PROPOSITO: Imprimir lista de objetos prestados
  412.     // PARAMETROS: Struct de categorias
  413.     // RETORNO: Void, no retorna
  414.     for (int i = 0; i < cantidad_categorias; i++)
  415.     {
  416.         cout << "Objeto Prestado: " << categorias[i].descripcion << endl;
  417.     }
  418. }
  419.  
  420. void imprimirPrestatarios(pres prestatarios[], int cantidad_prestatarios)
  421. {
  422.     // Funcion imprimirPrestatarios
  423.     // PROPOSITO: Imprimir lista de prestatarios
  424.     // PARAMETROS: Struct prestatarios
  425.     // RETORNO: Void, no retorna
  426.     for (int i = 0; i < cantidad_prestatarios; i++)
  427.     {
  428.         cout << "Prestatario: " << prestatarios[i].nombre << " " << prestatarios[i].apellido << endl;
  429.     }
  430. }
  431.  
  432. void imprimir_prestamos_por_categoria(string descripcion){
  433.     //Funcion imprimir_prestamos_por_categoria
  434.     //PROPOSITO: Imprimir los prestamos que presentan la categoria deseada
  435.     //Parametro: La descripcion de la categoria
  436.     //Retorno: Void, no retorna nada
  437.     string descripcion_aux=mayuscula(descripcion);
  438.     int codigo_aux=0;
  439.     bool existe=false;
  440.     for(int i=0;i<cantidad_categorias;i++){
  441.         if(descripcion_aux==categorias[i].descripcion){
  442.             codigo_aux=categorias[i].codigo_categoria;
  443.             existe=true;
  444.         }
  445.     }
  446.     if(existe==true){
  447.         for(int j=0;j<cantidad_prestamos;j++){
  448.             if(codigo_aux==prestamos[j].codigo_categoria){
  449.                 cout<<"Prestamo"<<j<<endl;
  450.                 cout<<"Descripcion:"<<title(prestamos[j].descripcion)<<endl;
  451.             }
  452.     }
  453. }
  454.     else{
  455.         cout<<"La categoria ingresada no existe"<<endl;
  456.     }
  457. }
  458.  
  459. void imprimirOrdenCategoria()
  460. {
  461.     // Funcion imprimirPorCategoria
  462.     // PROPOSITO: Imprimir lista de prestamos por orden categoria
  463.     // PARAMETROS: Struct prestamos
  464.     // RETORNO: Void, no retorna
  465. }
  466.  
  467. void imprimirOrdenPrestatario()
  468. {
  469.     // Funcion imprimirPorCategoria
  470.     // PROPOSITO: Imprimir lista de prestamos por orden prestatario
  471.     // PARAMETROS: Struct prestamos
  472.     // RETORNO: Void, no retorna
  473. }
  474.  
  475. void imprimirPrestatarioActivo(pr prestamos[], int cantidad_prestamos)
  476. {
  477.     // Funcion imprimirPrestatarioActivo
  478.     // PROPOSITO: Imprimir lista de prestatarios con prestamos activos
  479.     // PARAMETROS: Struct prestamos
  480.     // RETORNO: Void, no retorna
  481.     int contadorPrestatarios = 0;
  482.     cout << "\nLista de prestatarios con prestamos activos: " << endl;
  483.     cout << endl;
  484.     for (int i = 0; i < cantidad_prestamos; i++)
  485.     {
  486.         if (prestamos[i].estado == true)
  487.         {
  488.             cout << prestamos[i].prestatario << endl;
  489.             contadorPrestatarios++;
  490.         }
  491.         if (contadorPrestatarios == 0)
  492.         {
  493.             cout << "NO SE ENCONTRARON PRESTATARIOS ACTIVOS!" << endl;
  494.         }
  495.     }
  496. }
  497.  
  498. /*
  499. ======================
  500.      FUNCION MAIN
  501. ======================
  502. */
  503.  
  504. int main()
  505. {
  506.  
  507.     char seleccion, seleccionA, seleccionB, seleccionC;                                                                  // variables donde se almacenara la opcion del usuario
  508.     string categoriaAgregar, categoriaModificar, categoriaEliminar;                                                      // variables donde se almacenara los datos del usuario del inciso A
  509.     string nombrePrestatario, apellidoPrestatario, nombreModificar, apellidoModificar, nombreEliminar, apellidoEliminar; // variables donde se almacenara los datos del usuario del inciso A
  510.     string seleccionMenuB, ingresarCategoriaB, agregarNombreB, agregarApellidoB, descripcionPrestamoB;                   // Variables utilizadas en inciso B
  511.     string seleccionMenuC;                                                                                               // Variables usadas en el inciso C
  512.  
  513.     // Menu principal, loopeado mediante un do/while
  514.  
  515.     do
  516.     {                                            // Do del menu principal, para permitir volver al menu tras realizada cualquier opcion del menu
  517.         cout << "\nBienvenido al menu!" << endl; // Se muestra el menu mediante un COUT
  518.         cout << "\nA: Administrar y consultar Categorias y Prestatarios." << endl;
  519.         cout << "B: Administrar Prestamos." << endl;
  520.         cout << "C: Consultar Prestamos." << endl;
  521.         cout << "D: Salir." << endl;
  522.         cout << "\nElija la opcion a utilizar: ";
  523.         cin >> seleccion; // CIN ingresa la opcion deseada
  524.  
  525.         seleccion = toupper(seleccion); // convertimos la letra en mayusculas para que sea indiferente el ingreso de mayuscula o minuscula
  526.  
  527.         switch (seleccion)
  528.         {
  529.         case 'A':      // PRIMER CASO DEL MENU PRINCIPAL
  530.             limpiar(); // LIMPIA PANTALLA DEL MENU PRINCIPAL
  531.             do
  532.             { // Do del menu de la opcion A, para permitir volver al menu tras realizada cualquier seleccion
  533.                 cout << "\nOPCION A: Administracion y consulta de Categorias y Prestatarios!" << endl;
  534.                 cout << "\nA: Agregar categoria." << endl;
  535.                 cout << "B: Modificar categoria." << endl;   // Se pone en pantalla las opciones del apartado
  536.                 cout << "C: Eliminar categoria." << endl;    // Administracion y consultas de categorias
  537.                 cout << "\nD: Agregar prestatario." << endl; // Con un funcionamiento casi igual al principal
  538.                 cout << "E: Modificar prestatario." << endl; // Permite ingresar al usuario otra opcion del menu
  539.                 cout << "F: Eliminar prestatario." << endl;  // Y como en el principal, se comprueba si la opcion ingresada
  540.                 cout << "\nG: Volver al menu principal." << endl;
  541.                 cout << "\nElija la opcion a utilizar: "; // Es o no correcta.
  542.                 cin >> seleccionA;
  543.  
  544.                 seleccionA = toupper(seleccionA);
  545.  
  546.                 switch (seleccionA)
  547.                 {
  548.                 case 'A':
  549.                     cout << "\nOPCION A: Ingrese la categoria a agregar: "; // Se pide la categoria a agregar
  550.                     getline(cin >> ws, categoriaAgregar);                   // Se ingresa en la variable
  551.                     limpiar();                                              // Limpia pantalla
  552.                     cout << agregarCategoria(categoriaAgregar) << endl;     // Se ejecuta la funcion que la agrega en el struct
  553.                     break;
  554.  
  555.                 case 'B':
  556.                     cout << "\nOPCION B: Ingrese la categoria a modificar: "; // Se pide categoria a modificar
  557.                     getline(cin >> ws, categoriaModificar);                   // Se ingresa en la variable para ser modificada
  558.                     limpiar();                                                // Limpia pantalla
  559.                     cout << modificarCategoria(categoriaModificar) << endl;   // Se ejecuta la funcion que modifica la categoria
  560.                     break;
  561.  
  562.                 case 'C':
  563.                     cout << "\nOPCION C: Ingrese categoria a eliminar: "; // Se pide categoria a eliminar
  564.                     getline(cin >> ws, categoriaEliminar);                // Se ingresa la categoria
  565.                     limpiar();                                            // Se limpia pantalla
  566.                     cout << eliminarCategoria(categoriaEliminar) << endl; // Se elimina la categoria mediante la funcion
  567.                     break;
  568.  
  569.                 case 'D':
  570.                     cout << "\nOPCION D: Ingrese nombre del prestatario: ";                     // Se pide el nombre del prestatario
  571.                     getline(cin >> ws, nombrePrestatario);                                      // Se ingresa el nombre en la variable
  572.                     cout << "\nIngrese appelido del prestatario: ";                             // Se pide el apellido del prestatario
  573.                     getline(cin >> ws, apellidoPrestatario);                                    // Se ingresa el apellido en la variable
  574.                     limpiar();                                                                  // Se limpia pantalla
  575.                     cout << agregarPrestatario(nombrePrestatario, apellidoPrestatario) << endl; // Se procesan los datos en la funcion
  576.                     break;
  577.  
  578.                 case 'E':
  579.                     cout << "\nOPCION E: Ingrese nombre a modificar: ";                       // Se pide el nombre del prestatario a modificar
  580.                     getline(cin >> ws, nombreModificar);                                      // Se ingresa el nombre en la variable
  581.                     cout << "\nIngrese apellido a modificar: ";                               // Se pide el apellido del prestatario a modificar
  582.                     getline(cin >> ws, apellidoModificar);                                    // Se ingresa el apellido en la variable
  583.                     limpiar();                                                                // Se limpia pantalla
  584.                     cout << modificarPrestatario(nombreModificar, apellidoModificar) << endl; // Se modifica el nombre y apellido del prestatario mediante la funcion
  585.                     break;
  586.  
  587.                 case 'F':
  588.                     cout << "OPCION F: Ingrese nombre del prestatario a eliminar: ";       // Se pide el nombre del prestatario a modificar
  589.                     getline(cin >> ws, nombreEliminar);                                    // Se ingresa el nombre en la variable
  590.                     cout << "\nIngrese apellido del prestatario a eliminar: ";             // Se pide el apellido del prestatario a modificar
  591.                     getline(cin >> ws, apellidoEliminar);                                  // Se ingresa el apellido en la variable
  592.                     limpiar();                                                             // Se limpia pantalla
  593.                     cout << eliminarPrestatario(nombreEliminar, apellidoEliminar) << endl; // Se elimina el prestatario mdeiante la funcion
  594.                     break;
  595.                 case 'G':
  596.                     limpiar();
  597.                     cout << "'G': VOLVIENDO AL MENU PRINCIPAL" << endl; // MUESTRA EN PANTALLA LA OPCION SELECCIONADA Y REGRESA AL MENU PRINCIPAL
  598.                     break;
  599.  
  600.                 default:
  601.                     // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
  602.                     // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
  603.                     limpiar(); // se limpia la pantalla
  604.                     cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
  605.                     break;
  606.                 }
  607.             } while (seleccionA != 'G');
  608.             break;
  609.  
  610.         case 'B':      // SEGUNDO CASO DEL MENU PRINCIPAL
  611.             limpiar(); // LIMPIA PANTALLA DEL MENU PRINCIPAL
  612.             do
  613.             { // Do del menu B, para permitir volver al menu tras realizada cualquier seleccion
  614.                 cout << "\nOPCION B: Administracion de Prestamos!" << endl;
  615.                 cout << "\nA: Agregar prestamo." << endl;
  616.                 cout << "B: Modificar prestamo." << endl; // Se ponen en pantalla las opciones del la opcion B
  617.                 cout << "C: Eliminar prestamo." << endl;
  618.                 cout << "D: Devolver prestamo." << endl;
  619.                 cout << "\nE: Volver al menu principal." << endl;
  620.                 cout << "\nElija la opcion a utilizar: ";
  621.                 cin >> seleccionB; // Se ingresa la opcion seleccionada
  622.  
  623.                 seleccionB = toupper(seleccionB);
  624.  
  625.                 switch (seleccionB)
  626.                 {
  627.                 case 'A':
  628.                     limpiar();
  629.                     cout << "Desea ver las categorias actuales para su Prestamo?" << endl; // Se pregunta al usuario si desea ver las categorias existentes para su prestamo
  630.                     cout << "S/N: ";
  631.                     cin >> seleccionMenuB; // Se ingresa s o n para si o no respectivamente
  632.                     if (mayuscula(seleccionMenuB) == "S")
  633.                     { // Se comprueba que se elija si
  634.  
  635.                         imprimirObjetos_Categoria(categorias, cantidad_categorias); // Se realizaria la muestra de las categorias para los prestamos
  636.  
  637.                         cout << "Ingrese una categoria para el prestamo: ";
  638.                         cin >> ingresarCategoriaB; // Y le permite ingresar la descripcion de la categoria
  639.                     }
  640.                     else if (mayuscula(seleccionMenuB) == "N")
  641.                     {                                                       // Se comprueba si eligio no
  642.                         cout << "Ingrese una categoria para el prestamo: "; // En caso de que no, se le da la opcion a ingresar una categoria sin ver todas
  643.                         cin >> ingresarCategoriaB;                          // Se ingresa la eleccion
  644.                     }
  645.  
  646.                     cout << "Desea ver los prestatarios ya inscriptos?" << endl; // Se realiza lo mismo que en la pregunta anterior pero con los prestatarios
  647.                     cout << "S/N: ";
  648.                     cin >> seleccionMenuB;
  649.                     if (mayuscula(seleccionMenuB) == "S")
  650.                     { // Caso Si
  651.  
  652.                         imprimirPrestatarios(prestatarios, cantidad_prestatarios); // Se realizaria la muestra de los prestatarios
  653.  
  654.                         cout << "Ingrese el nombre del prestatario para el prestamo: "; // Se pide el nombre del prestatario
  655.                         cin >> agregarNombreB;                                          // Se ingresa el nombre
  656.                         cout << "Ingrese el apellido para el prestamo: ";               // Se pide el apellido del prestatario
  657.                         cin >> agregarApellidoB;                                        // Se ingresa
  658.                     }
  659.  
  660.                     // ACLARACION, en la funcion se busca el codigo del prestatario y el codigo de la categoria, para poder almacenar en el struct prestamos
  661.  
  662.                     else if (mayuscula(seleccionMenuB) == "N")
  663.                     {                                                                   // Caso No
  664.                         cout << "Ingrese el nombre del prestatario para el prestamo: "; // Se piden e ingresan directamente nombre y
  665.                         cin >> agregarNombreB;                                          // apellido del prestatario para el prestamo
  666.                         cout << "Ingrese el apellido del prestatario para el prestamo: ";
  667.                         cin >> agregarApellidoB;
  668.                     }
  669.  
  670.                     cout << "Ingrese una descripcion para el prestamo: "; // Se pide ingresar una descripcion al prestamo
  671.                     cin >> descripcionPrestamoB;                          // Se ingresa
  672.                     limpiar();
  673.                     cout << agregarPrestamo(ingresarCategoriaB, agregarNombreB, agregarApellidoB, descripcionPrestamoB) << endl;
  674.                     // 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
  675.                     break;
  676.  
  677.                 case 'B':
  678.                     limpiar();
  679.                     cout << "\nOPCION B: Ingrese la descripcion del prestamo a modificar: "; // Se le pide al usuario ingresarla
  680.                     cin >> descripcionPrestamoB;                                             // Se ingresa
  681.                     limpiar();
  682.                     cout << modificarPrestamo(descripcionPrestamoB) << endl;
  683.                     // Se llama a la funcion modificar_prestamo y con el cout se imprime el mensaje de error o no que devuelve la funcion
  684.                     break;
  685.  
  686.                 case 'C':
  687.                     limpiar();
  688.                     cout << "\nOPCION C: Ingrese la descripcion del prestamo a eliminar: "; // Se pide al usuario
  689.                     cin >> descripcionPrestamoB;                                            // Se Ingresa
  690.                     cout << eliminarPrestamo(descripcionPrestamoB) << endl;                 // Se llama a la funcion con un cout como en los anteriores casos para poder devolver el mensaje de error o lo contrario
  691.                     break;
  692.  
  693.                 case 'D':
  694.                     limpiar();
  695.                     cout << "\nOPCION D: Ingrese la descripcion del prestamo a devolver: "; // Se pide al usuario
  696.                     cin >> descripcionPrestamoB;                                            // Se ingresa
  697.                     cout << terminar_prestamo(descripcionPrestamoB) << endl;                // Se llama a la funcion con el parametro de la descripcion ingresada y se devuelve el mensaje de correcto o error
  698.                     break;
  699.  
  700.                 case 'E':
  701.                     limpiar();
  702.                     cout << "'E': VOLVIENDO AL MENU PRINCIPAL" << endl; // MUESTRA EN PANTALLA LA OPCION SELECCIONADA
  703.                     break;
  704.  
  705.                 default:
  706.                     // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
  707.                     // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
  708.                     limpiar(); // se limpia la pantalla
  709.                     cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
  710.                     break;
  711.                 }
  712.             } while (seleccionB != 'E');
  713.             break;
  714.  
  715.         case 'C':      // TERCER CASO DEL MENU PRINCIPAL
  716.             limpiar(); // LIMPIA PANTALLA DEL MENU PRINCIPAL
  717.             do
  718.             { // Do del menu de la opcion C, para permitir volver al menu tras realizada cualquier seleccion
  719.                 cout << "\nOPCION C:Consultas de Prestamos!" << endl;
  720.                 cout << "\nA: Cantidad de objetos prestados por categoria." << endl;
  721.                 cout << "B: Listado de prestamos por categoria." << endl; // Se ponen en pantalla las opciones
  722.                 cout << "C: Listado de prestamos ordenados por prestatario o categoria." << endl;
  723.                 cout << "D: Prestatarios con objetos en prestamo." << endl;
  724.                 cout << "\nE: Volver al menu principal." << endl;
  725.                 cout << "\nElija la opcion a utilizar: ";
  726.                 cin >> seleccionC; // Se ingresa el numero de opcion
  727.  
  728.                 seleccionC = toupper(seleccionC);
  729.  
  730.                 switch (seleccionC)
  731.                 {
  732.                 case 'A':
  733.                     limpiar();
  734.                     cout << "OPCION A" << endl;
  735.                     cout<<"Ingrese la categoria de la que desea conocer cantidad de objetos en prestamo";
  736.                     getline(cin >> ws, categoriaAgregar);
  737.                     cantidad_objetos_categoria(categoriaAgregar);
  738.                     break;
  739.  
  740.                 case 'B':
  741.                     cout << "OPCION B" << endl;
  742.                     cout<<"Ingrese la categoria de la que desea conocer los prestamos activos";
  743.                     getline(cin >> ws, categoriaAgregar);
  744.                     imprimir_prestamos_por_categoria(categoriaAgregar);
  745.                     break;
  746.  
  747.                 case 'C':
  748.                     cout << "OPCION C" << endl;
  749.                     break;
  750.  
  751.                 case 'D':
  752.                     limpiar();                                                // LIMPIA LA PANTALLA
  753.                     cout << "\nOPCION D" << endl;                             // MUESTRA EN PANTALLA
  754.                     imprimirPrestatarioActivo(prestamos, cantidad_prestamos); // SE EJECUTA LA FUNCION QUE MUESTRA LOS PRESTATARIOS ACTIVOS
  755.                     break;
  756.  
  757.                 case 'E':
  758.                     limpiar();
  759.                     cout << "'E': VOLVIENDO AL MENU PRINCIPAL" << endl; // MUESTRA EN PANTALLA LA OPCION SELECCIONADA
  760.                     break;
  761.  
  762.                 default:
  763.                     // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
  764.                     // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
  765.                     limpiar(); // se limpia la pantalla
  766.                     cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
  767.                     break;
  768.                 }
  769.             } while (seleccionC != 'E');
  770.             break;
  771.  
  772.         case 'D':
  773.             cout << "\nSELECCIONO LA OPCION SALIR." << endl; // MUESTRA EN PANTALLA QUE OPCION SELECCIONO
  774.             break;
  775.  
  776.         default:
  777.             // EN EL CASO DE QUE INGRESE UNA LETRA ERRONEA, EL PROGRAMA MOSTRARA
  778.             // ESTE MENSAJE Y LE DEJARA VOLVER A INGRESAR OTRA LETRA
  779.             limpiar(); // se limpia la pantalla
  780.             cout << "\nPOR FAVOR, SELECCIONE UNA OPCION VALIDA." << endl;
  781.             break;
  782.         }
  783.     } while (seleccion != 'D');
  784.  
  785.     cout << "\nFIN DEL PROGRAMA." << endl; // MUESTRA EN PANTALLA UN MENSAJE DE FIN
  786.  
  787.     getch();
  788.     return 0;
  789. }
  790.  
RAW Paste Data