Tema 10 AhiArchivos de datos - cartagena99.com 10.pdf · • Una operación de lectura de un fichero es parecida a una operación de ... – Es obligatorio cerrar un fichero cuando

Tema 10A hi d dArchivos de datos

Fundamentos de Informática

Índice

• Introducción

• Operaciones básicas con archivosOperaciones básicas con archivos

• Tipos de Archivos• Tipos de Archivos

A hi d t t• Archivos de texto

• Archivos binarios

2Departamento de Sistemas InformáticosEscuela Técnica Superior de Ingeniería ICAI

Tema 1: Introducción. Arquitectura básica y Sistemas Operativos

11

• Introducción



ArchivosUn archivo es un conjunto de información que se almacena en un ordenador y puede ser identificado por su ruta completa, cuyo fin ultimo es guardar o proporcionar información. Utilizaremos archivos secuenciales.La memoria RAMRAM se borra en cuanto se corta la corriente.

Es necesario un sistema de almacenamiento secundario.

Los archivos se almacenan en dispositivos de almacenamiento como el disco duro, diskette, CD ROM, …El manejo de los sistemas de almacenamiento de los archi os es gestionado por el sistemaEl manejo de los sistemas de almacenamiento de los archivos es gestionado por el sistema operativo.


Tema 1: Introducción. Arquitectura básica y Sistemas OperativosCarpetas Archivos

Archivos

• Hasta ahora los programas han tomado y devuelto datos de: • teclado ‐ pantalla• teclado ‐ pantalla.

• Una operación de lectura de un fichero es parecida a una operación de lectura de datos desde el tecladoU ió d i d fi h id• Una operación de escritura de un fichero es parecida a una operación de escritura en pantalla.

• Utilizaremos archivos secuenciales.• Operaciones con archivos:

– Apertura de archivos: fopen()– Cierre de archivos: fclose()Cierre de archivos: fclose()– Lectura de archivos: fscanf () (texto), fread() (binarios)– Escritura en archivos: fprintf () (texto), fprintf() (binarios)



22

Operaciones básicas con archivos




• Diferencias con el manejo de pantalla y teclado:– Es necesario establecer un área de buffer.

• Este área almacena la información mientras se está transfiriendo• Este área almacena la información mientras se está transfiriendo hacia o desde el fichero.

– Para apuntar a esa área de buffer se utiliza la siguiente declaración:FILE *punt_fichero;

– Donde:• FILE es un tipo especial de estructura que establece el área delFILE es un tipo especial de estructura que establece el área del buffer. Contiene toda la información que necesitan el resto de funciones que trabajan con archivos, como el modo del archivo, los buffers del archivo, errores ...,– Incluida en stdio.h

t fi h i bl d ti t t l• punt_fichero es una variable de tipo puntero que apunta al comienzo del área del buffer.



Operaciones básicas con archivos• Apertura de un archivo: fopen()p p ()

– Siempre antes de realizar cualquier operación con un fichero.

• Una vez abierto el fichero, y hasta que éste se cierre, se pueden li i d i id d d lrealizar tantas operaciones como se deseen sin necesidad de volver

a abrirlo.

– El objetivo de abrir un fichero es:j

• Asociar el nombre del archivo “físico” con el área del buffer.

• Especificar el uso que se le va a dar al fichero (lectura, escritura, l t it d t t bi i ) Memoria ExternaMemoria Internalectura‐escritura, en modo texto, binario ...).

Programa

Canal físico

Buffer


Tema 1: Introducción. Arquitectura básica y Sistemas OperativosCanal lógico

Registro buffer: espacio de memoria interna que reserva el sistema para el intercambio de registros entre el archivo y el programa.


• Apertura de un archivo: fopen()

– Prototipo de la función:

FILE *fopen (char * nombre_completo_archivo, char *modo);

• nombre_completo_archivo (cadena de caracteres): es el nombre del archivo físico sobre el que queremos trabajar.del archivo físico sobre el que queremos trabajar.

– Incluyendo el camino completo y la unidad en caso de que fuera necesario.

• modo (cadena de caracteres): indica el uso que vamos a hacer del fichero o archivo (ver la siguiente transparencia)

• El valor de retorno de fopen():El valor de retorno de fopen():

– Éxito: El puntero al comienzo del área del buffer.

– Fracaso: devuelve NULL si no se pudiera abrir el fichero.



Operaciones básicas con archivos• Apertura de un archivo: ModoApertura de un archivo: Modo

– “r”» Abre un archivo existente solo para lectura.

– “w”Ab hi l i E d i i hi» Abre un nuevo archivo solo para escritura. En caso de existir un archivo con ese nombre, lo borra y crea un nuevo archivo vacío.

– “a”» Abre un archivo para añadir. Si el archivo no existe crea uno nuevo, pero si

i t b t id S i i l fi l d l hi d fexiste no borra su contenido. Se posiciona al final del archivo de forma que sucesivas escrituras se añaden al final del archivo original.

