Tabla de fichas Indice del Tema 1006
1001 1002 1003 1004 1005 1006 1007 1008

Ejercicios Resueltos







Una base de datos sencilla
utiles.h
#include<stdio.h>


#ifndef __UTILES__
        #define __UTILES__
        
        char * sgets(void);
        void spause(void);
        int confirmar(char * indicacion);
        char * pedir(const char * indicacion);
        
        #ifdef __ISDEVC__
        
                #define BORRAR "cls"
                int strcasecmp(const char * big, const char * little);
        
        #else
        
                #define BORRAR "clear"
                #include<termios.h>
                char getch(void);
        
        #endif

#endif
utiles.c
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
#include "utiles.h"


/*
    sgets() has different implementations in Unix and elsewhere,
    hence our first step is to determine just what the
    underlying OS is
*/

#ifdef __ISDEVC__
/*
    This is not Unix, hence no fgetln() and sgets()
    is somewhat less safe. We hope the user
    will not input more than 1024 characteres at a time.
*/
char * sgets(void)
{
    int MAXCHARS = 1024;
    char * temp = (char *)malloc(MAXCHARS);
    char * resultado;
    fgets(temp,MAXCHARS,stdin);
    resultado = (char *)malloc(strlen(temp));
    strcpy(resultado, temp);
    resultado[strlen(resultado)-1] = '\0';
    free(temp);
    return resultado;
}

/*
    strcasecmp() is not defined, hence we
    try to produce a reasonable facsimile
*/

int strcasecmp(const char * big, const char * little)
{
        int i,n;
        char * _big = (char *)malloc(sizeof(char)*(strlen(big)+1));
        char * _little = (char *)malloc(sizeof(char)*(strlen(little)+1));
        int result;
        /*
                Store the original values
        */
        strcpy(_big, big);
        strcpy(_little,little);
        /*
                Translate into lowercase both _big and _little
        */
        n = strlen(_big);
        for(i=0;i<n;i++)
                _big[i] = tolower(_big[i]);
        n = strlen(_little);
        for(i=0;i<n;i++)
                _little[i] = tolower(_little[i]);
        /*
                Find out whether little and big are equal
                after translating into lowercase
        */
        result = strcmp(_big,_little);
        /*
                No leaks!
        */
        free(_big);
        free(_little);
        /*
                And tell what happened
        */
        return result;
}
#else
/*
    This is Unix, hence fgetln() is available but getch() is not.
    We produce a reasonable implementation of sgets() and
    of getch()
*/
char * sgets(void)
{
        char * puntero_linea;
        size_t longitud_linea;
        char * resultado;
        puntero_linea = fgetln(stdin, &longitud_linea);
        resultado = (char *)malloc(longitud_linea+2);
        memcpy(resultado,puntero_linea,longitud_linea);
        resultado[longitud_linea-1] = '\0';
        return resultado;
}


char getch(void) {
    struct termios conf_vieja, conf_nueva;
    char c;
    tcgetattr(0,&conf_vieja);
    conf_nueva = conf_vieja;
    conf_nueva.c_lflag &= (~ICANON);
    conf_nueva.c_cc[VTIME] = 0;

    conf_nueva.c_cc[VMIN] = 1;
    tcsetattr(0,TCSANOW,&conf_nueva);
    c = getchar();
    tcsetattr(0,TCSANOW,&conf_vieja);
    return c;
}

#endif
/*
    Once we have sgets() and getch() at our disposal, we build
    further useful functions like pedir (ask) and confirmar
    (confirm). All these functions are shared between platforms.
*/
char * pedir(const char * indicacion)
{
        char * resultado;
        printf("%s ", indicacion);
        resultado = sgets();
        return resultado;
}

void spause(void)
{
        char * temp;
        printf("\n\nPulse <INTRO> para continuar\n\n");
        temp = sgets();
        free(temp);
        return;
}

int confirmar(char * indicacion)
{
        char * respuesta;
        printf("%s (s/n): ", indicacion);
        respuesta = sgets();
        return toupper(respuesta[0]) == 'S';
}



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


#ifndef __PROGRAMAPRINCIPAL__
#define __PROGRAMAPRINCIPAL__

#include        "utiles.h"

#define MAX_REGISTROS 10

struct Registro {
	char nombre[20];
	int edad;
	float talla;
};

typedef struct Global {
        struct Registro bdd[MAX_REGISTROS];
} Global;

typedef void (*pfuncion)(Global *);

