<variable_fichero> = fopen (<nombre_fichero>, <modo acceso>);

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

   FILE *f;
   
   f = fopen ("texto.txt", "r");
   if (!f)
      printf ("Error, el fichero no existe\n");
   else
      ...

   FILE *f;
 
   if ((f = fopen ("texto.txt", "r")) == NULL)
      printf ("Error, el ficnero no existe\n");
   else
      ...

   <valor> = fclose (<variable_fichero>);

• 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>

   <numero_ficheros> = fcloseall();

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

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

• carácter es el carácter que se desea escribir en el fichero.
• var_fich es la variable declarada como FILE.

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

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

• carácter es la variable que contendrá el carácter leído del fichero.
• var_fich es la variable declarada como FILE.

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

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

   fputs (<cadena>, <var_fich>);

• cadena es el cadena que se desea escribir en el fichero.
• var_fich es la variable declarada como FILE.

• fputs ("hola\n", f1);
• strcpy (cad, "hola\n"); fputs (cad, f1);

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

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

• fgets (cad, 5, f1);

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

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

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

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

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

• valor es el valor que nos indica si ha llegado a final de fichero.
• var_fich es la variable declarada como FILE.

• while (!feof(f1))
  {
  fread (....);
  ...
  }
  

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

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

• valor es el valor que nos indica si ha ocurrido un error.
• var_fich es la variable declarada como FILE.

• fwrite (&dato, sizeof(dato), 1, fich);
  if (ferror(fich)) printf ("Error de escritura\n");

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

   rewind (<var_fich>);

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

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

   <num_entero> = getw (<var_fich>);

• num_entero es la variable que contendrá el valor entero leído del fichero.
• var_fich es la variable declarada como FILE.

• i = getw (fich);
• printf ("%d\n", getw (fich));

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

   putw (<num_entero>, <var_fich>);

• num_entero es el valor entero que se escribirá en el fichero.
• var_fich es la variable declarada como FILE.

• putw (5, fich);
• i = 99; putw (i, fich);

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

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

• fscanf (fich, "%s%d%f", nombre, &edad, &altura);

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

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

• fprintf (fich, "%s%d%f", nombre, edad, altura);

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

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

• remove ("datos.dat");
• strcpy (nombre, "texto.txt"); remove (nombre);

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

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

• strcpy (viejo, "clientes.xxx\0");
  strcpy (nuevo, "clientes.dat\0);
  rename (viejo, nuevo);

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.

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:

   <valor> = fseek (<var_fich>, <dirección>, <desde>);

• 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

   <posición> = ftell (<var_fich>);

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