– “r+”» Abre un archivo existente para actualizarlo (tanto para lectura como para

it )escritura).– “w+”

» Abre un archivo nuevo para lectura y escritura. Si existiera un archivo con ese nombre, lo borra y crea un nuevo archivo vacío.

– “a+”» Abre un archivo existente para leer y añadir. Si no existiera el archivo se creará

uno nuevo.– ‘b’

» Hay que añadirle a cualquiera de los modos anteriores cuando se esté trabajando con datos binarios.




Ejemplo Función fopen(). Apertura para leer y escribir.

#include <stdio h>#include <stdio.h>...int main(void){

FILE *pfich;...

pfich=fopen(“c:\\temp\\pepe.txt”,“r+”);/*Apertura*/

if(pfich==NULL){ /*Comprobamos apertura*/printf(“Error: No se puede abrir el archivo.\n”);

}...return 0;

}




• Cierre de un archivo: fclose()

– Su objetivo es liberar el espacio del área del bufferSu objetivo es liberar el espacio del área del buffer.

– Se escriben a disco todos los datos que aún queden en el buffer, se “desconecta” el archivo del programa y se libera el puntero al archivo.

– Es obligatorio cerrar un fichero cuando se haya terminado con su uso dentro del programa.

– Siempre que queramos cambiar la forma de acceso al fichero (modo)Siempre que queramos cambiar la forma de acceso al fichero (modo), también será necesario cerrarlo y volverlo a abrir especificando el nuevo tipo de acceso para el manejo del fichero.

f h d b d h b l• Un fichero no puede abrirse mas de una vez sin antes haberlo cerrado.



Operaciones básicas con archivos• Cierre de un archivo fclose()• Cierre de un archivo: fclose()

– Prototipo de la función:

int fclose(FILE *puntero al archivo);( p _ _ );

• puntero_al_archivo: es el puntero a archivo devuelto por la función fopen() al abrir el archivo que se desea cerrar.

l l d l l f ó• El valor devuelto por la función es:

0: si el archivo se cerró con éxito,

‐1: si ocurrió algún tipo de error al cerrarlo1: si ocurrió algún tipo de error al cerrarlo

Independientemente del valor de retorno, el archivo se cierra.

Un error típico es que el disco se ha llenado y no se ha podido vaciar el buffer con la consiguiente pérdida de datos

Ejemplo Función fclose(). Cierre fichero “pepe.txt” ejemplo anterior.

if(fclose(pfich)!=0){printf(“Error al cerrar el archivo\n”);



printf( Error al cerrar el archivo\n );printf(“Posible pérdida de datos”);

}

Operaciones básicas con archivos#include <stdio.h>

int main(void)Declaración de un

{

FILE *pfich;

Declaración de un puntero a archivo

Apertura en modo escritura pfich = fopen(“datos.txt”,”w”);

if (pfich == NULL) {

(w) del archivo “datos.txt”

Comprobación de que la t h id t

(p ) {

printf(“\n Error al abrir el fichero”);

}

... /* Se utiliza el archivo para escritura */

apertura ha sido correcta

Cierre del archivo y comprobación de si... / Se utiliza el archivo para escritura /

/* Al acabar de usar el archivo */

if (fclose(pfich) != 0) {

printf(”\n Error al cerrar el archivo “);

Cierre del archivo y comprobación de si se ha realizado correctamente

printf( \n Error al cerrar el archivo );

}

return 0;

}



}

33

Tipos de archivos



Tipos de archivos• Tipos de archivo:

– Texto.• Archivos ASCII planos, obtenidos y manejados desde programa utilizando cadenas

de caracteres.• Se pueden ver con un editor de texto.

– Binario.• Archivos con los datos guardados como copia exacta de la memoria del ordenador g p

(binario).• Sólo comprensible desde un programa que “sepa” qué tipos de datos contiene el

archivo y de qué forma están guardados.• Si se visualizan con un editor de texto no son comprensibles.• Los archivos binarios y los programa que utilizan archivos binarios no son fácilmente

portables a otros ordenadores y otros compiladores (el tamaño de las variables puede variar).

• Los archivos de texto son legibles y fáciles de portar, pero ocupan más espacio para almacenar la información.

• Los archivos binarios no son legibles con un editor de texto y no son portables de un ordenador a otro, pero ocupan menos espacio

• Ejemplo: variable entera de valor 2563 (texto: 4 bytes; binario: 2 bytes).



Tipos de archivos• Creación de un archivo:

– Un archivo secuencial debe ser creado antes de ser procesado.Formas de crear un archivo:– Formas de crear un archivo:

• Directamente: Mediante el uso de un editor de texto (sólo para archivos de texto).I di t t M di t ib i f ió• Indirectamente: Mediante un programa que reciba información, la procese y la guarde en un archivo (tanto para archivos de texto o como binarios).

l i d hi í ú l i d hi• La lectura y escritura de archivos varía según el tipo de archivos:– Texto: fprintf, fscanf, getc, putc, fgets, fputs– Binarios: fwrite, fread, fseek, ,