void dispatcher( char * pm, char * ov[], struct Global * pg, pfuncion pf[]);
void iniciacion(Global * pg, int argc, char * argv[]);
void terminacion(Global * pg);
void ayuda(Global * pg);

void altas(Global * pg);
void bajas(Global * pg);
void modificaciones(Global * pg);
void informes(Global * pg);
void salir(Global * pg);

void mostrar(struct Registro * p);
void rellenar(struct Registro * p);
#endif
main.c
#include "main.h"

/****************************************************************/
int main(int argc, char * argv[])
{
  Global * pg = (Global *)malloc(sizeof(Global));
  
  char menu[] = "A)ltas B)ajas M)odificaciones I)nformes H)Ayuda S)alir";
  char * opcionesvalidas[] = {
                "A", /* Ojo: el orden de opciones tiene que  */
                "B", /*    ser igual al orden de funciones */
                "M",
                "I",
                "H",
                "S"
               };
pfuncion pfun[] = {
            &altas, /* Ojo: el orden de funciones tiene que ser */
            &bajas, /*   igual al orden de opciones      */
            &modificaciones,
            &informes,
            &ayuda,
            &salir,
            NULL /* Marcador de fin de lista al estilo de las cadenas */
           };
/*
        Las opciones válidas pueden ser tanto caracteres individuales
        como palabras completas.
*/

  iniciacion(pg, argc, argv);
  dispatcher( menu,
        opcionesvalidas,
        pg,
        pfun);
  terminacion(pg);
  puts("\n\nThat's all folks!\n");
  return 0;
}

/****************************************************************/
void mostrar(struct Registro * p)
{
	printf("%20s %4d %6.2f\n",
					p->nombre,
					p->edad,
					p->talla);
}

void rellenar(struct Registro * p)
{
	char * n;
	do
		{
			printf("\nEscriba el nombre: ");
			n = sgets();
			strcpy(p->nombre, n);
			free(n); /* No hay fuga de memoria */
		} while (0 == strlen(p->nombre));
	do
		{
			printf("\nEscriba la edad: ");
			n = sgets();
			p->edad = strtol(n, NULL, 10);
			free(n);
		} while (p->edad <1 || p->edad >100);
	do
		{
			printf("\nEscriba la talla (cm): ");
			n = sgets();
			p->talla = strtof(n, NULL);
			free(n);
		} while (p->talla <=100.0 || p->talla >=230);
}
void iniciacion(Global * pg, int argc, char * argv[])
{
  int i;
  for(i=0;i<MAX_REGISTROS;i++)
  	{
  		strcpy(pg->bdd[i].nombre,"");
  		pg->bdd[i].edad = 0;
  		pg->bdd[i].talla = 0.0;
  	}
}
void altas(Global * pg)
{
	int i,n;
	n = -1;
	printf("\n\nAltas\n\n");
	for(i=0;i<MAX_REGISTROS;i++)
		if (0 == pg->bdd[i].edad)
			{
				n = i;
				break;
			}
	if(-1 != n)
		rellenar(&(pg->bdd[n]));
	else
		printf("Base de datos llena!%c\n", 7);
 spause();
}
void bajas(Global * pg)
{
 int i,n;
 char * s;
 for(i=0;i<MAX_REGISTROS; i++)
 	{
 		if (0 != pg->bdd[i].edad)
 			{
 				mostrar(&(pg->bdd[i]));
 			}
 	}
 printf("\nEscriba el índice del registro que desea eliminar: ");
 s = sgets();
 n = strtol(s, NULL, 10);
 free(s);
 pg->bdd[n].edad = 0;
 spause();
}
void modificaciones(Global * pg)
{
 int i,n;
 char * s;
 for(i=0;i<MAX_REGISTROS; i++)
 	if (0 != pg->bdd[i].edad)
 		mostrar(&(pg->bdd[i]));
 printf("\nModificaciones\n\nEscriba el índice del registro que desea modificar: ");
 s = sgets();
 n = strtol(s, NULL, 10);
 free(s); /* no hay fuga */
 rellenar(&(pg->bdd[n]));
 spause();
}
void informes(Global * pg)
{
	int i,n;
	char * s;
	printf("\nInformes\n\nEscriba la edad que desea buscar: ");
	s = sgets();
	n = strtol(s, NULL, 10);
	free(s); /* No hay fuga */
	printf("\nLista de registros hallados\n\n");
	for(i=0;i<MAX_REGISTROS; i++)
		{
			if (n == pg->bdd[i].edad)
				{
					mostrar(&(pg->bdd[i]));
				}
		}
	printf("\n\nFin de la lista de registros hallados\n\n");
	spause();
}

