Manejo de Ficheros en C                                                                                      BIOHAZARD 1999
FICHEROS


0. Introducci�n
1. Definici�n de fichero
2. Ficheros de acceso secuencial

2.1. fopen
2.2. fclose
2.3. fcloseall
2.4. putc
2.5. getc
2.6. fputs
2.7. fgets
2.8. fwrite
2.9. fread
2.10. feof
2.11. ferror
2.12. rewind
2.13. getw
2.14. putw
2.15. fscanf
2.16. fprintf
2.17. remove
2.18. rename
3. Gesti�n de un fichero secuencial de estructuras
4. Acceso directo a ficheros
4.1. fseek
4.2. ftell


0. Introducci�n

Bienvenidos al maravilloso mundo de los ficheros en C. He intentado meter en este cursillo todo lo relacionado con la creaci�n y gesti�n de ficheros, tanto binarios como de texto. Los ficheros son una de las m�s importantes, por no decir la m�s importante, de las partes de un programa, ya que nos ayudan a almacenar datos necesarios sin que se pierdan al apagar el equipo.

Veremos muchas de las funciones de manejo de ficheros, aunque no todas, pero si las m�s importantes y relevantes, asi como las formas de recorrer un fichero de la cabeza a los pies.

Acabando la siempre aburrida introducci�n en los documentos,
Os saluda

Biohazard Rules!
BIOHAZARD
- The virus of hate infects the ignorant minds -


1. Definici�n de fichero

Un fichero en sentido global puede ser desde un monitor hasta una impresora, pasando por un archivo en disco.

La idea m�s com�n del concepto de fichero es un conjunto de posiciones de memoria situadas en un disco de los dispositivos externos de almacenamiento del sistema, en las cuales podemos almacenar y recuperar informaci�n.

El lenguaje C nos proporciona un acceso secuencial y directo a los registros de un fichero, pero no soporta el acceso indexado a un registro dado.

Los ficheros en C los podemos clasificar, seg�n la informaci�n que contengan, en dos grupos: ficheros de texto y ficheros binarios.

Los ficheros de texto se caracterizan por estar compuestos por una serie de caracteres organizados en l�neas terminadas por un car�cter de nueva l�nea (car�cter '\n'). Esto nos hace pensar en la idea de usar la impresora como si fuese un fichero de texto.

Por otro lado, los ficheros binarios constan de una secuencia de bytes. Podemos decir que cualquier fichero que no sea de texto, ser� binario.

A la hora de trabajar con ficheros, tendremos que especificar antes de usarlos, si ser�n de texto o binarios.

Podemos establecer una segunda clasificaci�n de los ficheros, atendiendo al modo de acceso a su informaci�n. De este modo, distinguiremos entre ficheros secuenciales y ficheros directos.

Los ficheros de acceso secuencial se basan en el hecho de que, para acceder a una determinada posici�n de los mismos, hemos de recorrer desde el principio todas las posiciones hasta llegar a la deseada. Las impresoras son un claro ejemplo de acceso secuencial, as� como las cintas magn�ticas.

Con el uso de ficheros de acceso directo podemos acceder de forma directa a la posici�n que queramos sin tener que pasar por las posiciones anteriores. El dispositivo de acceso directo por excelencia es el dico magn�tico.

El lenguaje C trata a los ficheros como punteros. En realidad un fichero es un puntero a una estructura de nombre predefinido FILE, cuyas componentes son las caracter�sticas de la variable fichero declarada. Cada fichero deber� tener una estructura FILE asociada.

La estructura FILE se encuentra definida en el archivo de cabecera stdio.h, con lo cual es necesario incluirla en todos los programas que trabajen con ficheros mediante la conocida directiva #include <stdio.h>

La forma de declarar variables de tipo FILE es la siguiente: 

FILE *f, *f1, ...

Como podemos observar se trata de punteros que apuntan a estructuras de tipo FILE. En realidad lo que ocurre con el tipo FILE es que redefine a una estructura de los siguiente forma: 

typedef struct
   {
   short          level;
   unsigned       flags;
   char           fd;
   unsigned char  hold;
   short          bsize;
   unsigned char *buffer, *curp;
   unsigned       istemp;
   short          token;
   }FILE;

Esta estructura la podr�s ver editando el fichero stdio.h. El programador no tendr� que definirla puesto que ya existe.

A continuaci�n vamos a ver las operaciones que podemos realizar con ficheros secuenciales y directos.

2. Ficheros de acceso secuencial

