E/S para archivos

Lenguaje C • Las funciones y tipos están definidos en

<stdio.h>

Manejo de Archivos • FILE

– Estructura que define un descriptor de archivo
• EOF
– Constante para detectar el fin del archivo

Modos de Apertura
Apertura de Archivos r Abrir para lectura. El archivo debe existir.

w Abrir para escritura. Se crea un archivo

• fopen nuevo o se sobreescribe si ya existe.

– Abre un archivo para su uso a Abrir para añadir datos al final. Si el archivo
no existe, se crea.

– FILE* fopen(char* nombre, char* modo); rb Abrir para lectura binaria.

wb Abrir para escritura binaria.

Devuelve el descriptor ab Abrir para añadir datos binarios.

Modo de apertura
del archivo para su uso posterior. (lectura, escritura, etc.) r+ Abrir para lectura/escritura. El archivo debe
NULL en caso de error existir.
Nombre del archivo a abrir
 Modos de Apertura
w+ Crear archivo para lectura/escritura. se crea Cierre de Archivos
un archivo nuevo o se sobreescribe si ya
existe.
• fclose
a+ Añadir, lectura y escritura. El cursor se situa
al final del archivo. Si el archivo no existe, – Cierra un archivo previamente abierto,
se crea. liberando los recursos asociados al programa.
r+b Abre para lectura/escritura binaria.

w+b Crea para lectura/escritura binaria. – int fclose(FILE* f);

a+b Abre o crea para añadir datos binarios.

Éxito de la operación Flujo a cerrar

(0 en caso de éxito)

Apertura y cierre Manejo de errores

#include <stdio.h>
• En C, muchas funciones modifican una variable
int main(){ global cuando ocurre un error.
FILE* archivo; • Esta variable puede ser consultada para saber más
archivo = fopen("test.txt","r"); acerca del error.
if(archivo!=NULL){
if(fclose(archivo)!=EOF) • La variable global se llama “errno”.
printf("Ok!\n"); – Se define en <errno.h>
else
printf("Error al cerrar!\n"); • La función “strerror(int e)” entrega una
}else descripcion de un código de error.
printf("Error al abrir!\n");
} – Se define en <string.h>
 Manejo de errores Lectura de carácteres
#include <stdio.h>
• fgetc
int main(){
– Lee un carácter desde un archivo abierto para
FILE* archivo; lectura.
archivo = fopen("test.txt","r");
if(archivo!=NULL){
if(fclose(archivo)!=EOF)
printf("Ok!\n"); – int fgetc(FILE* f);
else
printf("Error al cerrar!\n");
}else
printf("Error al abrir: %s\n",strerror(errno));
}
Devuelve el carácter leído como un entero. Descriptor de archivo
En caso de error, devuelve EOF

Lectura de carácteres Lectura de carácteres

int main(){
• fgets FILE* archivo;
– Lee desde un archivo abierto para lectura hasta archivo = fopen("test.txt","r");
if(archivo!=NULL){
un largo fijo o el fin de línea. char c;
do{
c = fgetc(archivo);
– fgets(char* cadena, int longitud, FILE* f); printf("%c",c);
}while(c!=EOF);
fclose(archivo);
}
}
Arreglo de caracteres donde Cantidad máxima de Descriptor de
guardar la cadena leída carácteres a leer archivo
 Lectura de carácteres Lectura de carácteres
int main(){
FILE* archivo; • Una función muy útil es “feof”, quien
archivo = fopen("test.txt","r");
if(archivo!=NULL){
detecta si se ha alcanzado o no el fin de
char* res; archivo.
char cadena[128];
do{
res=fgets(cadena,128,archivo);
if(res!=NULL) printf("%s",cadena); • feof
}while(res!=NULL);
– Devuelve verdadero si se ha alcanzado el fin de
fclose(archivo); archivo
}
}
– int feof(FILE* f);
1: Fin de archivo Descriptor de archivo
0: otro caso

Lectura de carácteres Lectura de carácteres

