Para que dejeis de preguntar de una vez por los menus

[do-while]

MODIFICADO

Añadido:
----------
- portabilidad
- texto centrado


Ya se que todo el codigo que viene a continuacion es una morcilla de las de Burgos, pero si mirais el ejemplo que hay al final, vereis como se simplifica todo a la hora de utilizar los menus.

Menu.h

Código (c) [Seleccionar] Expandir



/*

IMPORTANTE: Cuando el menu ya no sea util, ultilizar siempre la funcion finalizarMenu

*/

#ifndef MENU_H
#define MENU_H

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

/*
* Para compilar en UNIX desactivar la definicion de WINDOWS y activar la de UNIX
* Para otros SO desactivar ambas.
*/

#ifndef WINDOWS
   #define WINDOWS
#endif
/*
#ifndef UNIX
   #define UNIX
#endif
*/

#define MENU_OK                   0L
#define MENU_ERROR                1L
#define MENU_MEMORIA_INSUFICIENTE 2L

#define MENU_MODO_NORMAL      0L
#define MENU_MODO_ULTIMA_CERO 1L

struct Menu
{
   char*         titulo;
   char*         texto;
   char**        opciones;
   int           numOpciones; /* numero de opciones */
   int           maxlen;
   unsigned long lFlags;
};
typedef struct Menu Menu;

void inicializarMenu(Menu* menu,char* titulo, char* texto, char* opciones[]);
int mostrarMenu(Menu* menu,int modo);
void finalizarMenu(Menu* menu);

#endif /* MENU_H */


menu.c

Código (c) [Seleccionar] Expandir


#include "menu.h"

void inicializarMenu(Menu* menu, char* titulo, char* texto, char* opciones[])
{
  menu->lFlags = MENU_OK;

  if(titulo == NULL)
     menu->titulo = NULL;
  else
  {
      if((menu->titulo = (char*) malloc(strlen(titulo) * sizeof(char) + 1)))
          strcpy(menu->titulo,titulo);
     else
     {
        menu->lFlags |= MENU_ERROR | MENU_MEMORIA_INSUFICIENTE;
        menu->texto = NULL;
     }
  }

  if(texto == NULL)
     menu->texto = NULL;
  else
  {
     if((menu->texto = (char*) malloc(strlen(texto) * sizeof(char) + 1)))
        strcpy(menu->texto,texto);
     else
     {
        menu->lFlags |= MENU_ERROR | MENU_MEMORIA_INSUFICIENTE;
        menu->texto = NULL;

         if(menu->titulo)
         {
            free(menu->titulo);
            menu->titulo = NULL;
         }
     }
  }

  if(opciones == NULL)
     menu->opciones = NULL;
  else
  {
     menu->numOpciones = -1;

     while(opciones[ ++(menu->numOpciones) ][0]);

     if((menu->opciones = (char**) malloc(menu->numOpciones * sizeof(char*))))
     {
        int i=0;

        menu->maxlen = 0;

        for(i=0 ; i < menu->numOpciones ; i++)
        {
           if
           (
              (menu->opciones[i] =
              (char*) malloc(strlen(opciones[i]) * sizeof(char) + 1))
           )
           {
              strcpy(menu->opciones[i],opciones[i]);

              if(strlen(menu->opciones[i]) > menu->maxlen)
                 menu->maxlen = strlen(menu->opciones[i]);
           }
           else
           {
              int j;

              for(j=0 ; j<i ; j++)
                 free(menu->opciones[j]);

              free(menu->opciones);

              menu->opciones = NULL;
              menu->numOpciones = 0;

              if(menu->texto)
              {
                 free(menu->texto);
                 menu->texto = NULL;
              }

              if(menu->titulo)
              {
                 free(menu->titulo);
                 menu->titulo = NULL;
              }

              menu->lFlags |= MENU_ERROR | MENU_MEMORIA_INSUFICIENTE;
           }
        }
     }
     else
     {
        menu->lFlags |= MENU_ERROR | MENU_MEMORIA_INSUFICIENTE;
        menu->opciones = NULL;

        if(menu->texto)
        {
           free(menu->texto);
           menu->texto = NULL;
        }

        if(menu->titulo)
        {
           free(menu->titulo);
           menu->titulo = NULL;
        }
     }
  }
}