void ayuda(Global * pg)
{
 printf("\n\nAyuda\n\n");
 spause();
}
void terminacion(Global * pg)
{
  int i;
  puts("\nEl contenido de la base de datos es:\n\n");
  for(i=0;i<MAX_REGISTROS;i++)
  	mostrar(&(pg->bdd[i]));
  printf("\n\nFin del listado\n\n");
}
/****************************************************************/

void dispatcher( char * pm, char * ov[], Global * pg, pfuncion pf[])
{
  char * temp = NULL;     /* Para leer la instrucción */
  int instruccion;           /* dada por el usuario                      */
  int num_opciones = 0;
  int i;
  
  /* Recuento de opciones */
  while(pf[num_opciones] != NULL) num_opciones++;
 
  /* Bucle principal de ejecución */
  do
   {
      printf("%s ", pm);
      temp = sgets();
      
      instruccion = -1;
      for(i=0;i<num_opciones;i++)
            if(0==strcasecmp(ov[i],temp))
                  {
                      instruccion = i;
                      break;
                  }
 
      system(BORRAR);
      
      if (-1 != instruccion)
        pf[instruccion](pg);
      else
        printf("%c", 7);
        
  
      free(temp); /* Se libera la memoria reservada por sgets() */
   } while (&salir != pf[instruccion]);
  
} /* Fin de dispatcher() */

/****************************************************************/

void salir(struct Global * pg)
{
 return;
}


makefile
OBJECTS = main.o utiles.o
CC = gcc
#FLAGS = -D__ISWINDOWS__
FLAGS = -D__ISUNIX__

program: $(OBJECTS)
	$(CC) $(FLAGS) $(OBJECTS) -o program

utiles.o: utiles.c utiles.h
	$(CC) $(FLAGS) -c utiles.c -o utiles.o

main.o: main.c utiles.h main.h
	$(CC) $(FLAGS) -c main.c

clean:
	rm *.o
	rm program

windows_clean:
	del *.o
	del program.exe



Una base de datos con soporte en un archivo binario
utiles.h
#include<stdio.h>


#ifndef __UTILES__
        #define __UTILES__
        
        char * sgets(void);
        void spause(void);
        int confirmar(char * indicacion);
        char * pedir(const char * indicacion);
        
        #ifdef __ISDEVC__
        
                #define BORRAR "cls"
                int strcasecmp(const char * big, const char * little);
        
        #else
        
                #define BORRAR "clear"
                #include<termios.h>
                char getch(void);
        
        #endif

#endif

utiles.c
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
#include "utiles.h"


/*
    sgets() has different implementations in Unix and elsewhere,
    hence our first step is to determine just what the
    underlying OS is
*/

#ifdef __ISDEVC__
/*
    This is not Unix, hence no fgetln() and sgets()
    is somewhat less safe. We hope the user
    will not input more than 1024 characteres at a time.
*/
char * sgets(void)
{
    int MAXCHARS = 1024;
    char * temp = (char *)malloc(MAXCHARS);
    char * resultado;
    fgets(temp,MAXCHARS,stdin);
    resultado = (char *)malloc(strlen(temp));
    strcpy(resultado, temp);
    resultado[strlen(resultado)-1] = '\0';
    free(temp);
    return resultado;
}

/*
    strcasecmp() is not defined, hence we
    try to produce a reasonable facsimile
*/

int strcasecmp(const char * big, const char * little)
{
        int i,n;
        char * _big = (char *)malloc(sizeof(char)*(strlen(big)+1));
        char * _little = (char *)malloc(sizeof(char)*(strlen(little)+1));
        int result;
        /*
                Store the original values
        */
        strcpy(_big, big);
        strcpy(_little,little);
        /*
                Translate into lowercase both _big and _little
        */
        n = strlen(_big);
        for(i=0;i<n;i++)
                _big[i] = tolower(_big[i]);
        n = strlen(_little);
        for(i=0;i<n;i++)
                _little[i] = tolower(_little[i]);
        /*
                Find out whether little and big are equal
                after translating into lowercase
        */
        result = strcmp(_big,_little);
        /*
                No leaks!
        */
        free(_big);
        free(_little);
        /*
                And tell what happened
        */
        return result;
}
#else
/*
    This is Unix, hence fgetln() is available but getch() is not.
    We produce a reasonable implementation of sgets() and
    of getch()
*/
char * sgets(void)
{
        char * puntero_linea;
        size_t longitud_linea;
        char * resultado;
        puntero_linea = fgetln(stdin, &longitud_linea);
        resultado = (char *)malloc(longitud_linea+2);
        memcpy(resultado,puntero_linea,longitud_linea);
        resultado[longitud_linea-1] = '\0';
        return resultado;
}


