Acceso a archivos de texto

Para C un archivo puede ser cualquier cosa, desde un archivo de disco, una impresora o un terminal. Un puntero es el hilo que unifica el sistema de E/S con un buffer. Para poder utilizar las instrucciones de manejo de ficheros hay que incluir el archivo stdio.h con la directiva del preprocesador include<> en la cabecera de nuestro programa.

Para obtener un puntero a un archivo debemos utilizar:

FILE *nombrePuntero;

y utilizar el puntero en las funciones específicas sobre archivos.

fopen() abre una secuencia

FILE *fopen(const char *nombre_Archivo, const char *modo);

  • nombre_Archivo es un puntero a una cadena de caracteres que representa un nombre válido de archivo, puede incluir una especificación de directorio.
  • modo  pueden ser lo siguientes:
    • r:   Arbre un archivo de texto para lectura
    • w:  Crea un archivo de texto para escritura
    • a:   Abre un archivo de texto para añadir
    • r+: Abre un archivo de texto para lectura/escritura
    • w+:Crea un archivo de texto para lectura/escritura
    • a+: Añade o  crea un archivo de texto par lectura/escritura

               FILE *archivo;
               archivo = fopen("miArchivo.txt","w");

Crea un archivo de texto llamado miArchivo.txt en el directorio de trabajo actual. Si fopen() no puede realizar la operación que se le pide, devuelve un valor NULL. Por lo que podemos comparar el valor devuelto por fopen() y actuar en consecuencia.


        FlLE *fich;
        if ((fich = fopen("nomfich.dat", "r")) == NULL)
        {                                 /* control del error de apertura * /
                printf ( " Error en la apertura. Es posible que el fichero no exista \n ");
        }

fclose() cierra una secuencia, abierta con fopen(). Escribe la información que aún se encuentre en el buffer de disco y el cierre del archivo. También libera el bloque de control de archivo dejándolo libre para su reutilización.

int fclose(FILE *archivo);

Tenemos más funciones en la biblioteca estándar de C, aquí dejo unas pocas para abrir boca


  • int putc(int car, FILE *pf);  //Escribe caracteres en un archivo abierto para escritura.
  • int getc(FILE *pf); //Lee caracteres de un archivo abierto para lectura
  • int fputs(const char *cad, FILE *pf); //Escribe una cadena de texto en un archivo.
  • int fgets(char *cad, FILE *pf); /*Lee una cadena de texto de un archivo abierto para lectura.*\
  • void rewind(FILE *pf); //Inicia el indicador de posición al principio del archivo
Hay más funciones como remove(), fflush(), fread(), fwrite(), fprintf(), fscanf(), feof() o ferror() que iremos viendo su uso en los sucesivos ejemplos.


/*
Abre el archivo DATOSIN.DAT para leer su contenido y escribirlo en el archivo DATOSOUT.DAT
*\
#include <stdio.h>

int main (void)
{
FILE *fin, *fout;
char c, x;
if (((fin = fopen("DATOSIN.DAT", "r")) == NULL) ||
      ((fout = fopen("DATOSOUT.DAT", "w")) == NULL))
{
if (fout != NULL)
fclose (fout);
if (fin != NULL)
fclose (fin);
printf ("Error en la apertura de ficheros de salida \n");
return 1;
}

c = fgetc(fin);
while (c != EOF)     // EOF  --> End Of File es una constante definida que representa el final de 
                                 //archivo
{
x = fputc (c, fout); //fputc devuelve el carácter leído
if (x != c)      //compara el carácter leído c, con el carácter devuelto por fputc, ambos deben de 
                           //ser iguales
printf ("Error de escritura");
c = fgetc(fin);
}
fclose (fin);
fclose (fout);
return 0;
}

Este ejemplo se ha sacado de la página: webs.um.es/iverdu 

El siguiente ejemplo muestra por pantalla el contenido de un archivo. Tiene previstas dos formas de pasar el nombre del archivo a mostrar, o bien se pone en la llamada al programa y es pasado como parámetro de main() o el mismo programa pregunta al usuario el nombre del archivo a abrir.

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

int main(int argc, char *argv[])
{
FILE *f;
char caracter;
char nombreArchivo[20];
if(argc < 2){    //argc contiene el número de argumentos pasados al programa
                            //un valor inferior a 2 indica que no tiene parámetros
puts("Qué archivo quieres abrir?");
scanf("%s",nombreArchivo);
f = fopen(nombreArchivo,"r");
}
else{
f = fopen(argv[1],"r");     //argv[1] contiene el argumento pasado al programa
}
if (f == NULL) {
fputs("Error al abrir el archivo\n",stderr); 
exit(1);
return 1;
}
rewind(f);                    //posiciona el cursor de lectura al principio del archivo
fflush(stdin);               //fuerza el vaciado del canal, en este caso stdin
while(feof(f) == 0){   //feof() devuelve 0 si llega al final del archivo
caracter = fgetc(f); //obtiene el siguiente carácter del archivo apuntado por f
printf("%c",caracter);
}
fflush(stdin);
puts("\n");
fclose(f);
return 0;
}
argv[] es un array de cadenas de caracteres que contiene en  argv[0] el nombre del ejecutable y en el elemento 1 y sucesivos, los parámetros pasados al programa.
argc es un valor entero con la cantidad de parámetros pasados al programa.
Un valor mayor que 1, nos indica que se intentan pasar parámetros al ejecutable.
Suscribirse a: Entradas (Atom)