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

 
/*
 
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

#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)

#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.

Ahora solo falta ponerle una chincheta al tema 

Para eso estan los privados 

do-while: con compilacion condicional podes hacerlo.

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:

#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!

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:

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

 /* 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  :

#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...

/*
* 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!