int mostrarMenu(Menu* menu,int modo)
{
  int i=0, opcion=0;

  if(menu->numOpciones)
  {
      do{

         #ifdef WINDOWS
            system("CLS");
         #elif defined UNIX
            system("clear");
         #endif

         if(menu->titulo)
         {
            for(i=0 ; i<80 ; i++)
                printf("=");

            printf("%*s\n", 40 + strlen(menu->titulo) / 2, , menu->titulo);

            for(i=0 ; i<80 ; i++)
                printf("=");
         }

         if(menu->texto)
             printf("%-*s%s\n\n",40 - menu->maxlen / 2 - 8, " ", menu->texto);
             
         for(i=0 ; i < menu->numOpciones ; i++)
         {
            if(modo == MENU_MODO_ULTIMA_CERO && i == menu->numOpciones - 1)
            {
               if(menu->numOpciones > 10)
                  printf("%*s 0. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", 40 + menu->maxlen / 2,
                                           menu->opciones[i]);
               else
                  printf("%*s0. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", 40 + menu->maxlen / 2,
                                          menu->opciones[i]);
            }
            else
            {
               if(modo != MENU_MODO_ULTIMA_CERO)
               {
                  if(menu->numOpciones >= 10)
                  {
                     printf("%*s%2d. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", i+1,
                                               40 + menu->maxlen / 2, menu->opciones[i]);
                  }
                  else
                  {
                     printf("%*s%d. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", i+1,
                                              40 + menu->maxlen / 2, menu->opciones[i]);
                  }
               }
               else
               {
                  if(menu->numOpciones > 10)
                  {
                     printf("%*s%2d. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", i+1,
                                               40 + menu->maxlen / 2, menu->opciones[i]);
                  }
                  else
                  {
                     printf("%*s%d. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", i+1,
                                              40 + menu->maxlen / 2, menu->opciones[i]);
                  }
               }
            }
         }
         printf("%-*s>", 40 - menu->maxlen / 2 - 8, " ");

        if(!scanf("%d", &opcion))
        {
           while(getchar() != '\n');
           scanf("%d", &opcion);
        }        

      }while
      (
         (
            (modo != MENU_MODO_ULTIMA_CERO) ? (opcion < 1) : (opcion < 0)
         )
         ||
         (
            (modo != MENU_MODO_ULTIMA_CERO) ?
               (opcion >  menu->numOpciones)
               :
               (opcion >= menu->numOpciones)
         )
      );

      return opcion;
  }
 
  return -1;
}

void finalizarMenu(Menu* menu)
{
  if(menu->texto)
  {
     free(menu->texto);
     menu->texto = NULL;
  }

  if(menu->opciones)
  {
      int i=0;

      for(i=0 ; i < menu->numOpciones ; i++)
      {
          if(menu->opciones[i])
          {
              free(menu->opciones[i]);
              menu->opciones[i] = NULL;
          }
      }
      free(menu->opciones);
      menu->opciones = NULL;
  }

  menu->numOpciones = 0;
}


ejemplo: (tener en cuenta que menu.h y menu.c tienen que estar en el mismo directorio donde este el fichero con la funcion principal)

Código (c) [Seleccionar] Expandir


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

#include "menu.h"
#include "menu.c" /* solo si no se va crear un proyecto*/

int main(int argc, char *argv[])
{
   Menu menu;
   char *opciones[] = {"Continuar","Salir",""}; /* la ultima opcion siempre es una cadena vacia*/
   int opcion;

   inicializarMenu(&menu,"MENU DE PRUEBA","Escoger una opcion:",opciones);

   do{
       opcion=mostrarMenu(&menu,MENU_MODO_ULTIMA_CERO);
       
       switch(opcion)
       {
           case 1:
               printf("Has escogido continuar.\n");
               break;
           case 0:
               printf("Has escogido salir.\n");
               break;
       }
   }while(opcion!=0);

   /* ¡¡¡¡¡IMPORTANTE!!!!! */
   finalizarMenu(&menu);

   return 0;
}