44

Archivos de texto

Archivos de Texto

• Son los archivos que contienen caracteres ASCII.• Apertura y cierre de fichero.

– Según lo visto en las transparencias anteriores.• Los archivos guardan caracteres ASCII:

E ibl ili l f i d bibli ili d– Es posible utilizar las funciones de biblioteca utilizadas para escribir o leer cadenas vistas a lo largo del curso.

– La diferencia está en que ahora cuando se utilicen estas funciones hay que incluir el puntero al buffer del fichero• putc(caracter,puntero)• getc(puntero)• getc(puntero)• fputs(cadena,puntero)• fgets(cadena,numero de caracteres,puntero)• fprintf(puntero,cadena de control,variables)• fscanf(puntero, cadena de control,variables)



Archivos de Texto

L f i f i f() f f()• Las funciones fprintf() y fscanf():– Las propias funciones se encargan de realizar las conversiones de formato que son necesarias para poder transformar los valores binarios usados internamente en el ordenador a cadenas de caracteres usadas en losinternamente en el ordenador a cadenas de caracteres usadas en los archivos de texto.

• fprintf():El funcionamiento es idéntico al de printf() salvo que ahora es necesario– El funcionamiento es idéntico al de printf() salvo que ahora es necesario indicar en qué archivo ha de escribir.

– Valor de retorno: • Éxito: devuelve el número de bytes que ha escrito• Éxito: devuelve el número de bytes que ha escrito• Fracaso: devuelve EOF

fprintf (FILE *puntero_al_archivo, const char *cadena_de_formato,...);

Ejemplo Función fprintf(). Escritura en el fichero “pepe.txt”.

... /*Apertura realizada*/

fprintf(pfich,”El valor de %d en hexadecimal es %x\n”,15,15);



Archivos de Texto

f f()• fscanf():– El funcionamiento es idéntico al de scanf() salvo que ahora es necesario indicar de qué archivo ha de leer.

– Valor de retorno (cuando sólo se lee un valor): • Éxito: devuelve el valor 1 si ha leído correctamente• Fracaso: devuelve 0 si ha ocurrido un error en la lectura por una mala pespecificación de formato.

• EOF: si no se ha leído nada porque se ha llegado al final del archivo.

– Valor de retorno (cuando se lee más de un valor): ( )• El valor devuelto es igual al número de datos leídos si se ha leído correctamente(devuelve el número de argumentos que han sido leídos y a los que se le ha asignado un valor.)

• Si se ha producido algún error antes de leer todos los datos el valor devuelto es igual al número de datos leídos correctamente.

• EOF: si no se ha leído nada porque se ha llegado al final del archivo.

int fscanf (FILE *puntero_al_archivo, const char *cadena_de_formato,...);



Ejemplo Manejo de archivos.8.- Archivos de texto

Diseñar un programa que escriba en el fichero “c:\temp\pepe.txt” los números 1.3, 3.4, 4.5 y 123.4 en líneas separadas y cierre el fichero. A continuación es programa abrirá el fichero para lectura, leerá todos los datos introducidos anteriormente los sumará e imprimirá la suma El hi t t ti d é danteriormente, los sumará e imprimirá la suma.

#include <stdio.h>#

• El archivo pepe.txt contiene después de escribir:

1.33.44.5#include <stdlib.h>

int main(void){int n; /*Valor devuelto por fscanf*/

/*P l h */

4.5123.4

• El resultado sería:El valor de la suma es: 132.600000

FILE *fichero; /*Puntero al archivo*/double dato; /*Dato leído del fichero*/double sum_tot; /*Suma de los datos*/

/* b l f h d d *//*Abrimos el fichero para introducir datos*/fichero=fopen("c:\\temp\\pepe.txt", "w");if(fichero==NULL){

printf("Error de apertura");}}else{

fprintf(fichero,"1.3\n3.4\n4.5\n123.4");



1 2

1 2

8.- Archivos de texto/*Cerramos el fichero*/if(fclose(fichero)!=0){

printf("Error al cerrar le fichero\n");}}

}/*Abrimos el fichero para leer datos*/

fichero=fopen("c:\\temp\\pepe.txt", "r");

if(fichero==NULL)printf("Error de apertura");printf( Error de apertura );

else{

sum_tot=0.0;

n=fscanf(fichero,"%lf",&dato);

while((n == 1)) {while((n 1)) {sum_tot=sum_tot+dato;

n=fscanf(fichero,"%lf",&dato);}



1 3

8.- Archivos de texto

/*Imprimimos la suma*/

printf(" El valor de la suma es : %lf\n",sum tot);

1 3

printf( El valor de la suma es : %lf\n ,sum_tot);

/*Cerramos el fichero*/

if i ! 0if(fclose(fichero)!=0){

printf("Error al cerrar el fichero\n");

}}

}



Archivos de Texto

(No las usuremos en este curso para archivos de texto)• Las funciónes fgets(), fputs(), getc() ó fgetc(), putc() ó fputc()