char getch(void) {
    struct termios conf_vieja, conf_nueva;
    char c;
    tcgetattr(0,&conf_vieja);
    conf_nueva = conf_vieja;
    conf_nueva.c_lflag &= (~ICANON);
    conf_nueva.c_cc[VTIME] = 0;

    conf_nueva.c_cc[VMIN] = 1;
    tcsetattr(0,TCSANOW,&conf_nueva);
    c = getchar();
    tcsetattr(0,TCSANOW,&conf_vieja);
    return c;
}

#endif
/*
    Once we have sgets() and getch() at our disposal, we build
    further useful functions like pedir (ask) and confirmar
    (confirm). All these functions are shared between platforms.
*/
char * pedir(const char * indicacion)
{
        char * resultado;
        printf("%s ", indicacion);
        resultado = sgets();
        return resultado;
}

void spause(void)
{
        char * temp;
        printf("\n\nPulse <INTRO> para continuar\n\n");
        temp = sgets();
        free(temp);
        return;
}

int confirmar(char * indicacion)
{
        char * respuesta;
        printf("%s (s/n): ", indicacion);
        respuesta = sgets();
        return toupper(respuesta[0]) == 'S';
}



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


#ifndef __PROGRAMAPRINCIPAL__
#define __PROGRAMAPRINCIPAL__

#include        "utiles.h"

#define MAX_REGISTROS 10000

struct Registro {
	char nombre[20];
	int edad;
	float talla;
};

typedef struct Global {
        struct Registro bdd[MAX_REGISTROS];
} Global;

typedef void (*pfuncion)(Global *);

void dispatcher( char * pm, char * ov[], struct Global * pg, pfuncion pf[]);
void iniciacion(Global * pg, int argc, char * argv[]);
void terminacion(Global * pg);
void ayuda(Global * pg);

void altas(Global * pg);
void bajas(Global * pg);
void modificaciones(Global * pg);
void informes(Global * pg);
void salir(Global * pg);

void mostrar(struct Registro * p);
void rellenar(struct Registro * p);

void abrir(Global * p);
void guardar(Global * p);
#endif
main.c
#include "main.h"

/****************************************************************/
int main(int argc, char * argv[])
{
  Global * pg = (Global *)malloc(sizeof(Global));
  
  char menu[] = "O)Abrir G)uardar A)ltas B)ajas M)odificaciones I)nformes H)Ayuda S)alir";
  char * opcionesvalidas[] = {
  							"O",
  							"G",
                "A", /* Ojo: el orden de opciones tiene que  */
                "B", /*    ser igual al orden de funciones */
                "M",
                "I",
                "H",
                "S"
               };
pfuncion pfun[] = {
						&abrir,
						&guardar,
            &altas, /* Ojo: el orden de funciones tiene que ser */
            &bajas, /*   igual al orden de opciones      */
            &modificaciones,
            &informes,
            &ayuda,
            &salir,
            NULL /* Marcador de fin de lista al estilo de las cadenas */
           };
/*
        Las opciones válidas pueden ser tanto caracteres individuales
        como palabras completas.
*/

  iniciacion(pg, argc, argv);
  dispatcher( menu,
        opcionesvalidas,
        pg,
        pfun);
  terminacion(pg);
  puts("\n\nThat's all folks!\n");
  return 0;
}

/****************************************************************/
void mostrar(struct Registro * p)
{
	printf("%20s %4d %6.2f\n",
					p->nombre,
					p->edad,
					p->talla);
}