En lo que es el menu, me gustaria completar alguna opcion mas, pero el codigo ya es funcional.

Si el codigo no funciona, avisad, ya que es una adaptacion del codigo que realmente tengo guardado. Lo he puesto asi para evitar incluir mas headers y mas codigo.

El codigo de ejemplo lo he imprivosado sobre la marcha. Si hubiese algun error revisad el codigo, que no creo que haya darle muchas vueltas.

[Littlehorse]

Esta bastante bien el codigo, como consejo te diria que en vez de pensar en sumarle opciones le mejores la portabilidad. No tiene sentido que sea exclusivo de Windows solamente por system y fflush  .

Un saludo!

[^Winder^]

Ahora solo falta ponerle una chincheta al tema 

[do-while]

Jajajaja!

Lo de la portabilidad ya lo estaba pensando, al codigo ya tiene algunos mesecillos y ultimamente he estado pensando en la portabilidad.

Lo de system("PAUSE"), tiene facil solucion, para lo del fflush(stdin) ya tengo una alternativa y una solucion, pero lo de limpiar la pantalla... me parece que no hay ningun equivalente estandar para limpiarla, ¿no?

Le hecho un vistazo y a ver que sale.

¡Hasta luego!

[Eternal Idol]

Ahora solo falta ponerle una chincheta al tema 

Para eso estan los privados 

do-while: con compilacion condicional podes hacerlo.

[do-while]

bueno, ya estan los cambios, he incluido un header y un fichero fuente mas, porque ahi esta la funcion que evita el fflush(stdin) antes de la lectura de un dato entero. (a parte creo que tambien hay funciones que pueden resultar utiles...) Tambien he eliminado las llamadas a system, ahora no queda tan bonito, pero esportable.

EI, si quieres completar el codigo con la compilacion condicional... yo desconozco las ordenes equivalentes en otros systemas operativos, asi que sirectamente evito utilizarlas, y tampoco he utilizado la compilacion condicional mas que para comprobar errores con printf's para ver los valores de las variables.

Asi contribuimos a mejorar el codigo un poco entre todos.

¡Hasta luego!

He eliminado los dos ficheros añadidos. (por una sola funcion era meter demasiado codigo que no venia a cuento)

Ultima modificacion:

Código (c) [Seleccionar] Expandir


#ifdef WINDOWS
  system("CLS");
#elif defined UNIX
  system("clear");
#endif


¿Es correcto?

Para los mac's y otros sistemas operativos no conozco analogos, pero sigo buscando.

[Littlehorse]

Si, asi es correcto. Podes usar un else para luego poner el codigo para MAC.
clear podria funcionar pero de seguro trae problemas por el tema de la consola.

Yo dejaria el codigo asi para mantenerlo limpio. Eso si, las llamadas a system no me gustan para nada, pero si lo queres estandar solo puedes codificar tus propias funciones, y de seguro agregas codigo que tal vez sea innecesario.
Evitar la compilacion condicional de seguro es complicado si queres una funcion estandar para limpiar la pantalla.

Me refiero a algo asi con el tema de la pausa:

Código (c) [Seleccionar] Expandir

#include <stdio.h>
#define PAUSE printf("Presiona una tecla..."); fgetc(stdin);

int main()
{
 PAUSE
 return 0;
}  

Esto lo digo como detalle, como ya dije, para tareas como esa llamar a system no es un problema importante.    

Un saludo!

[do-while]

Ok. Pues, de momento asi lo dejo. Ahora me queda algun detalle sobre la presentacion (alineacion delos textos) y pulir los flags, que los puse a ultima hora.

Hasta luego!

Bueno, creo que mas o menos ya esta. Si hay alguna idea, bienvenida sea.

Hasta luego!

EI: juntando mensajes.

¡Hola a todos!

Despues de la ultima modificacion, la funcion mostrarMenu, producia un error en tiempo de ejecucion, devido a un error que cometi. Ya esta corregido, y el codigo es funcional.

¡Hasta luego!

[D4RIO]

Hola, de vuelta al foro (por ahora que estoy de vacaciones aunque sea) y un intento de cooperación un mes después del ultimo comentario, espero que valga, a ver:

Respecto a la función de limpiar la pantalla:

En un entorno Windows:

To accomplish this task for a Win32 console application, use one of the following methods:
- Use a system function.
- Write a function that will programmatically clear the screen.

La primera seria un system("cls"), que es lo que usa ahora, y la segunda opción:

Código (cpp) [Seleccionar] Expandir

/* Standard error macro for reporting API errors */
#define PERR(bSuccess, api){if(!(bSuccess)) printf("%s:Error %d from %s on line %d\n", __FILE__, GetLastError(), api, __LINE__);}

void cls( HANDLE hConsole )
{
    COORD coordScreen = { 0, 0 };    /* here's where we'll home the
                                        cursor */
    BOOL bSuccess;
    DWORD cCharsWritten;
    CONSOLE_SCREEN_BUFFER_INFO csbi; /* to get buffer info */
    DWORD dwConSize;                 /* number of character cells in
                                        the current buffer */

    /* get the number of character cells in the current buffer */

    bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
    PERR( bSuccess, "GetConsoleScreenBufferInfo" );
    dwConSize = csbi.dwSize.X * csbi.dwSize.Y;

    /* fill the entire screen with blanks */

    bSuccess = FillConsoleOutputCharacter( hConsole, (TCHAR) ' ',
       dwConSize, coordScreen, &cCharsWritten );
    PERR( bSuccess, "FillConsoleOutputCharacter" );

    /* get the current text attribute */

    bSuccess = GetConsoleScreenBufferInfo( hConsole, &csbi );
    PERR( bSuccess, "ConsoleScreenBufferInfo" );

    /* now set the buffer's attributes accordingly */

    bSuccess = FillConsoleOutputAttribute( hConsole, csbi.wAttributes,
       dwConSize, coordScreen, &cCharsWritten );
    PERR( bSuccess, "FillConsoleOutputAttribute" );

    /* put the cursor at (0, 0) */

    bSuccess = SetConsoleCursorPosition( hConsole, coordScreen );
    PERR( bSuccess, "SetConsoleCursorPosition" );
    return;
}

Fuente: http://support.microsoft.com/kb/99261

... también vi por ahi implementaciónes en inline ASM con llamadas de DOS, pero no las encuentro ahora.


Ahora bien, falta la implementación UNIX, que resulta ser un poco más... amena  :

Código (c) [Seleccionar] Expandir

#include <stdio.h>

int
main(void)
{
printf("\033[H\033[J"); // Esto es to, esto es todo amigos
return 0;
}
Fuentes:
  http://www.programmersheaven.com/mb/beginnercpp/137205/137377/re-clear--screen/
  http://homepages.cwi.nl/~tromp/tetris.html
  http://196.1.111.155/download_util/download/MODIFY07.txt?id=uniqueid
  http://okmij.org/ftp/packages/tournament-sched.c
  http://www.geekinterview.com/question_details/16718
  ...
  Y demás fuentes gratuitos que obtuve por ahi, en fin, el hecho es que funciona Ok, y debería funcionar Ok en cualquier terminal UNIX que use secuencias de Escape (desde LINUX, por los BSDes, AIX... bla bla bla)



Ahora bien, otro tema es que esta parte del code...

Código (c) [Seleccionar] Expandir

/*
* Para compilar en UNIX desactivar la definicion de WINDOWS y activar la de UNIX
* Para otros SO desactivar ambas.
*/

#ifndef WINDOWS
    #define WINDOWS
#endif
/*
#ifndef UNIX
    #define UNIX
#endif
*/

...resulta bastante "sucia" por así llamarle (y con todo respeto), ya que existen macros dadas para cada sistema (ver fuente http://msdn.microsoft.com/en-us/library/b0084kay.aspx), con lo que puedes usar _WIN32 y _WIN64 para definir un Windows, y cualquier otro sistema usara la secuencia de escape (si sale un Bug por ahi se solucionará, pero esa secuencia debe funcionar hasta en un BeOS)


Espero haber aportado suficiente

Un saludo Gente, Feliz 2010

@EI, rato que no me pasaba por aqui, un saludo!

[.;.]

Ahora ya si que anda perfecto .