Son funciones que escriben o leen un carácter (fgetc() getc() fputc() putc()) o– Son funciones que escriben o leen un carácter (fgetc(), getc(), fputc(), putc()) o cadenas de caracteres (fgets(), fputs())

– No realizan conversión de formatos (todo se hace con caracteres)

• Lectura de un carácter:Lectura de un carácter: int fgetc(FILE *puntero_a_archivo) ó int getc(FILE *puntero_a_archivo)

– Leen el siguiente carácter del archivo.g– Valor de retorno:

• Éxito: el carácter leído• Fracaso: Si llega al final de fichero u ocurre un error, el valor de retorno es EOF.

• Escritura de un carácter: int fputc(int car, FILE * puntero_a_archivo) ó int putc(int car, FILE * puntero_a_archivo)

– Escriben el carácter car en el archivo al que apunta puntero_a_archivo. – Valor de retorno:

• Éxito: el propio carácter escrito



• Error: EOF

Archivos de Texto(No lo usuremos en este curso para archivos de texto)( p )

#include <stdio.h>#include <stdlib.h>#i l d < t h>#include <ctype.h>int main(void){

FILE *punt;p ;char c;punt=fopen("datos.txt","w");if (punt==NULL) {

i tf("\ E NO SE PUEDE ABRIR EL FICHERO")printf("\n Error – NO SE PUEDE ABRIR EL FICHERO");}else {

do {c = toupper(getchar());putc(c, punt);

}while (c != '\n');if (f l ( t) ! 0) {if (fclose(punt) != 0) {

printf("Error al cerrar el fichero");}

}



return 0;}

Cadena de caracteres: fgets(), fputs()(No las usuremos en este curso para archivos de texto)• Lectura de una cadena de caracteres:

char * fgets(char *cadena, int tam cad, FILE *punt a arch)char fgets(char cadena, int tam_cad, FILE punt_a_arch)

La cadena leída se almacena en esta variable

La lectura termina cuando:- Encuentra el \n (que sí se copia)

Encuentra el fin de fich (no se escribe \n)

Al final de la cadena siempre se añade el ‘\0’

– Valor de retorno:• Éxito: es un puntero a la cadena leída.

- Encuentra el fin de fich (no se escribe \n)- Se han leído (tam_cad-1) caracteres

• Fracaso: NULL, si se llega al final de fichero u ocurre un error

• Escritura de una cadena de caracteres:i f ( h * d FILE * h)int fputs(const char *cadena, FILE *punt_a_arch)

V l d t

Escribe la cadena en el archivo al que apunta punt a arch SIN EL ‘\0’ DEL FINAL

– Valor de retorno:• Éxito: número positivo si se ha escrito la cadena correctamente• Error: EOF

p _ _



Archivos de Texto

(No las usuremos en este curso para archivos de texto)• Lectura de una cadena de caracteres:

char * fgets(char *cadena, int tam cad, FILE *puntero a archivo).char fgets(char cadena, int tam_cad, FILE puntero_a_archivo).– Lee una cadena de caracteres del archivo apuntado por puntero_a_archivo y la almacena en cadena.La lectura se acaba cuando se encuentra el carácter ‘\n’ (que SÍ se escribe en– La lectura se acaba cuando se encuentra el carácter \n (que SÍ se escribe en la cadena), cuando se encuentra el fin de fichero (en este caso no se escribe ‘\n’ en la cadena) o cuando se han leído tam cad‐1 caracteres. En todos estos casos, se escribe un carácter ‘\0’ en la _ , \cadena a continuación del último carácter leído.

– Valor de retorno:• Éxito: es un puntero a la cadena leída.Éxito: es un puntero a la cadena leída.• Fracaso: NULL, si se llega al final de fichero u ocurre un error

• Escritura de una cadena de caracteres: int fputs(const char *cadena FILE *puntero a archivo)int fputs(const char cadena, FILE puntero_a_archivo)

– Escribe la cadena en el archivo al que apunta puntero_a_archivo SIN EL ‘\0’ DEL FINAL.V l d t



– Valor de retorno:• Éxito: número positivo si se ha escrito la cadena correctamente• Error: EOF

Ejemplo• Escribir un programa que calcule las pérdidas que tendría un almacén si explotase (es

decir, perdiera todos los productos que tiene en el almacén). La información almacenada de cada producto es:

b d l d– Nombre del producto– Número de unidades de ese producto en el almacén– Precio unitario

Por lo tanto para poder guardar la información de cada producto será necesario• Por lo tanto, para poder guardar la información de cada producto, será necesario crearse un tipo de estructura T_PRODUCTO con los campos anteriormente citados.

• La información de todos los productos existentes en el almacén está contenida en un fichero de texto llamado “almacen.txt” y que deberá crearse el alumno (se puedo utilizar el ejemplo proporcionado por el profesor en este enunciado) en un editor de texto ASCII (el editor del MinGW es ASCII) para poderlo leer desde su programa.

• En el programa principal se debe declarar un vector estático de estructuras T PRODUCTO para almacenar posteriormente la información de todos los productosT_PRODUCTO para almacenar posteriormente la información de todos los productos del almacén (asignación estática de memoria).

• El fichero de texto tiene la información de todos los productos, por lo que será necesario ir leyendo el fichero y rellenando el vector de estructuras de tipo T PRODUCTO Una vez finalizada la lectura del fichero de texto hasta encontrar el finlaT_PRODUCTO. Una vez finalizada la lectura del fichero de texto hasta encontrar el finladel fichero, será necesario cerrar dicho fichero.



Ejemplo• Un ejemplo de este fichero de entrada sería:

mechas1240detonadores23456456dinamita23100100mecheros4100

• Una vez finalizada la lectura de todos los productos se le debe mostrar al usuario la lista de los productos existentes en el almacén utilizando la función MostrarAlmacen().

• Para calcular cuál sería la pérdida total al destruirse el almacén, se ha de utilizar la f ió P did T t l() d l l é did t t l t d á l i i tfunción PerdidaTotal() que devuelve la pérdida total, y que tendrá el siguiente prototipo:

double PerdidaTotal(T_PRODUCTO *tabla, int num_productos);









44

Archivos Binarios

Archivos binarios

• Los archivos binarios se utilizan para almacenar la información como una copia exacta de la memoria del ordenador.

• Normalmente, no se pueden ver con un editor de texto, pues sería unaNormalmente, no se pueden ver con un editor de texto, pues sería una casualidad que los bytes que contienen fuesen caracteres legibles.

• Útil cuando se desea guardar en un archivo bloques de información Permite escribir los bloques de una sola vez sin necesidad de escribir cada• Permite escribir los bloques de una sola vez sin necesidad de escribir cada uno de sus componentes.

• Problema de portabilidad• Es necesario al abrir el fichero poner en el modo ‘b’ de binario.• Permiten el acceso directo a los datos en el archivo



Archivos binarios

• En estos casos utilizaremos las funciones fwrite() y fread():– Ambas funciones hacen un acceso directo a la memoria del ordenador a partir de la dirección de estructura.

– Escritura:size_t fwrite(void *estructura, size_t tam, size_t numero, FILE *archivo);

• Toma un número (tam* numero) de bytes de la memoria a partir de la dirección estructura y los escribe en el archivoestructura y los escribe en el archivo.

• Valor de retorno: el número de elementos que ha escrito (es decir, numero)– Lectura:size t fread (void *estructura, size t tam, size t numero, FILE *archivo);_ ( , _ , _ , );

• Lee del archivo un número (tam* numero) de bytes y los guarda a partir de la dirección de memoria estructura.

• Valor de retorno: el número de elementos que ha leído(es decir, numero)



Función fread() – Ejemplo 1// Programa que lee todos los registros en el fichero items.dat

E l j l t // y muestra el contenido en la pantalla// El número de registros no se conoce de antemano

#include <stdio.h>

En el ejemplo tenemos en cuenta que fread() devuelve el número de elementos leídos del archivo. Si se leen menos elementos de los pedidos en la #include <stdlib.h>

typedef struct{char nombre[20]; int existencias;

elementos de los pedidos en la llamada o bien ha ocurrido un error, o bien se han alcanzado el fin del fichero.

float precio_unitario; }T_ITEM;

int main()

En este caso sólo se lee un elemento y, por lo tanto, el bucle while continúa leyendo nuevos registros hasta que el

l d l f d() {FILE *p_fich;T_ITEM item;if((p_fich = fopen ("items.dat", "rb"))==NULL) {

valor devuelto por fread() sea distinto de 1.

printf("ERROR. No se puede abrir el fichero para lectura\n");}else {

while(fread(&item, sizeof(T_ITEM), 1, p_fich) == 1) {printf("\nNombre del item => %s\n", item.nombre); printf("Existencias => %d\n", item.existencias); printf("Precio unitario => %.2f\n", item.precio_unitario);

}


Tema 1: Introducción. Arquitectura básica y Sistemas Operativos 37

fclose(p_fich);}return 0;

}

Función fread() – Ejemplo 2#include <stdio.h> El ib i #include stdio.h#include <stdlib.h>int main(void){

FILE *fp;

El programa escribe cinco números de tipo double del vector bal a un fichero de disco llamado test y, a continuación, se leen del disco FILE fp;

int i;double bal[5] = {1.1, 2.2, 3.3, 4.4, 5.5};

fp=fopen("test.dat", "wb+");

se leen del disco.

El valor que devuelve fread()—5 en este caso— se usa para comprobar el resultado de la p ope ( test dat , b );

if (fp==NULL) {printf("\nNo se puede abrir el fichero\n");

} else {

poperación de lectura. En el ejemplo se quiere constatar que fread() puede retornar valores diferentes a 1.{

fwrite(bal, sizeof(double), 5, fp); rewind(fp);if(fread(bal, sizeof(double), 5, fp)!=5) {

printf("\nError al leer el fichero\n");p ( \ \ );}else {

for(i=0; i<5; i++)printf("%.2f ", bal[i]); p ( , [ ]);

fclose(fp); }

}return 0;



;}

Archivos binarioEjemplo: Almacenamiento de estructuras en archivos de binarios

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

Ejemplo: Almacenamiento de estructuras en archivos de binarios

Resultado: no se puede ver pero#include <string.h>#define N 2/* Declaración de una estructura para los productos

*/

Resultado: no se puede ver pero ocupa 28 caracteres (ya que cada estructura ocupa 16 bytes)

typedef struct {char nombre[12];int precio;

Apertura en modo binario

/*** Creo el archivo ***/f=fopen("datos dat" "wb");}T_PROD;

int main(void)Tamaño de la

f=fopen( datos.dat , wb );if (f==NULL) {

printf("Error al crear el archivo datos.dat\n");}{

T_PROD producto[N]; int i; /* contador para los bucles*/

FILE *f; /* Descriptor del archivo de texto */

Tamaño de la estructura

}else {

for (i=0; i<N; i++) {f it (& d t [i] i f( d t [i]) 1 f)FILE f; / Descriptor del archivo de texto /

/*** Inicializo del vector ***/strcpy(producto[0].nombre,"CD Rosana");

fwrite (&producto[i] , sizeof(producto[i]) ,1, f);}fclose(f);

}



strcpy(producto[0].nombre, CD Rosana );producto[0].precio=2563;strcpy(producto[1].nombre,"CD Titanic");producto[1].precio=2628;

Dirección de la estructura a escribir

}return 0;

}