void rellenar(struct Registro * p)
{
	char * n;
	do
		{
			printf("\nEscriba el nombre: ");
			n = sgets();
			strcpy(p->nombre, n);
			free(n); /* No hay fuga de memoria */
		} while (0 == strlen(p->nombre));
	do
		{
			printf("\nEscriba la edad: ");
			n = sgets();
			p->edad = strtol(n, NULL, 10);
			free(n);
		} while (p->edad <=0 || p->edad >100);
	do
		{
			printf("\nEscriba la talla (cm): ");
			n = sgets();
			p->talla = strtof(n, NULL);
			free(n);
		} while (p->talla <=1.0 || p->talla >=230);
}
void iniciacion(Global * pg, int argc, char * argv[])
{
  int i;
  for(i=0;i<MAX_REGISTROS;i++)
  	{
  		strcpy(pg->bdd[i].nombre,"");
  		pg->bdd[i].edad = 0;
  		pg->bdd[i].talla = 0.0;
  	}
}
void altas(Global * pg)
{
	int i,n;
	n = -1;
	printf("\n\nAltas\n\n");
	for(i=0;i<MAX_REGISTROS;i++)
		if (0 == pg->bdd[i].edad)
			{
				n = i;
				break;
			}
	if(-1 != n)
		rellenar(&(pg->bdd[n]));
	else
		printf("Base de datos llena!%c\n", 7);
 spause();
}
void bajas(Global * pg)
{
 int i,n;
 char * s;
 for(i=0;i<MAX_REGISTROS; i++)
 	if (0 == pg->bdd[i].edad)
 		mostrar(&(pg->bdd[i]));
 printf("\nEscriba el índice del registro que desea eliminar: ");
 s = sgets();
 n = strtol(s, NULL, 10);
 pg->bdd[n].edad = 0;
 spause();
}
void modificaciones(Global * pg)
{
 int i,n;
 char * s;
 for(i=0;i<MAX_REGISTROS; i++)
 	if (0 != pg->bdd[i].edad)
 		mostrar(&(pg->bdd[i]));
 printf("\nModificaciones\n\nEscriba el índice del registro que desea modificar: ");
 s = sgets();
 n = strtol(s, NULL, 10);
 free(s); /* no hay fuga */
 rellenar(&(pg->bdd[n]));
 spause();
}
void informes(Global * pg)
{
	int i,n;
	char * s;
	printf("\nInformes\n\nEscriba la edad que desea buscar: ");
	s = sgets();
	n = strtol(s, NULL, 10);
	free(s); /* No hay fuga */
	printf("\nLista de registros hallados\n\n");
	for(i=0;i<MAX_REGISTROS; i++)
		if (n == pg->bdd[i].edad)
			mostrar(&(pg->bdd[i]));
	printf("\n\nFin de la lista de registros hallados\n\n");
	spause();
}

void ayuda(Global * pg)
{
 printf("\n\nAyuda\n\n");
 spause();
}
void terminacion(Global * pg)
{
  int i;
  puts("\nEl contenido de la base de datos es:\n\n");
  for(i=0;i<MAX_REGISTROS;i++)
  	mostrar(&(pg->bdd[i]));
  printf("\n\nFin del listado\n\n");
}
/****************************************************************/

void dispatcher( char * pm, char * ov[], Global * pg, pfuncion pf[])
{
  char * temp = NULL;     /* Para leer la instrucción */
  int instruccion;           /* dada por el usuario                      */
  int num_opciones = 0;
  int i;
  
  /* Recuento de opciones */
  while(pf[num_opciones] != NULL) num_opciones++;
 
  /* Bucle principal de ejecución */
  do
   {
      printf("%s ", pm);
      temp = sgets();
      
      instruccion = -1;
      for(i=0;i<num_opciones;i++)
            if(0==strcasecmp(ov[i],temp))
                  {
                      instruccion = i;
                      break;
                  }
 
      system(BORRAR);
      
      if (-1 != instruccion)
        pf[instruccion](pg);
      else
        printf("%c", 7);
        
  
      free(temp); /* Se libera la memoria reservada por sgets() */
   } while (&salir != pf[instruccion]);
  
} /* Fin de dispatcher() */

/****************************************************************/

void salir(struct Global * pg)
{
 return;
}


void abrir(Global * pg)
{
	FILE * fp;
	fp = fopen("datos.bin", "rb");
	fread(pg->bdd, sizeof(pg->bdd), 1, fp);
	fclose(fp);
}

void guardar(Global * pg)
{
	FILE * fp;
	fp = fopen("datos.bin", "wb");
	fwrite(pg->bdd, sizeof(pg->bdd), 1, fp);
	/* fwrite(pg->bdd, sizeof(struct Registro), MAX_REGISTROS, fp); */
	fclose(fp);
}
makefile
OBJECTS = main.o utiles.o
program: $(OBJECTS)
	cc $(OBJECTS) -o program