La primera oeraci�n despu�s de declarar un fichero y antes de cualquier otra operaci�n con �l es abrirlo.

  • fopen 
       <variable_fichero> = fopen (<nombre_fichero>, <modo acceso>);
    Donde:
    • variable_fichero es la variable declarada de la forma: FILE *<variable_fichero>
    • nombre_fichero es el nombre que tendr� el fichero en el dispositivo usado. Podr� ser variable o constante.
    • modo acceso es el modo de apertura del fichero, mediante el cual le diremos al compilador si se trata de un fichero de texto o binario, y si vamos a leer o escribir en el fichero.
      Los distintos modos de abrir un fichero son los siguientes:

      Modo

      Significado
      r
      		 Abre un archivo de texto para solo lectura. Si el archivo no existe, devuelve un error
      w
      		 Abre el archivo de texto para solo escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
      a
      		 Abre el archivo de texto para a�adir al final. Si el fichero no existe, lo crea.
      r +
      		 Abre el archivo de texto para lectura/escritura. Si el fichero no existe, da un error
      w +
      		 Abre el archivo de texto para lectura/escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
      a +
      		 Abre el archivo de texto para a�adir al final, con opci�n de lectura. Si el fichero no existe, lo crea.
      rb
      		 Abre un archivo binario para solo lectura. Si el archivo no existe, devuelve un error
      wb
      		 Abre el archivo binario para solo escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
      ab
      		 Abre el archivo binario para a�adir al final. Si el fichero no existe, lo crea.
      rb +
      		 Abre el archivo binario para lectura/escritura. Si el fichero no existe, da un error
      wb +
      		 Abre el archivo binario para lectura/escritura. Si el fichero no existe, lo crea, y si existe lo machaca.
      ab +
      		 Abre el archivo binario para a�adir al final, con opci�n de lectura. Si el fichero no existe, lo crea.

    Decir que los ficheros de texto se pueden referenciar tambien como "rt", "wt", "at", "rt+", "wt+" y "at+", pero para facilitar m�s las cosas, cuando no especificamos si queremos abrir un fichero de texto o binario, por defecto se supone que es de texto, es por ello que los modos "r", "w" y "a" se refieren a ficheros de texto.

    Hemos de tener cuidado con los modos de apertura de los ficheros por que al abrir con cualquier modo "w", si ya exist�a el fichero, se borrar� la informaci�n que contuviese. Si no existe, lo crear�. Por el contrario con el modo "a" tambi�n lo crear� si no existe el fichero, pero si ya existe, a�adir� al final del mismo los datos que escribamos.

    Podemos saber si un fichero ha sido abierto correctamente o no. Debido a que los ficheros son punteros a estructuras tipo FILE, podemos conocer su valor al hacer que apunten a ellas. La forma de hacerlo es comparando el puntero con la constante predefinida NULL. De esta forma, cuando el puntero valga NULL (no apunta a ninguna variable o posicion de memoria), es porque ha habido alg�n problema al abrir el fichero.

    Este problema se puede deber a que no existe el fichero que intentamos abrir para lectura, que no hay espacio suficiente en el disco al tratar de crear el fichero, que la unidad de disco no est� preparada, que el disco est� da�ado fisicamente o que la impresora no est� conectada. Veamos en ejemplo del testeo de la existencia de un fichero de texto. 

       FILE *f;
   
   f = fopen ("texto.txt", "r");
   if (f == NULL)
      printf ("Error, el fichero no existe\n");
   else
      ...
    O de esta otra manera 
       FILE *f;
   
   f = fopen ("texto.txt", "r");
   if (!f)
      printf ("Error, el fichero no existe\n");
   else
      ...
    O bien, de forma abreviada 
       FILE *f;
 
   if ((f = fopen ("texto.txt", "r")) == NULL)
      printf ("Error, el ficnero no existe\n");
   else
      ...

  • fclose 
       <valor> = fclose (<variable_fichero>);
    Donde:
    • valor es el valor que nos dir� si ha ocurrido alg�n error cerrando el fichero. 0 indica que todo ha ido bien.
    • variable_fichero es la variable declarada de la forma: FILE *<variable_fichero>

    Cuando terminemos de trabajar con un fichero hemos de realizar la operaci�n de cierre del fichero. Si no lo hacemos podemos ocasionar la p�rdida de todos los datos del mismo. Si se necesitan cerrar varios ficheros a la vez, nos podemos ahorrar varios fclose utilizando la funcion fcloseall.

  • fcloseall 
       <numero_ficheros> = fcloseall();
    Donde:
    • numero_ficheros es una variable entera que indica el n�mero de ficheros cerrados, o EOF si ha ocurrido un error.

    Ahora veamos una serie de funciones para escribir y leer datos de un fichero de texto.


  • putc

    Esta funci�n escribe un car�cter en un fichero de texto. Devuelve un entero si la escritura es correcta. De otra forma devuelve el valor EOF que indica que ha habido un error. Su formato es: 

       putc (<car�cter>, <var_fich>);
    Donde:
    • car�cter es el car�cter que se desea escribir en el fichero.
    • var_fich es la variable declarada como FILE.
    Ejemplos:
    • putc ('a', f1);
    • c = 'G'; putc (c, f1);

    Ni que decir tiene que cuando usemos funciones para escribir en ficheros, estos tendr�n que haber sido abiertos en modo escritura o para a�adir datos.


  • getc

    Esta funci�n lee un car�cter de un fichero de texto abierto en modo lectura. Devuelve un entero si la lectura es correcta. De otra forma devuelve el valor EOF que indica que hemos llegado al final del fichero. Su formato es: 

       <car�cter> = getc (<var_fich>);
    Donde:
    • car�cter es la variable que contendr� el car�cter le�do del fichero.
    • var_fich es la variable declarada como FILE.
    Ejemplos:
    • c = getc (f1);

    Un ejemplo del uso de estas dos funciones ser�a leer todos los caracteres de un fichero de texto y escribirlos en otro fichero de texto y por pantalla a la vez para comprobar la correcta ejecuci�n: 

       #include <stdio.h>

   main ()
   {
      FILE *f_in, *f_out;
      char c;
      
      clrscr();
      if ((f_in = fopen ("prueba.c", "r")) == NULL)
         {
         printf ("Error de apertura del fichero\n");
         exit (1);
         }
      if ((f_out = fopen ("salida.c", "w")) == NULL)
         {
         printf ("Error de creaci�n del fichero\n");
         exit (1);
         }
      do
         {
         c = getc(f_in);
         putchar(c)       /* escritura en pantalla */
         putc(c, f_out);  /* escritura en el fichero */
         }
      while (c != EOF);
      fclose (f_in);
      fclose (f_out);
   }

    Aparece en este ejemplo una nueva funci�n, la funci�n exit(). Esta funci�n provoca que acabe el programa con lo que la funci�n main() devuelve un valor, en este caso el valor 1. Recordamos que toda funci�n devuelve un valor.


  • fputs

    Esta funci�n escribe una cadena de caracteres en un fichero de texto. Su formato es: 

       fputs (<cadena>, <var_fich>);
    Donde:
    • cadena es el cadena que se desea escribir en el fichero.
    • var_fich es la variable declarada como FILE.
    Ejemplos:
    • fputs ("hola\n", f1);
    • strcpy (cad, "hola\n"); fputs (cad, f1);

  • fgets

    Esta funci�n lee un n�mero de caracteres de un fichero almacen�ndolos en una cadena. Si se encuentra el car�cter de nueva l�nea ya no almacenar� m�s caracteres. Su formato es: 

       fgets (<cadena>, <num_caracteres>, <var_fich>);
    Donde:
    • cadena es la variable que almacenar� la cadena le�da del fichero.
    • num_caracteres es el n�mero de caracteres que se desea leer.
    • var_fich es la variable declarada como FILE.
    Ejemplos:
    • fgets (cad, 5, f1);

  • fwrite

    Esta funci�n permite escribir uno o m�s datos o bloques de datos binarios en un fichero. Su formato es el siguiente: 

       fwrite (<dato>, <num_bytes>, <cont>, <var_fich>);
    Donde:
    • dato es el dato o datos que se van a escribir en el fichero. Hemos de especificar su direcci�n de memoria mediante el operador "&", ya que realmente es un puntero que apunta a la zona de memoria intermedia donde se almacenar� temporalmente la informaci�n antes de pasarla al fichero.
    • num_bytes es el n�mero de bytes que se van a escribir. Lo m�s corriente es usar para este argumento el operador sizeof sobre el dato a escribir.
    • contes el n�mero de datos, de num_bytes cada uno que se van a escribir.
    • var_fich es el puntero al fichero binario usado.

  • fread

    Esta funci�n permite leer uno o m�s datos o bloques de datos de un fichero binario. Su formato es: 

       fread (<dato>, <num_bytes>, <cont>, <var_fich>);
    Donde:
    • dato es la variable donde se guardar�n los datos le�dos del fichero. Hemos de indicar su direcci�n por tratarse de un puntero.
    • num_bytes es el n�mero de bytes que se van a leer del fichero. Lo m�s corriente es usar para este argumento el operador sizeof sobre el dato a escribir.
    • contes el n�mero de datos, de num_bytes cada uno que se van a leer.
    • var_fich es el puntero al fichero binario usado.

    Vamos a ver un ejemplo que escriba un float en un fichero y despu�s lo lea y escriba en pantalla: 

       #include <stdio.h>

   main ()
   {
      FILE *fich;
      float f = 4.879;

      /* Escritura del float en el fichero */
      if ((fich = fopen ("floats.dat", "wb")) == NULL)
         {
         printf ("Error de creaci�n del fichero\n");
         exit (1);
         }
      fwrite (&f, sizeof(f), 1, fich);
      fclose (fich);
      /* Lectura del float del fichero */
      if ((fich = fopen ("floats.dat", "rb")) == NULL)
         {
         printf ("Error de existencia del fichero\n");
         exit (1);
         }
      fread (&f, sizeof(f), 1, fich);
      fclose (fich);
      printf ("Float = %.3f", f);
   }

    Vemos que hemos usado el mismo puntero de fichero. Lo podemos hacer siempre que cerremos el primero antes de abrir el segundo fichero, o se trate del mismo fichero, como es en este caso. Primero hemos abierto el fichero binario para escritura, con lo cual lo creamos de nuevo, y despu�s lo abrimos para lectura para leer el float.

    Este es un ejemplo muy sencillo pues en el fichero solo escribimos un float y despu�s lo leemos. Pero, �qu� ocurre cuando escribimos m�s de un dato? �c�mo sabemos hasta donde debemos leer en el fichero?. La respuesta est� en conocer donde est� el final del fichero. De esta forma leeremos hasta encontrar el final del fichero dado. Existe una funci�n que nos dir� si hemos llegado a este punto o no: la funci�n feof.


  • feof

    Esta funci�n nos devuelve un n�mero positivo si hemos llegado al final de un fichero binario. De otro modo, nos devuelve un cero. Su sintaxis es: 

       <valor> = feof (<var_fich>);
    Donde:
    • valor es el valor que nos indica si ha llegado a final de fichero.
    • var_fich es la variable declarada como FILE.
    Ejemplos:
    • while (!feof(f1))
      {
      fread (....);
      ...
      }

    Este bucle significa "mientras no sea final de fichero leer..."


  • ferror

    Determina si una operaci�n con archivos ha sido err�nea o no. Si lo ha sido devuelve un n�mero positivo, y si no ha habido problema, devuelve un 0. Su sintaxis es: 

       <valor> = ferror (<var_fich>);
    Donde:
    • valor es el valor que nos indica si ha ocurrido un error.
    • var_fich es la variable declarada como FILE.
    Ejemplos:
    • fwrite (&dato, sizeof(dato), 1, fich);
      if (ferror(fich)) printf ("Error de escritura\n");

  • rewind

    Esta funci�n restablece el localizador de posici�n del archivo al comienzo del mismo. Su sintaxis es: 

       rewind (<var_fich>);
    Donde:
    • var_fich es la variable declarada como FILE.

    Por ejemplo, si estamos leyendo secuencialmente el fichero fich y vamos por el cuarto dato, al hacer rewind(fich), volver�amos al principio del fichero y podr�amos volver a leer el primer dato, como si lo abri�semos de nuevo para lectura.


  • getw

    Esta funci�n devuelve un entero le�do de un fichero binario. Su sintaxis es: 

       <num_entero> = getw (<var_fich>);
    Donde:
    • num_entero es la variable que contendr� el valor entero le�do del fichero.
    • var_fich es la variable declarada como FILE.
    Ejemplos:
    • i = getw (fich);
    • printf ("%d\n", getw (fich));

  • putw

    Esta funci�n escribe un entero en un fichero binario. Su sintaxis es: 

       putw (<num_entero>, <var_fich>);
    Donde:
    • num_entero es el valor entero que se escribir� en el fichero.
    • var_fich es la variable declarada como FILE.
    Ejemplos:
    • putw (5, fich);
    • i = 99; putw (i, fich);

  • fscanf

    Esta funci�n trabaja de la misma manera que scanf, pero leyendo los datos formateados de un fichero. Su sintaxis es: 

       fscanf (<var_fich>, <cadena_de_control>, <lista_variables>);
    Donde:
    • var_fich es la variable declarada como FILE.
    • cadena_de_control son las cadenas de control que se desean leer, tales como %d, %s, %f, %x, etc...
    • lista_variables son las variables que contendr�n los valores de la lectura del fichero que deben coincidir con sus respectivas cadenas de control.
    Ejemplos:
    • fscanf (fich, "%s%d%f", nombre, &edad, &altura);

  • fprintf

    Esta funci�n trabaja de la misma manera que printf, pero escribiendo los datos formateados sobre un fichero. Su sintaxis es: 

       fprintf (<var_fich>, <cadena_de_control>, <lista_variables>);
    Donde:
    • var_fich es la variable declarada como FILE.
    • cadena_de_control son las cadenas de control que se desean escribir, tales como %d, %s, %f, %x, etc...
    • lista_variables son las variables que contendr�n los valores para la escritura en el fichero que deben coincidir con sus respectivas cadenas de control.
    Ejemplos:
    • fprintf (fich, "%s%d%f", nombre, edad, altura);

  • remove

    Esta funci�n borra fisicamente el archivo que se especifique. Devuelve un 0 si todo ha salido correctamente o un -1 si ha ocurrido un error. Su sintaxis es: 

       <valor> = remove (<nombre_archivo>);
    Donde:
    • valor es el valor que nos dir� si ha ocurrido un error al borrar el fichero.
    • nombre_archivo es el nombre del fichero que se desea borrar, o sea, que se refiere a una cadena de caracteres y no al identificador del fichero.
    Ejemplos:
    • remove ("datos.dat");
    • strcpy (nombre, "texto.txt"); remove (nombre);

  • rename

    Esta funci�n renombra un fichero especificado. Devuelve 0 si el cambio de nombre ha sido correcto, y -1 si no lo ha sido. Su sintaxis es: 

       <valor> = rename (<nombre_actual>, <nuevo_nombre>);
    Donde:
    • valor es el valor que nos dir� si ha ocurrido un error al renombrar el fichero.
    • nombre_actual es el nombre actual del fichero que se desea renombrar. Se refiere a una cadena, y no al identificador del fichero.
    • nuevo_nombre es el nuevo nombre que se le desea asignar al fichero. Se refiere a una cadena, y no al identificador del fichero.
    Ejemplos:
    • strcpy (viejo, "clientes.xxx\0");
      strcpy (nuevo, "clientes.dat\0);
      rename (viejo, nuevo);


    3. Gesti�n de un fichero secuencial de estructuras

    Los componentes o registros de un fichero pueden ser de cualquier tipo de datos, desde tipos b�sicos (enteros, float, char, etc...) hasta estructuras de datos.

    Las operaciones en cualquiera de los casos son siempre iguales. Veamos un ejemplo de un fichero de estructuras:

    • Apertura:
      ...
struct Tcli
   {
   char nombre[30];
   char direcci�n[30];
   ...
   };

void main()
{
   FILE *f;
   struct Tcli cliente;
   char fichero[13];
 
   strcpy (fichero, "cliente.dat\0");
   if ((fopen(fichero, "ab") == NULL)
      {
      printf ("Error al abrir el fichero\n");
      exit (1);
      }
   ...
}
    • Escritura:
         fwrite (&cliente, sizeof(cliente), 1, f);
    • Lectura:
         fread (&cliente, sizeof(cliente), 1, f);

    Las operaciones b�sicas en el mantenimiento o gesti�n de un fichero secuencial son las siguientes:

    • Comprobaci�n de la existencia del fichero: Se abrir� el fichero en modo lectura, si no existe, se permitir� la creaci�n del mismo, volvi�ndolo a abrir en modo escritura.
    • Altas: Se abrir� el fichero en modo a�adir.
    • Bajas: Utilizaremos dos ficheros: el maestro y otro auxiliar. El maestro lo abriremos para lectura, y el auxiliar para escritura. Iremos transfiriendo todos los registros del maestro al auxiliar excepto el que queramos borrar. A continuaci�n, borraremos el maestro, y asignaremos al auxiliar el nombre del maestro.
    • Modificaciones: Procederemos de igual forma que para las bajas, salvo que transferiremos todos los registros al auxiliar, los no modificados y el modificado. Borraremos el maestro y renombraremos el auxiliar para darle el nombre del maestro.
    • Consultas: Se abrir� el fichero en modo lectura.
    • Listado por pantalla: Se abrir� el fichero en modo lectura. Se ir� leyendo informaci�n mientras no se llegue al final del ficnero.
    • Listado por impresora: Utilizaremos dos ficheros, el maestro y el de impresora. El primero lo abriremos para lectura, y el segundo para escritura, del siguiente modo: 
      FILE *f, *fimp;

f = fopen ("clientes.dat", "r");
fimp = fopen ("prn", "w");
      De tal forma que todo lo que escribamos en fimp saldr� por impresora. Por tal motivo, debemos pensar que se trata de un fichero de texto, por lo cual, usaremos funciones de escritura en ficheros de texto.


    4. Acceso directo a ficheros

    Ya hemos visto como acceder secuencialmente a un fichero, sin embargo tambi�n se puede hacer de forma directa.

    Supongamos que tenemos definido un fichero con la siguiente estructura de registro: 

       struct
      {
      int codigo;
      char nomart[31];
      float precio;
      }articulo;

    Es evidente que la longitud de cada registro es de 37 bytes (2+31+4 bytes). De esta forma, la disposici�n de los registros dentro del fichero en disco se realiza en las siguientes posiciones:

    El acceso directo consiste en indicar la posici�n a la que queremos acceder en bytes. Por ejemplo, para acceder directamente al registro 2, indicaremos que queremos ir al byte 37, contando desde el principio del registro. La orden que posibilita este acceso es la siguiente.

  • fseek 
       <valor> = fseek (<var_fich>, <direcci�n>, <desde>);
    Donde:
    • valor es el valor que nos dir� si ha ocurrido un error al desplazarnos por el fichero. 0 si todo ha ido bien.
    • var_fich es el puntero al fichero que estamos utilizando.
    • direcci�n es el n�mero de bytes que vamos a desplazarnos.
    • desde es el punto de partida del desplazamiento. Este punto admite tres posibles valores:

      Referencia
      Valor
      Desde
      SEEK_SET
      0
      Principio de fichero
      SEEK_CUR
      1
      Posici�n actual del fichero
      SEEK_END
      2
      Final del fichero

    Hay que tener muy en cuenta que no es lo mismo desplazarse 37 bytes desde el principio del fichero (accederemos al segundo registro), que desde el lugar donde nos encontremos (accederemos al siguiente registro)

    Existe otra funci�n que nos devuelve la posici�n en la que nos encontramos dentro del fichero


  • ftell 
       <posici�n> = ftell (<var_fich>);
    Donde:
    • posici�n es la variable que contendr� la posici�n en bytes en la que nos encontramos en ese momento en el fichero.
    • var_fich es la variable declarada como FILE.

    Esta funci�n se suele usar, a parte de para saber la situaci�n exacta en el fichero, para obtener la longitud del mismo. Veamos un ejemplo: 

       ...
   if ((f=fopen("articul.dat", "rb")) == NULL)
      {
      printf ("Imposible crear fichero\n");
      exit (1);
      }
   fseek (f, 0, 2); /* tambien puede ser fseek (f, 2, SEEK_END); */
   l = ftell(f);
   printf ("El fichero tiene un tama�o de %ld bytes\n", l);
   printf ("Y un total de %ld registros\n", l/sizeof(reg));
   /* donde reg ser�a la estructura o el dato simple contenido en el fichero */
   ...

    La forma de dar de alta registros es igual que para el acceso secuencial. Se har� un recorrido hasta llegar al final del fichero para comprobar que no existe el c�digo del registro a dar de alta, y en ese caso, se procede a hacer fwrite. Abriremos para ello el fichero en modo a�adir.

    Las bajas consisten en localizar el registro seg�n un c�digo, y escribir un registro vac�o en tal posici�n. Para ello tendremos que abrir el fichero en modo lectura/escritura, o sea, "r+".

    Las modificaciones, de forma similar a las bajas pero escribiendo en el lugar correspondiente el registro modificado que reemplace al actual.

    Las consultas no son otra cosa que un acceso directo al c�digo indicado.

    Y por �ltimo los listados, que consisten en un recorrido secuencial desde el primer registro hasta el �ltimo.


    Hasta aqu� el cursillo sobre ficheros en C. Recordaros que la forma de gesti�n de los ficheros aqu� expuesta es la m�s b�sica que yo conozco, pero que se puede hacer de mil maneras, mejores o peores, pero que no es la �nica. Comentamos casi al principio que C no soporta los ficheros indexados, pero podeis crearoslos vosotros mismos, s�lo debeis pensar en crearos un fichero de �ndices y otro maestro y a partir de ah�, todo sale solo.

    Web original (SFJ/prog/dos)