1Entrada Y Salida Por Archivos 11Fundamentos Del Sistema

1entrada y salida por archivos ============================== 1.1fundamentos del sistema de archivos -----------------------------------

1Entrada y Salida por archivos
==============================
1.1Fundamentos del sistema de archivos
--------------------------------------
Antes de leer o escribir en un archivo se debe informar al sistema la
intención de hacerlo, mediante lo que se denomina apertura de un
archivo. Si lo que se desea es escribir será necesario crear un
archivo, descartar el contenido previo o simplemente anexar
información a uno ya existente.
Para abrir un archivo se utiliza la función fopen( ), que en su forma
general corresponde a :
FILE *fopen(char *nombre_archivo, char *modo_apertura);
Donde :
nombre_archivo : es un puntero a una cadena que contiene el nombre del
archivo, en forma alternativa se puede usar una cadena entre comillas
dobles que especifique un nombre de archivo.
modo de apertura : determina como se puede acceder al archivo.
Los posible valores para el modo de apertura son :
Modo
Significado
r
abre un archivo de texto para lectura
w
crea un archivo de texto para escritura
a
abre un archivo d texto para añadir
rb
abre un archivo binario para lectura
wb
crea un archivo binario para escritura
ab
abre un archivo binario para añadir
r+
abre un archivo de text para lectura/escritura
w+
crea un archivo de texto para lectura/escritura
a+
abre un archivo de texto paralectura/escritura
r+b
abre un archivo binario para lectura/escritura
w+b
crea un archivo binario para lectura/escritura
a+b
añadir en un archivo binario en modo lectura/escritura
FILE : indica que la función devuelve un puntero a una variale de tipo
FILE *, si la apertura falla se devuelve un puntero nulo.
Esta función usa el archivo de cabecera STDIO.H, en donde se define el
tipo FILE, el cual corresponde a una estructura que contiene campos
que contienen información relativa al archivo.
Importante es destacar que el puntero FILE se utilizará con todas las
funciones que operan sobre un archivo.
Además es imprescindible comprobar el valor de FILE después de llamar
a fopen( ) para asegurarse de que no es NULL.
Ejemplo :
FILE *fp;
if ((fp = fopen(“mi_archivo”,“r”)) = = NULL )
{
printf(“error en la apertura del archivo \n”);
exit( ); /* provoca la salida del programa */
}
Algunos comentarios adicionales a los modos de apertura :
Cuando se abre un archivo para operaciones de lectura y este no existe
fopen( ) fallará. Si no existe cuando se abre un archivo en el modo
para añadir se creará uno. Además, cuando se abra para añadir los
nuevos datos se escribirán al final del archivo y el contenido
original permanecerá sin cambio. Si se abre un archivo para escritura
y este no existe, se creará por el contrario si ya existe el contenido
original será destruido y se creará un archivo nuevo.
Para cerrar un archivo se utiliza fclose( ), cuya forma es :
int fclose(FILE *fp);
donde fp es un puntero asociado a un archivo y obtenido mediante
fopen( ).
El valor devuelto por esta función será cero si se ejecuta
correctamente de lo contrario devuelve EOF.
Para leer y/o escribir bytes hacia o desde un archivo se utilizan :
int fgetc(FILE *fp);
int fputc(int ch,FILE *fp);
La función fgetc( ) lee el siguiente byte desde el archivo descrito
por fp como un unsigned char y lo devuelve como un entero.La función
fgetc( ) devuelve el valor EOF cuando se alcanza el final del archivo.
Aunque esta rutina devuelva un int, perfectamente se le puede asignar
el valor de retorno a una variable de tipo char.
La función fputc( ) escribe el byte contenido en ch en el archivo
asociado a fp como un unsigned char. Aunque en su definición ch este
definido como un un int, se le puede llamar simplemente utilizando un
char, que es el procedimiento común.
Ejemplo : Para escribir una cadena byte a byte en un archivo y luego
leerla:
char nombre[20],ch;
int i = 0;
FILE *fp;
if ((fopen(“mi_archivo.dat”,“w”)) ! = NULL )
{
gets(nombre);
while (nombre[i] ! = ‘\0’)
fputc(nombre[i++],fp);
}
fclose(fp);
if ((fopen(“mi_archivo.dat”,“r”)) ! = NULL )
{
while ((ch= fgetc(fp)) != EOF)
printf(“%c”,ch);
}
feof( ) y ferror( )
Estas funciones permiten saber si se ha llegado al final del archivo o
si se produjo un error.
En su forma general :
int feof(FILE *fp);
int ferror(FILE *fp);
La función feof( ) devuelve un valor distinto de cero si el archivo
asociado a fp ha llegado a su final. En caso contrario devuelve
cero.Esta función es tanto para archivos de texto como para archivos
binarios.
La función ferror( ) devuelve un valor cero si el archivo asociado a
fp ha experimentado un error, en caso contrario devuelve cero.Esta
función solamente comunica el estado del sistema de archivos relativo
al último acceso de archivo. Es por eso que ferror( ) debe llamarse
después de cada operación de archivo.
Ejemplos: Para leer el contenido del archivo del ejemplo anterior y
verificar errores al leer.
if ((fopen(“mi_archivo.dat”,“r”)) ! = NULL )
{
while ( !feof(fp) )
ch= fgetc(fp);
if ferror(fp)
{
printf(“error de archivo \n”);
break;
}
printf(“%c”,ch);
}
1.2Funciones de texto de alto nivel
-----------------------------------
Cuando se trabaja con archivos de texto, C proporciona cuatro
funciones que facilitan las operaciones con archivos. Las dos primeras
se llaman fputs( ) y fgets( ), que escriben y leen una cadena
hacia/desde un archivo respectivamente. Sus formas son :
int fputs(char *cadena, FILE *fp);
char *fgets(char *cadena, int num, FILE *fp);
La función fputs( ) escribe la cadena a la que apunta cadena en el
archivo asociado a fp.No se escribe el caracter nulo que ternima la
cadena . Además a diferencia de puts( ), no añade automáticamente una
secuencia retorno de carro/salto de linea. Devuelve EOF si hay error.
La función fgets( ) lee caracteres del archivo asociado a fp y los
guarda en la cadena hasta que se hayan leído num -1 caracteres, se
encuentre una nueva linea o se llegue al final del archivo. En
cualquier caso la cadena termina en un caracter nulo. A diferencia de
gets( ), se mantiene el caracter de nueva linea.Devuelve un puntero
nulo si hay error.
Otras funciones muy importantes son fprintf( ) y fscanf( ). Estas
funciones funcionan exactamente igual que printf( ) y scanf( ) excepto
que trabajan con archivos.La forma general de cada una de ellas es :
int fprintf( FILE *fp,especificador(es) de formato, variable(s) );
int fscanf( FILE *fp,especificador(es) de formato, variable(s) );
La ventaja en el uso de estas dos funciones radica en que facilitan la
escritura de una gran variedad de datos en un archivo utilizando un
formato de texto legible para el ser humano, ya que no se utilizan
formatos internos.En síntesis fprintf( ) escribe en un archivo lo que
escribe printf( ) en la pantalla.
Ejemplo : Se ingresará en un archivo de texto una cadena que luego
será leída usando
fgets( ).Note que si el numero de cadenas ingresadas es desconocido es
necesario el uso de feof( ).
char cadena[20];
FILE *fp;
if (( fp = fopen(“mi_archivo.txt”,“w”))!=NULL)
{
gets(cadena);
strcat(cadena,“\n”);
fputs(cadena,fp);
}
fclose(fp);
if (( fp = fopen(“mi_archivo.txt”,“r”)) != NULL)
{
fgets(cadena,sizeof(cadena),fp);
printf( “ %s ”,cadena);
}
fclose(fp);
Ejemplo : Se escribira una serie de datos de distinto tipo usando
fprintf( ) que luego se leen usando fscanf( ). Los datos son el
sueldo, edad y nombre de una persona.
char cadena[20];
float f ;
int i ;
FILE *fp;
if (( fp = fopen(“mi_archivo.txt”,“w”))!=NULL)
{
fprintf(fp,“%f %d %s \n”,450.670,25,“juan oporto”);
fprintf(fp,“%f %d %s”,670.790,40,“maria lara”);
}
fclose(fp);
if (( fp = fopen(“mi_archivo.txt”,“r”)) != NULL)
{
fscanf(fp,“ %f %d %s ”,&f,&i,cadena);
printf( “Nombre : %s \n Sueldo : %f \n Edad : %d \n”,cadena,f,i);
fscanf(fp,“ %f %d %s ”,&f,&i,cadena);
printf( “Nombre : %s \n Sueldo : %f \n Edad : %d \n”,cadena,f,i);
}
fclose(fp);
Note que en el primer fprintf( ) es necesario escribir un \n porque en
caso contrario serán escritos en la misma linea dentro del archivo los
datos del segundo fprintf( ).
1.3Lectura y escritura de datos binarios
----------------------------------------
A pesar de lo útiles que son fscanf( ) y fprintf( ) no son el modo más
eficiente de leer y escribir datos en un archivo.La razón de esto es
que ambas funciones realizan conversiones de datos.
Para solucionar esto C incluye dos funciones importantes fread( ) y
fwrite( ). Estas funciones pueden leer y escribir cualquier tipo de
datos. Sus fomas generales :
size_t fread(void *buffer, size_t numero_bytes, size_t cuenta, FILE
*fp);
size_t fwrite(void *buffer, size_t numero_bytes, size_t cuenta, FILE
*fp);
fread( ) lee del archivo asociado a fp el número de elementos
especificado en cuenta en el buffer apuntado por buffer y considerando
cada elemento con una longitud en bytes de numero_bytes. Devuelve el
número de elementos leídos, si este valor es cero, no se ha leído
ningún elemento o bien alcanzado al final del archivo o se ha
producido un error.
fwrite( ) es la opuesta de fread( ). Escribe en el archivo asociado a
fp, el número de elementos especificados en cuenta que están
contenidos en el buffer apuntado por buffer y considerando cada
elemento con una longitud de numero_bytes. Devuelve el número de
objetos escritos.
Ejemplo : Se escribe un array de enteros en el archivo y luego se lee
lo escrito.
int buffer[5]= { 1, 2, 3, 4, 5};
FILE *fp
if ((fp = fopen(“archivo”,“w+b”))!=NULL)
{
fwrite(buffer,sizeof buffer,1,fp);
fclose(fp);
}
if ((fp = fopen(“archivo”,“r+b”))!=NULL)
{
fread(buffer,sizeof buffer,1,fp);
fclose(fp);
}
1.4Acceso aleatorio
-------------------
Hasta ahora los ejemplos contemplan la escritura o lectura de
principio a fin.Sin embargo se puede accesar cualquier lugar de un
archivo en cualquier momento..
La función que permite lo anterior es fseek( ) :
int fseek(FILE *fp, long numero_bytes, int origen);
Donde :
fp : esta asociado al archivo con el cual se desea trabajar.
numero_bytes : es el número de bytes a partir del origen que supondrán
la nueva posición.
El valor de origen debe ser una de las constantes definidas en stdio.h
Valor de origen
Significado
SEEK_SET
buscar desde el inicio del archivo
SEEK_CUR
buscar desde la posición actual
SEEK_END
buscar desde el finañ del archivo
Si se quiere que la posición actual esté a 100 bytes desde el inicio
del archivo, entonces origen será SEEK_SET y numero_bytes será 100.
fseek( ) devuelve cero cuando se ejecuta correctamente.
Adicionalmente se puede determinar la posición actual de un archivo
usando ftell( ) :
long ftell( fp);
Devuelve la posición del indicador de posición del archivo dentro del
archivo asociado a fp.
Ejemplo : Se ingresa un array de tipo double y luego se desea mostrar
el i-ésimo elemento.
double arreglo[5] = {4.4, 6.6, 2.5, 6.7, 8.9};
long posicion;
double valor;
FILE *fp;
if ((fp = fopen(“archivo”,“wb”))!=NULL)
fwrite(arreglo,sizeof arreglo,1,fp);
fclose(fp)
printf(“¿qué elemento del arreglo desea visualizar? ”);
scanf(“ %ld ”,&posicion);
if ((fp = fopen(“archivo”,“rb”))!=NULL)
{
fseek(fp, posicion*sizeof(double),SEEK_SET);
fread(&valor,sizeof(valor),1,fp);
printf(“el valor del elemento número %ld es : %f \n ”,posicion,valor);
}
fclose(fp);