utiles.o: utiles.c utiles.h
	cc -c utiles.c -o utiles.o

main.o: main.c utiles.h main.h
	cc -c main.c

clean:
	rm utiles.o
	rm *.o
	rm program



Una base de datos dinámica con soporte binario
utiles.h
#include<stdio.h>


#ifndef __UTILES__
        #define __UTILES__
        
        char * sgets(void);
        void spause(void);
        int confirmar(char * indicacion);
        char * pedir(const char * indicacion);
        
        #ifdef __ISDEVC__
        
                #define BORRAR "cls"
                int strcasecmp(const char * big, const char * little);
        
        #else
        
                #define BORRAR "clear"
                #include<termios.h>
                char getch(void);
        
        #endif

#endif

utiles.c
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<ctype.h>
#include "utiles.h"


/*
    sgets() has different implementations in Unix and elsewhere,
    hence our first step is to determine just what the
    underlying OS is
*/

#ifdef __ISDEVC__
/*
    This is not Unix, hence no fgetln() and sgets()
    is somewhat less safe. We hope the user
    will not input more than 1024 characteres at a time.
*/
char * sgets(void)
{
    int MAXCHARS = 1024;
    char * temp = (char *)malloc(MAXCHARS);
    char * resultado;
    fgets(temp,MAXCHARS,stdin);
    resultado = (char *)malloc(strlen(temp));
    strcpy(resultado, temp);
    resultado[strlen(resultado)-1] = '\0';
    free(temp);
    return resultado;
}

/*
    strcasecmp() is not defined, hence we
    try to produce a reasonable facsimile
*/

int strcasecmp(const char * big, const char * little)
{
        int i,n;
        char * _big = (char *)malloc(sizeof(char)*(strlen(big)+1));
        char * _little = (char *)malloc(sizeof(char)*(strlen(little)+1));
        int result;
        /*
                Store the original values
        */
        strcpy(_big, big);
        strcpy(_little,little);
        /*
                Translate into lowercase both _big and _little
        */
        n = strlen(_big);
        for(i=0;i<n;i++)
                _big[i] = tolower(_big[i]);
        n = strlen(_little);
        for(i=0;i<n;i++)
                _little[i] = tolower(_little[i]);
        /*
                Find out whether little and big are equal
                after translating into lowercase
        */
        result = strcmp(_big,_little);
        /*
                No leaks!
        */
        free(_big);
        free(_little);
        /*
                And tell what happened
        */
        return result;
}
#else
/*
    This is Unix, hence fgetln() is available but getch() is not.
    We produce a reasonable implementation of sgets() and
    of getch()
*/
char * sgets(void)
{
        char * puntero_linea;
        size_t longitud_linea;
        char * resultado;
        puntero_linea = fgetln(stdin, &longitud_linea);
        resultado = (char *)malloc(longitud_linea+2);
        memcpy(resultado,puntero_linea,longitud_linea);
        resultado[longitud_linea-1] = '\0';
        return resultado;
}


char getch(void) {
    struct termios conf_vieja, conf_nueva;
    char c;
    tcgetattr(0,&conf_vieja);
    conf_nueva = conf_vieja;
    conf_nueva.c_lflag &= (~ICANON);
    conf_nueva.c_cc[VTIME] = 0;

    conf_nueva.c_cc[VMIN] = 1;
    tcsetattr(0,TCSANOW,&conf_nueva);
    c = getchar();
    tcsetattr(0,TCSANOW,&conf_vieja);
    return c;
}

#endif
/*
    Once we have sgets() and getch() at our disposal, we build
    further useful functions like pedir (ask) and confirmar
    (confirm). All these functions are shared between platforms.
*/
char * pedir(const char * indicacion)
{
        char * resultado;
        printf("%s ", indicacion);
        resultado = sgets();
        return resultado;
}

void spause(void)
{
        char * temp;
        printf("\n\nPulse <INTRO> para continuar\n\n");
        temp = sgets();
        free(temp);
        return;
}

int confirmar(char * indicacion)
{
        char * respuesta;
        printf("%s (s/n): ", indicacion);
        respuesta = sgets();
        return toupper(respuesta[0]) == 'S';
}



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


#ifndef __PROGRAMAPRINCIPAL__
#define __PROGRAMAPRINCIPAL__

#include "utiles.h"

#define MAX_REGISTROS 10000

struct Registro {
	char nombre[20];
	int edad;
	float talla;
};

typedef struct Global {
        struct Registro *bdd;
        int num_registros;
} Global;