int main(){
FILE* archivo; • Existe una version de scanf para archivos
archivo = fopen("test.txt","r");
if(archivo!=NULL){
char cadena[128]; • int fscanf(FILE* f, char* fmt, ...);
while(!feof(archivo)){
fgets(cadena,128,archivo);
printf("%s",cadena);
}
fclose(archivo);
}
} Numero de conversiones Descriptor de Variables a
realizadas con éxito archivo Modificar (referencias!)
 Lectura de carácteres Escritura de carácteres
int main(){ • Cada función de lectura tiene su pareja
FILE* archivo;
archivo = fopen("test.txt","r");
if(archivo!=NULL){ • int fputc(int c , FILE* f);
char c; – EOF en caso de error
while( fscanf(archivo,"%c",&c)==1 ) • int fputs(char* cadena, FILE* f);
printf("%c",c); – EOF en caso de error
fclose(archivo); • int fprintf(FILE* f, char* fmt, ...);
} – Devuelve el numero de transformaciones
realizadas con éxito.
}

Escritura de carácteres Escritura de carácteres

archivo2 = fopen("test2.txt","w+"); do{
... res=fgets(cadena,128,archivo);
do{ if(res!=NULL){
c = fgetc(archivo); printf("%s",cadena);
if(c!=EOF){
fputs(cadena,archivo2);
fputc(c,archivo2);
}while(res!=NULL);
printf("%c",c);
}
}while(c!=EOF);
 Escritura de carácteres Escritura de carácteres
• fflush
while( fscanf(archivo,"%c",&c)==1 ){
– Vacia el buffer de escritura. Fuerza la salida del
printf("%c",c);
buffer hacia el disco.
fprintf(archivo2,"%c",c);
– int fflush(FILE* f);
}

Devuelve EOF en caso Descriptor de archivo

de error

Otras Funciones Manejo de Archivos con tipo

- void rewind(FILE *f): sitúa el cursor de lectura/escritura al principio del archivo.
semejante a Pascal
- size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)): lee desde un
archivo uno o varios registros de la misma longitud
- int fseek(FILE *fichero, long int desplazamiento, int origen): situa el cursor del …

archivo para leer o escribir en el lugar deseado. Retorna cero si la función tuvo struct {

éxito, y un valor distinto de cero si hubo algún error. int matricula;

char nombre[30];
El parámetro origen: int edad;} alumno;

void main() {
- SEEK_SET el desplazamiento se cuenta desde el principio del archivo. El primer FILE *archdisco;
byte del archivo tiene un desplazamiento cero. archdisco = fopen("alumnos.dat","at+"); // leyendo disco

- SEEK_CUR el desplazamiento se cuenta desde la posición actual del cursor. while ((!feof(archdisco)) {
fread(&alumno,sizeof(alumno),1,archdisco);
- SEEK_END el desplazamiento se cuenta desde el final del archivo. printf("MATRICULA = %d ",alumno.matricula);

printf(" NOMBRE = %s ",alumno.nombre);

printf(" EDAD = %d ",alumno.edad);

- long int ftell(FILE *fichero): devuelve la posición actual del cursor de printf("\n");

lectura/escritura, o -1 si hay algún error. }; // aqui termina while

fclose(archdisco);

}
 Manejo de Archivos con tipo
semejante a Pascal Ejercicios
- size_t fwrite(void *ptr, size_t size, size_t nmemb, FILE *stream)): escribe en un
fichero uno o varios registros de la misma longitud 1) Crear un archivo de texto de nombre “origen.txt” e inserte
…

struct { la frase “Primer ejercicio” utilizando la función fputc().

int matricula;
char nombre[30];
2) Copie el contenido de “origen.txt” en un nuevo archivo
int edad;} alumno;
“destino.txt” utilizando fgetc() para leer de “origen.txt” y
void main() {
// captura de campos fputs() para escribir en “destino.txt”.
printf("ingrese matricula :");scanf("%d",&alumno.matricula);getchar();

printf("ingrese nombre :");gets(alumno.nombre); 3) Añadir al final del archivo “destino.txt” la frase “con
printf("ingrese edad :");scanf("%d",&alumno.edad);

// grabando a disco
Archivos.”.
FILE *archdisco;
4) Recorrer y mostrar el contenido completo de “destino.txt”.
archdisco = fopen("alumnos.dat","at+");

fwrite(&alumno,sizeof(alumno),1,archdisco);

fclose(archdisco);

getchar();getchar();