Qué hacer para que mi programa vuelva al menú anterior y siga ejecutandose

[RGT]

Hola,
estoy haciendo un ejercicio de la universidad (explicado en los comentarios del programa) y me gustaría que el programa se repita. Por ejemplo, Presione 1 para volver al menú anterior y 0 para salir. Al volver al menú anterior, poder elegir otra opción y asi sucesivamente, manteniendo los valores de las variables ya que el punto del programa es ver los valores e ir jugando con ellas añadiendo y eliminando valores.

Aquí mi programa:

Código [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

/*
Tema V. Funciones

22. Escriba un programa en el cual haciendo uso de arreglos se puedan manipular conjuntos de números enteros donde se ofrezcan los siguientes servicios:

a)Insertar un elemento en el conjunto.
b)Eliminar un elemento  del conjunto.
c)Determinar si un elemento es miembro o no en el conjunto.
d)Unión de conjuntos.
e)Intersección de conjuntos.
*/

//Declaración de prototipos
void MostrarConjunto(int laiArreglo[], size_t TamanoArreglo);
void InsertarElemento(int liElemento, int laiArreglo[], size_t TamanoArreglo);
void EliminarElemento(int liElemento, int laiArreglo[], size_t TamanoArreglo);
void DeterminarExistencia(int liElemento, int laiArreglo[], size_t TamanoArreglo);

int main()
{
   //Declaración de variables
   int liOpcionMenu, laiArreglo[] = {5,8,2,3,1,4,6,9,7,10}, liElemento;

   //Entrada de datos
   printf("NOTA: Tama%co m%cximo del conjunto: %d\n", 164, 160, sizeof (laiArreglo) / sizeof (int));
   printf("\n----------MENU-----------------------------------------------------------------");
   printf("\n1. Insertar un elemento en el conjunto");
   printf("\n2. Eliminar un elemento del conjunto");
   printf("\n3. Determinar si un elemento es miembro o no en el conjunto");
   printf("\n4. Uni%cn de conjuntos", 162);
   printf("\n5. Intersecci%cn de conjuntos", 162);
   printf("\n-------------------------------------------------------------------------------");
   do
   {
       printf("\n=> ");
       scanf("%d", &liOpcionMenu);

       if (liOpcionMenu <= 0 || liOpcionMenu > 5)
           printf("\n\tError!, debe ingresar un valor de 1 a 5.\n");
   } while (liOpcionMenu <= 0 || liOpcionMenu > 5);

   //Procesamiento
   switch (liOpcionMenu)
   {
       case 1:
           system("cls");
           printf("1. Insertar un elemento en el conjunto");
           printf("\n--------------------------------------");
           printf("\nIngrese el elemento: ");
           scanf("%d", &liElemento);
           InsertarElemento(liElemento, laiArreglo, sizeof (laiArreglo) / sizeof (int));
           MostrarConjunto(laiArreglo, sizeof (laiArreglo) / sizeof (int));
           break;
       case 2:
           system("cls");
           printf("2. Eliminar un elemento del conjunto");
           printf("\n------------------------------------");
           printf("\nIngrese el elemento: ");
           scanf("%d", &liElemento);
           EliminarElemento(liElemento, laiArreglo, sizeof (laiArreglo) / sizeof (int));
           MostrarConjunto(laiArreglo, sizeof (laiArreglo) / sizeof (int));
           break;
       case 3:
           system("cls");
           printf("3. Determinar si un elemento es miembro o no en el conjunto");
           printf("\n-----------------------------------------------------------");
           printf("\nIngrese el elemento: ");
           scanf("%d", &liElemento);
           DeterminarExistencia(liElemento, laiArreglo, sizeof (laiArreglo) / sizeof (int));
           MostrarConjunto(laiArreglo, sizeof (laiArreglo) / sizeof (int));
           break;
       case 4:
           break;
       case 5:
           break;
   }

   //Salida de datos

   return 0;
}

void MostrarConjunto(int laiArreglo[], size_t TamanoArreglo)
{
   int liContador;

   printf("\nCONJUNTO: ");

   for (liContador = 0; liContador < TamanoArreglo; liContador++)
   {
       printf("%d", laiArreglo[liContador]);

       if (liContador < TamanoArreglo - 1)
           printf(", ");
   }

   printf("\n");
}

void InsertarElemento(int liElemento, int laiArreglo[], size_t TamanoArreglo)
{
   int liContador, liCondicionElse = 0;

   for (liContador = 0; liContador < TamanoArreglo; liContador++)
   {
       if (laiArreglo[liContador] == 0)
       {
           laiArreglo[liContador] = liElemento;
           printf("\n---------------------------------------------\n| Insertado correctamente de la posici%cn %d. |\n---------------------------------------------\n", 162, liContador + 1);
           liCondicionElse++;
           return;
       }
   }

   if (liCondicionElse == 0)
       printf("\n\tAviso!, todas las posiciones estan ocupadas.\n");
}

void EliminarElemento(int liElemento, int laiArreglo[], size_t TamanoArreglo)
{
   int liContador, liCondicionElse = 0;

   for (liContador = 0; liContador < TamanoArreglo; liContador++)
   {
       if (laiArreglo[liContador] == liElemento)
       {
           laiArreglo[liContador] = 0;
           printf("\n---------------------------------------------\n| Eliminado correctamente de la posici%cn %d. |\n---------------------------------------------\n", 162, liContador + 1);
           liCondicionElse++;
           return;
       }
   }

   if (liCondicionElse == 0)
       printf("\n\tAviso!, no existe ese elemento en el conjunto.\n");
}

void DeterminarExistencia(int liElemento, int laiArreglo[], size_t TamanoArreglo)
{
   int liContador, liCondicionElse = 0;

   for (liContador = 0; liContador < TamanoArreglo; liContador++)
   {
       if (laiArreglo[liContador] == liElemento)
       {
           printf("\n------------------------------------------\n| Elemento encontrado en la posici%cn %d. |\n------------------------------------------\n", 162, liContador + 1);
           liCondicionElse++;
           return;
       }
   }

   if (liCondicionElse == 0)
       printf("\n\tAviso!, no existe ese elemento en el conjunto.\n");
}


Pensé en un DO WHILE ó WHILE pero como el programa es tan largo, no sé si sería lo correcto, también pensé en poner el menú en una función y llamarlo en cada opción del menú, no tengo ni idea de qué sería lo mejor, nunca he hecho esto.

Espero que me ayuden, saludos a todos y gracias!.

[tremolero]

Hola RGT,

Yo normalmente cuando hago un menu como lo que tu quieres, suelo introducir todo dentro de un while, de tal manera que de ese while solo se sale cuando elijo la opcion salir y se terminaria el programa.

Creo que tambien se podria utilizar la opcion GOTO, de tal manera que lo rediriges a donde tu quieres...

es decir, pones el menu al final y cuando eligen otra opcion que no sea salir, lo rediriges con la opcion GOTO, pero creo que es mas correcto usar el while, ya que creo que el goto se usa cuando quieres redirigir y no tienes otra forma.

Piensa que normalmente el programa tiene un inicio y un fin, y lo que tu pretendes es que el programa no finalice asi que la unica forma es no permitiendolo hasta que no se cumpla una condicion.

Un saludo.

[RGT]

Hola,
entonces, pongo todo el codigo dentro de un while, luego deberia poner el menu en una funcion y llamar esa funcion en cada menu del switch, luego, preguntar al final de cada menu si desea regresar al menu anterior o no?, eso es todo?.

[RGT]

Hize unos cambios, creo que lo logré, me gustaría que lo probaran y me digan sus opiniones y qué cosas puedo mejorar.

Código [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>

/*
Tema V. Funciones

22. Escriba un programa en el cual haciendo uso de arreglos se puedan manipular conjuntos de números enteros donde se ofrezcan los siguientes servicios:

a)Insertar un elemento en el conjunto.
b)Eliminar un elemento  del conjunto.
c)Determinar si un elemento es miembro o no en el conjunto.
d)Unión de conjuntos.
e)Intersección de conjuntos.
*/

//Declaración de prototipos
int RepetirPrograma(void);
int MenuPrincipal(size_t TamanoArreglo);
void MostrarConjunto(int laiArreglo[], size_t TamanoArreglo);
void InsertarElemento(int liElemento, int laiArreglo[], size_t TamanoArreglo);
void EliminarElemento(int liElemento, int laiArreglo[], size_t TamanoArreglo);
void DeterminarExistencia(int liElemento, int laiArreglo[], size_t TamanoArreglo);

int main()
{
    //Declaración de variables
    int liRepetirPrograma,
        laiArreglo[] = {5,8,2,3,1,4,6,9,7,10}, liElemento;

    do
    {
        //Procesamiento
        switch (MenuPrincipal(sizeof (laiArreglo) / sizeof (int)))
        {
            case 1:
                system("cls");
                printf("1. Insertar un elemento en el conjunto");
                printf("\n--------------------------------------");
                printf("\nIngrese el elemento: ");
                scanf("%d", &liElemento);
                InsertarElemento(liElemento, laiArreglo, sizeof (laiArreglo) / sizeof (int));
                MostrarConjunto(laiArreglo, sizeof (laiArreglo) / sizeof (int));
                liRepetirPrograma = RepetirPrograma();
                break;
            case 2:
                system("cls");
                printf("2. Eliminar un elemento del conjunto");
                printf("\n------------------------------------");
                printf("\nIngrese el elemento: ");
                scanf("%d", &liElemento);
                EliminarElemento(liElemento, laiArreglo, sizeof (laiArreglo) / sizeof (int));
                MostrarConjunto(laiArreglo, sizeof (laiArreglo) / sizeof (int));
                liRepetirPrograma = RepetirPrograma();
                break;
            case 3:
                system("cls");
                printf("3. Determinar si un elemento es miembro o no en el conjunto");
                printf("\n-----------------------------------------------------------");
                printf("\nIngrese el elemento: ");
                scanf("%d", &liElemento);
                DeterminarExistencia(liElemento, laiArreglo, sizeof (laiArreglo) / sizeof (int));
                MostrarConjunto(laiArreglo, sizeof (laiArreglo) / sizeof (int));
                liRepetirPrograma = RepetirPrograma();
                break;
            case 4:
                break;
            case 5:
                break;
        }
    } while (liRepetirPrograma == 1);

    return 0;
}

int RepetirPrograma(void)
{
    int liRepetirPrograma;

    printf("-------------------------------------------------------------------------------\nPresione 1 para volver al men%c anterior...\n=> ", 163);
    scanf("%d", &liRepetirPrograma);

    return liRepetirPrograma;
}

int MenuPrincipal(size_t TamanoArreglo)
{
    system("cls");

    int liOpcionMenu;

    printf("NOTA: Tama%co m%cximo del conjunto: %d\n", 164, 160, TamanoArreglo);
    printf("\n----------MENU-----------------------------------------------------------------");
    printf("\n1. Insertar un elemento en el conjunto");
    printf("\n2. Eliminar un elemento del conjunto");
    printf("\n3. Determinar si un elemento es miembro o no en el conjunto");
    printf("\n4. Uni%cn de conjuntos", 162);
    printf("\n5. Intersecci%cn de conjuntos", 162);
    printf("\n-------------------------------------------------------------------------------");
    do
    {
        printf("\n=> ");
        scanf("%d", &liOpcionMenu);

        if (liOpcionMenu <= 0 || liOpcionMenu > 5)
            printf("\n\tError!, debe ingresar un valor de 1 a 5.\n");
    } while (liOpcionMenu <= 0 || liOpcionMenu > 5);

    return liOpcionMenu;
}

void MostrarConjunto(int laiArreglo[], size_t TamanoArreglo)
{
    int liContador;

    printf("\nCONJUNTO: ");

    for (liContador = 0; liContador < TamanoArreglo; liContador++)
    {
        printf("%d", laiArreglo[liContador]);

        if (liContador < TamanoArreglo - 1)
            printf(", ");
    }

    printf("\n");
}

void InsertarElemento(int liElemento, int laiArreglo[], size_t TamanoArreglo)
{
    int liContador, liCondicionElse = 0;

    for (liContador = 0; liContador < TamanoArreglo; liContador++)
    {
        if (laiArreglo[liContador] == 0)
        {
            laiArreglo[liContador] = liElemento;
            printf("\n---------------------------------------------\n| Insertado correctamente de la posici%cn %d. |\n---------------------------------------------\n", 162, liContador + 1);
            liCondicionElse++;
            return;
        }
    }

    if (liCondicionElse == 0)
        printf("\n\tAviso!, todas las posiciones estan ocupadas.\n");
}

void EliminarElemento(int liElemento, int laiArreglo[], size_t TamanoArreglo)
{
    int liContador, liCondicionElse = 0;

    for (liContador = 0; liContador < TamanoArreglo; liContador++)
    {
        if (laiArreglo[liContador] == liElemento)
        {
            laiArreglo[liContador] = 0;
            printf("\n---------------------------------------------\n| Eliminado correctamente de la posici%cn %d. |\n---------------------------------------------\n", 162, liContador + 1);
            liCondicionElse++;
            return;
        }
    }

    if (liCondicionElse == 0)
        printf("\n\tAviso!, no existe ese elemento en el conjunto.\n");
}

void DeterminarExistencia(int liElemento, int laiArreglo[], size_t TamanoArreglo)
{
    int liContador, liCondicionElse = 0;

    for (liContador = 0; liContador < TamanoArreglo; liContador++)
    {
        if (laiArreglo[liContador] == liElemento)
        {
            printf("\n------------------------------------------\n| Elemento encontrado en la posici%cn %d. |\n------------------------------------------\n", 162, liContador + 1);
            liCondicionElse++;
            return;
        }
    }

    if (liCondicionElse == 0)
        printf("\n\tAviso!, no existe ese elemento en el conjunto.\n");
}


[tremolero]

A mi no me convencen mucho el metodo que has utilizado para el menu.

A ver te explico a mi forma de ver como funciona el que tu has hecho(No lo he probado asi que podria haber leido mal algo.)

-Tu programa se ejecuta.
-muestra el menu(1.-instertar,2.-eliminar,3.-,4.-,5.-)
-entras en la opcion elegida, la ejecutas, el usuario hace lo correspondiente.
- y al terminar indicas que pulse uno para volver al menu anterior de lo contrario se cierra el programa.

eso es lo que he entendido mirandolo por encima...

Yo de normal, nose si es lo mas correcto, lo que hago es en el menu, añado una opcion final que es salir/exit.

Por lo que la comprobacion de si quieres volver, yo me la salto y le devuelvo directamente al menu y el ahi decide si quieres otra opcion o directamente salir.

A mi forma de ver, se hace molesto que te pregunte constantemete si quieres volver, creo que es mejor enviarle al menu y que desde ahi decida bajo su criterio que prefiere.

Un saludo.

[RGT]

Hola,
entiendo tu punto de vista pero, si lo envio al menu automaticamente, el usuario no podra ver el resultado de la accion que hizo.

Supongamos que eligio la opcion 1 (añadir elemento), el ingresa el numero 5, luego lo envia al menu y ya?, o sea, no podra ver su numero agregado en el arreglo.

Entiendes?....
no sé si estoy mal......

[NOIS]

Puedes añadir algo como cin.get(); para esperar una pulsación del teclado antes de continuar y volver al menú, así el usuario podrá ver lo que tenga que ver.

[RGT]

Ya veo.
Pero, independientemente de todo eso, esta bien hecho el método de hacer que el programa se repita?, hize algo mal o esta todo bien?.

[Josuex24]

Código (cpp) [Seleccionar] Expandir

Amigo, te hace falta trabajar mas de manera modular, lo unico que debes hacer es crear en la declaracion de prototipos otra funcion y la trabajes de la misma manera que utilizas el int main.

Ejemplo.

int Menu();
int Menu2();
void FMenu2();

int main()
{
 int opc=1;
   while (opc!=0)
   {
      opc=Menu();
        switch(opc)
           {
             case 1: FMenu2();
           }
   }  return 0;
}

int Menu()
{
 opc;
   cout<<"1. Otra opcion\n"
          <<"0. Salir";
   cin>>opc;
return opc;
}


//*Esta funcion cumplirá la misma funcion del int main*//

void FMenu2()
{
 int opc;
   int opc;
   while (opc!=0)
   {
      opc=Menu2();
        switch(opc)
           {
             case....
           }
   }
}


int Menu2()
{
 opc;
   cout<<"Este es el segundo menu\n"
         <<"Pulse 0 para regresar\n";
   cin>>opc;
return opc;
}

Algo mas o menos asi, espero hayas entendido, saludos.