typedef void (*pfuncion)(Global *);

void dispatcher( char * pm, char * ov[], struct Global * pg, pfuncion pf[]);
void iniciacion(Global * pg, int argc, char * argv[]);
void terminacion(Global * pg);
void ayuda(Global * pg);

void altas(Global * pg);
void bajas(Global * pg);
void modificaciones(Global * pg);
void informes(Global * pg);
void salir(Global * pg);

void mostrar(struct Registro * p);
void rellenar(struct Registro * p);

void abrir(Global * p);
void guardar(Global * p);
#endif
main.c
#include "main.h"

/****************************************************************/
int main(int argc, char * argv[])
{
  Global * pg = (Global *)malloc(sizeof(Global));
  
  char menu[] = "O)Abrir G)uardar A)ltas B)ajas M)odificaciones I)nformes H)Ayuda S)alir";
  char * opcionesvalidas[] = {
  							"O",
  							"G",
                "A", /* Ojo: el orden de opciones tiene que  */
                "B", /*    ser igual al orden de funciones */
                "M",
                "I",
                "H",
                "S"
               };
pfuncion pfun[] = {
						&abrir,
						&guardar,
            &altas, /* Ojo: el orden de funciones tiene que ser */
            &bajas, /*   igual al orden de opciones      */
            &modificaciones,
            &informes,
            &ayuda,
            &salir,
            NULL /* Marcador de fin de lista al estilo de las cadenas */
           };
/*
        Las opciones válidas pueden ser tanto caracteres individuales
        como palabras completas.
*/

  iniciacion(pg, argc, argv);
  dispatcher( menu,
        opcionesvalidas,
        pg,
        pfun);
  terminacion(pg);
  puts("\n\nThat's all folks!\n");
  return 0;
}

/****************************************************************/
void mostrar(struct Registro * p)
{
	printf("%20s %4d %6.2f\n",
					p->nombre,
					p->edad,
					p->talla);
}

void rellenar(struct Registro * p)
{
	char * n;
	do
		{
			printf("\nEscriba el nombre: ");
			n = sgets();
			strcpy(p->nombre, n);
			free(n); /* No hay fuga de memoria */
		} while (0 == strlen(p->nombre));
	do
		{
			printf("\nEscriba la edad: ");
			n = sgets();
			p->edad = strtol(n, NULL, 10);
			free(n);
		} while (p->edad <=0 || p->edad >100);
	do
		{
			printf("\nEscriba la talla (cm): ");
			n = sgets();
			p->talla = strtof(n, NULL);
			free(n);
		} while (p->talla <=1.0 || p->talla >=230);
}
void iniciacion(Global * pg, int argc, char * argv[])
{
  int i;
  pg->bdd = NULL;
}
void altas(Global * pg)
{
	int i,n;
	n = -1;
	printf("\n\nAltas\n\n");
	for(i=0;i<pg->num_registros;i++)
		if (0 == pg->bdd[i].edad)
			{
				n = i;
				break;
			}
	if(-1 != n)
		rellenar(&(pg->bdd[n]));
	else
		printf("Base de datos llena o inexistente%c\n", 7);
 spause();
}
void bajas(Global * pg)
{
	int i,n;
	char * s;
	int num_posibles_bajas = 0;
	for(i=0;i<pg->num_registros; i++)
 	if (0 != pg->bdd[i].edad)
 		{
	 		mostrar(&(pg->bdd[i]));
	 		num_posibles_bajas++;
	 	};
	if(0 == num_posibles_bajas)
		{
			printf("\n\nBase de datos vacía\n\n");
		}
	else
		{
			printf("\nEscriba el índice del registro que desea eliminar: ");
			s = sgets();
			n = strtol(s, NULL, 10);
			pg->bdd[n].edad = 0;
 		}
	spause();
}
void modificaciones(Global * pg)
{
 int i,n;
 char * s;
 int num_posibles_modificaciones = 0;
 for(i=0;i<pg->num_registros; i++)
 	if (0 != pg->bdd[i].edad)
 		{
 			mostrar(&(pg->bdd[i]));
 			num_posibles_modificaciones++;
 		}
 	if (0 == num_posibles_modificaciones)
 		{
 			printf("\n\nBase de datos vacía o inexistente\n\n");
 		}
 	else
 		{
			printf("\nModificaciones\n\nEscriba el índice del registro que desea modificar: ");
			s = sgets();
			n = strtol(s, NULL, 10);
			free(s); /* no hay fuga */
			rellenar(&(pg->bdd[n]));
		}
 spause();
}
void informes(Global * pg)
{
	int i,n;
	char * s;
	if (0 == pg->num_registros)
		{
			printf("\n\nBase de datos vacía.\n\n");
		}
	else
		{
			printf("\nInformes\n\nEscriba la edad que desea buscar: ");
			s = sgets();
			n = strtol(s, NULL, 10);
			free(s); /* No hay fuga */
			printf("\nLista de registros hallados\n\n");
			for(i=0;i<pg->num_registros; i++)
				if (n == pg->bdd[i].edad)
					mostrar(&(pg->bdd[i]));
			printf("\n\nFin de la lista de registros hallados\n\n");
		}
	spause();
}