Archivos binarios

#include <stdio.h>#include <stdlib.h>typedef struct{

punt=fopen("datos.dat","rb");

f ( ) {typedef struct{char nombre[30];int edad;

}T_Ficha;int main(void)

if (punt==NULL) {printf("\n Error al abrir el fichero ");

}else {

int main(void){ FILE *punt;

T_Ficha ficha;T_Ficha ficha2;

t f ("d t d t" " b")

puts("\nYa hemos leido el fichero y contiene:\n");fread(&ficha2, sizeof(T_Ficha), 1 , punt);printf("NOMBRE: ");puts(ficha2.nombre);punt=fopen("datos.dat","wb");

if (punt==NULL) {printf("\n Error al abrir el fichero ");

}l {

puts(ficha2.nombre);printf("EDAD: ");printf("%d",ficha2.edad);

if (f l ( t) ! 0) {else {printf("Introduzca el nombre de la persona:\n");fgets(ficha.nombre, 30, stdin);printf("Introduzca la edad de la persona:\n");

if (fclose(punt) != 0) {printf(“Error al cerrar el fichero “);

}}

scanf("%d",&(ficha.edad));fwrite(&ficha, sizeof(T_Ficha), 1, punt);

if (fclose(punt) != 0) {

return 0;}



( (p ) ) {printf(“Error al cerrar el fichero “);

}}

Archivos binarios#include <stdio.h>

Ejemplo Opción 1

#include <stdio.h>#include <stdlib.h>#define N 5typedef struct{

char nombre[30];int edad;

punt=fopen("prueba.txt ","rb");

int edad;}T_Ficha;void main(void){

FILE *punt;h f h

if (punt==NULL) {printf("\n Error abriendo el fichero ");

}else {

T_Ficha ficha;T_Ficha lista[N];int cont;punt=fopen(“prueba.txt","wb");if (punt==NULL) {

Lectura de una estructura cada vez

puts("\nYa hemos leido el fichero y contiene:\n");

for (cont=0;cont<N;cont++) {fread(&lista[cont], sizeof(T Ficha),1,punt);(p ) {

printf("\n Error abriendo el fichero ");}else {

for (cont=0;cont<N;cont++) {fflush(stdin);

( [ ], ( _ ), ,p );printf("NOMBRE: ");puts(lista[cont].nombre);printf("EDAD: ");printf("%d\n" lista[cont] edad);fflush(stdin);

printf("Introduzca el nombre de la persona:\n");

gets(ficha.nombre);printf("Introduzca la edad de la persona \n")

printf( %d\n ,lista[cont].edad);}if (fclose(punt) != 0 ) {

printf(“Error al cerrar el archivo”);persona:\n");scanf("%d",&ficha.edad);fwrite(&ficha, sizeof(T_Ficha), 1, punt);

}if (fclose(punt) != 0 ) {

}} /* del else*/

}



if (fclose(punt) ! 0 ) {printf(“Error al cerrar el archivo”);}

} /* del else */

Archivos binarios#include <stdio h>

Ejemplo Opción 2

#include <stdio.h>#include <stdlib.h>#define N 5typedef struct{

char nombre[30];

If (fclose(punt) != 0 ) {printf(“Error al cerrar el archivo”);

}char nombre[30];int edad;

}T_Ficha;int main(void){ Lectura de las N

}}punt=fopen("prueba.txt ","rb");if (punt==NULL) {

printf("\n Error abriendo el fichero ");{FILE *punt;T_Ficha ficha;T_Ficha lista[N];int cont;

Lectura de las N estructuras a la vez

printf( \n Error abriendo el fichero );}

else {puts("\nYa hemos leido el fichero y contiene:\n");

punt=fopen(“prueba.txt","wb");if (punt==NULL) {

printf("\n Error abriendo el fichero ");}

l {

fread(lista, sizeof(T_Ficha),N ,punt);for (cont = 0; cont < N; cont++) {

printf("NOMBRE: ");t (li t [ t] b )else {

for (cont=0;cont<N;cont++) {fflush(stdin);printf("Introduzca el nombre de la

persona:\n");

puts(lista[cont].nombre);printf("EDAD: ");printf("%d\n",lista[cont].edad);

}persona:\n");

fgets(ficha.nombre, 30, stdin);printf("Introduzca la edad de la

persona:\n");scanf("%d" &(ficha edad));

If (fclose(punt) != 0 ) {printf(“Error al cerrar el archivo”);

}



scanf( %d ,&(ficha.edad));fwrite(&ficha, sizeof(T_Ficha), 1, punt); }

return 0;}

Archivos binarios• Permiten el acceso directo a los datos en el archivo utilizando la función

fseek().• Prototipo:

size_t fseek(FILE *archivo, long posicion, int origen);– archivo :

• Puntero al buffer del fichero con el que estamos trabajando.q j– posicion :

• Desplazamiento en bytes a partir de lo que indique origen– origen :origen :

• Especifica donde comienza la búsqueda.– SEEK_CUR: Posición actual del puntero.– SEEK END: Final del fichero._– SEEK_SET: Comienzo del fichero

• Valor de retorno:– Éxito: devuelve 0 (cuando el puntero del archivo se ha movido– Éxito: devuelve 0 (cuando el puntero del archivo se ha movido satisfactoriamente)

– Fracaso: devuelve un valor distinto de 0



Archivos binarios

• Ejemplos: fseek(fp,0,SEEK_SET); /* Va a la primera posición del archivo */f k(f * f( ) ) /* l d */fseek(fp,10*sizeof(T_PRODUCTO),SEEK_SET); /* Va al 11º producto */fseek(fp,2*sizeof(T_PRODUCTO),SEEK_CUR); /* Se salta dos productos desde la poisción actual */



typedef struct {

fseek(): Un ejemplo sencillo typedef struct {

char nombre[40];char calle [30];char ciudad[30];char provincia[20];

La siguiente función busca la estructura num cliente char provincia[20];

int cod_postal;}T_INFO;

void Buscar(int num cliente)

estructura num_cliente especificada de tipo T_INFO

void Buscar(int num_cliente){

FILE *fp;T_INFO info;

if((fp=fopen("correo.dat", "rb"))==NULL) {printf("No se puede abrir el fichero.\n");

} else {else {

// Buscar la estructura escogidafseek(fp, num_cliente*sizeof(T_INFO), SEEK_SET);

// Leer la información a memoria// Leer la información a memoriafread(&info, sizeof(T_INFO), 1, fp);

fclose(fp);}



} }

Archivos binarios: ejemplo fseek()1/4

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

void introducir_datos(T_Lista lista){

int cont;

1/4

typedef struct{char nombre[30];int edad;

}T Ficha;

int cont;printf("Introduzca los nombres y edades de 5 personas: \n");for (cont=0;cont<5;cont++) {

fflush(stdin);}T_Ficha;typedef T_Ficha T_Lista[10];void introducir_datos(T_Lista lista);void pintar_datos(T_Lista lista);

id d fi h (T Li t li t )

( );printf("Introduzca el nombre de la persona:\n");gets(lista[cont].nombre);printf("Introduzca la edad de la persona:\n");scanf("%d",&lista[cont].edad);

}void guardar_fichero(T_Lista lista);void cargar_fichero(T_Lista lista);void modificar(void);

i t i ( id)

}}

void pintar_datos(T_Lista lista){int main(void)

{T_Lista lista,lista2;

{int cont;printf("\n:::::Los datos del fichero leido son:\n");for (cont=0;cont<5;cont++) {

printf("NOMBRE: ");introducir_datos(lista);guardar_fichero(lista);modificar();cargar_fichero(lista2);

p ( );puts(lista[cont].nombre);printf("EDAD: ");printf("%d\n",lista[cont].edad);

}}



g ( )pintar_datos(lista2);return 0;

}

}


void guardar_fichero(T_Lista lista){

FILE *punt;

void cargar_fichero(T_Lista lista){

FILE * t

2/4

FILE punt;int cont;

printf("\nGUARDANDO FICHERO....\n");punt=fopen("a:datos.juan","wb");

FILE *punt;int cont=0;printf("\nLEYENDO FICHERO.................\n");punt=fopen("a:datos.juan","rb");

if (punt==NULL) {printf("\nERROR");

}else {

if (punt==NULL) {printf("\n Error al abrir el fichero");

}else {

( f (& f( ) 1 )) 1) {else {

for(cont=0;cont<5;cont++) {fwrite(&lista[cont],sizeof(T_Ficha),1,punt);

}

while ( fread(&lista[cont],sizeof(T_Ficha),1,punt)) == 1) {cont++;

}

if (fclose(punt) != 0) {}

/* Otra opción en vez del bucle anterior fwrite(lista,sizeof(T_Ficha),5,punt); */

if (fclose(punt) != 0) {

if (fclose(punt) != 0) {printf(“Error cerrando el fichero “);

}printf("\n:::::FICHERO LEIDO:::::\n");

}if (fclose(punt) != 0) {printf(“Error al cerrar el archivo”);

}printf("\n:::::FICHERO GUARDADO:::::\n");

}

}



}}


void modificar(void){

FILE *punt;T Fi h i t

3/4

T_Ficha registro;int cont=0;char cadena[30];

fflush(stdin);printf("\nIntroduzca nombre a buscar:\n");gets(cadena);printf("\nLEYENDO FICHERO Y BUSCANDO NOMBRE SOLICITADO \n");printf( \nLEYENDO FICHERO Y BUSCANDO NOMBRE SOLICITADO..............\n );punt=fopen("datos.juan","rb+");if (punt==NULL) {

printf("\nERROR");}}else {

do {fread(&registro,sizeof(T_Ficha),1,punt);cont++;

} while ((strcmp(registro.nombre,cadena)!=0)&&(cont<5));

CONTINUA EN SIGUIENTE TRANSPARENCIA



CONTINUA EN SIGUIENTE TRANSPARENCIA


if (strcmp(registro.nombre,cadena)==0) {printf("\n..........INDIVIDUO ENCONTRADO..........\n");printf("\n...DATOS ACTUALES:\n");

i tf("NOMBRE % \ " i t b )

4/4

printf("NOMBRE: %s\n",registro.nombre);printf("EDAD: %d\n",registro.edad);printf("\n:::::INTRODUZCA NUEVOS DATOS:::::::::\n");fflush(stdin);printf("Introduzca el nombre de la persona:\n");gets(registro.nombre);printf("Introduzca la edad de la persona:\n");scanf("%d" &registro edad);scanf( %d ,&registro.edad);printf("\n..........MODIFICANDO LOS DATOS EN EL FICHERO..........\n");fseek(punt,(cont-1)*sizeof(T_Ficha),SEEK_SET);fwrite(&registro,sizeof(T_Ficha),1,punt);

i tf("\ DATOS MODIFICADOS EN EL FICHERO \ ")printf("\n..........DATOS MODIFICADOS EN EL FICHERO..........\n");

}else {

printf("\n::::EL NOMBRE SOLICITADO NO SE ENCUENTRA EN EL FICHERO::::\n");}if (fclose(punt) != 0) {

printf("\n:::::FICHERO GUARDADO:::::\n");



printf( \n:::::FICHERO GUARDADO:::::\n );}

}}

• Indica si se ha alcanzado el final del fichero apuntado por fp

Función feof()• Indica si se ha alcanzado el final del fichero apuntado por fp

• Prototipo: int feof (FILE *fp);fp : es un puntero a un fichero– fp : es un puntero a un fichero

• Valor devuelto:Un valor distinto de 0: cuando se intenta leer un registro del fichero y nos– Un valor distinto de 0: cuando se intenta leer un registro del fichero y nos encontramos con un EOF (fin del fichero)

– 0: en cualquier otro caso

• Permite leer un fichero cuando el número de registros no se conoce de antemano, leyendo registros hasta que se encuentra el fin del fichero

• feof() se puede usar tanto en ficheros binarios como de texto



feof(): Ejemplo de fichero binario// Programa para ilustrar el uso de la función feof() con un fichero binario#include <stdio.h>typedef struct{

char nombre[15];char nombre[15]; int existencias; double precio_unitario;

}T_ITEM; int main(void)int main(void){

FILE *fp;T_ITEM item;fp = fopen("items dat" "rb");fp = fopen( items.dat , rb );if(fp==NULL) {

printf("\nERROR. No se puede abrir el fichero para lectura\n"); }else {else {

fread(&item, sizeof(T_ITEM), 1, fp);while(!feof(fp)) {

printf("\nNombre=%-15s Existencias=%d Precio=%7.2f",item nombre item existencias item precio unitario);item.nombre, item.existencias, item.precio_unitario);

fread(&item, sizeof(T_ITEM), 1, fp); }fclose(fp);

}



} return 0;

}

Escuela Técnica Superior de Ingeniería ICAIAlberto Aguilera 2528015 MadridTel +34 91 542 28 00Tel +34 91 542 28 00Fax + 34 91 542 31 76Iwww.icai.upcomillas.es

www.upcomillas.es

Documents

Tema 10 AhiArchivos de datos - cartagena99.com 10.pdf · • Una operación de lectura de un fichero es parecida a una operación de ... – Es obligatorio cerrar un fichero cuando