void ayuda(Global * pg)
{
 printf("\n\nAyuda\n\n");
 spause();
}
void terminacion(Global * pg)
{
  int i;
  if (0 == pg->num_registros)
  	{
  		printf("\n\nBase de datos vacía.\n\n");
  	}
  else
  	{
			puts("\nEl contenido de la base de datos es:\n\n");
			for(i=0;i<pg->num_registros;i++)
				if (0 != pg->bdd[i].edad)
					mostrar(&(pg->bdd[i]));
			printf("\n\nFin del listado\n\n");
			free(pg->bdd);
		}
}
/****************************************************************/

void dispatcher( char * pm, char * ov[], Global * pg, pfuncion pf[])
{
  char * temp = NULL;     /* Para leer la instrucción */
  int instruccion;           /* dada por el usuario                      */
  int num_opciones = 0;
  int i;
  
  /* Recuento de opciones */
  while(pf[num_opciones] != NULL) num_opciones++;
 
  /* Bucle principal de ejecución */
  do
   {
      printf("%s ", pm);
      temp = sgets();
      
      instruccion = -1;
      for(i=0;i<num_opciones;i++)
            if(0==strcasecmp(ov[i],temp))
                  {
                      instruccion = i;
                      break;
                  }
 
      system(BORRAR);
      
      if (-1 != instruccion)
        pf[instruccion](pg);
      else
        printf("%c", 7);
        
  
      free(temp); /* Se libera la memoria reservada por sgets() */
   } while (&salir != pf[instruccion]);
  
} /* Fin de dispatcher() */

/****************************************************************/

void salir(struct Global * pg)
{
 if (confirmar("Desea guardar los cambios?"))
 	guardar(pg);
 else
 	printf("\n\nNo se han guardado los cambios.\n\n");
 return;
}


void abrir(Global * pg)
{
	FILE * fp;
	struct Registro registro = {"", 0, 0.0 };
	int i;
	fp = fopen("datos.bin", "rb");
	if (NULL == fp)
		{
			/* la base de datos no existe, la creamos */
			fp = fopen("datos.bin", "wb");
			for(i=0;i<MAX_REGISTROS;i++)
				fwrite(&registro, sizeof(struct Registro),1,fp);
			fclose(fp);
			printf("\n\nBase de datos creada... por favor, arranque de nuevo.\n\n");
			exit(0);
		}
	else
		{
			/* Calculamos el número de registros que hay en el archivo */
			fseek(fp,0,SEEK_END);
			pg->num_registros = ftell(fp)/sizeof(struct Registro);
			printf("\n\nSe han leído %d registros\n", pg->num_registros);
			/* Creamos un bloque de tamaño adecuado */
			pg->bdd = calloc(pg->num_registros,sizeof(struct Registro));
			/* Ponemos el puntero de archivo al principio */
			fseek(fp,0,SEEK_SET);
			fread(pg->bdd, sizeof(struct Registro), pg->num_registros, fp);
			fclose(fp);
		}
}

void guardar(Global * pg)
{
	FILE * fp;
	if (0 != pg->num_registros)
		{
			fp = fopen("datos.bin", "wb");
			fwrite(pg->bdd, sizeof(struct Registro), pg->num_registros, fp);
			fclose(fp);
		}
	else
		{
			printf("\n\nLa base de datos está vacía y no se ha guardado.\n\n");
		}
}
makefile
OBJECTS = main.o utiles.o
program: $(OBJECTS)
	cc $(OBJECTS) -o program

utiles.o: utiles.c utiles.h
	cc -c utiles.c -o utiles.o

main.o: main.c utiles.h main.h
	cc -c main.c

clean:
	rm utiles.o
	rm *.o
	rm program