Lenguaje C

Archivos
Conceptos generales
Fichero, en Espaa; file en ingls, se pronuncia faiil (i alargada y suave).

Un archivo es un espacio de memoria para almacenamiento de datos organizados, permanente o temporal; tiene un nombre y se guarda
generalmente en un disco, dos tipos de archivo muy utilizados son:

De texto: compuesto nicamente de caracteres sin formato (tamao, color, tipo de fuente); estos caracteres se pueden codificar con
la tabla ascii o de distintos modos, dependiendo de la lengua usada. Se les conoce tambin como archivos de texto llano, plano o
simple.
Binario: contiene informacin de cualquier tipo, codificada en forma binaria para el propsito de almacenamiento y procesamiento
de ordenadores. Partes de un archivo binario pueden ser interpretados como texto.

Operaciones bsicas en archivos:

Creacion : FILE *fptr; // Crea puntero fptr de tipo FILE
Apertura : fptr = fopen("test.txt", "w+"); // abre archivo test.txt, modo: w+ y lo apunta con fptr
Escritura : fprintf(fptr, "%d %s %f\n", 2, "abf", 3.4); // escribe datos: 2, "abf", 3.4 ; similar a printf()
Lectura : fscanf(fptr, "%d%s%f", &n, a, &ff) // lee datos a: n, arreglo a y ff ; similar a scanf()
Escritura : putc() // similar a putchar()
Lectura : getc() // similar a gerchar
Recorrido: fseek(...) // Se posiciona en un byte
Cierre : fclose(fptr) // cierra archivo apuntado por fptr

Las funciones generales para manejar archivos estn en la librera stdio.h.

El lenguaje C, FILE representa a un archivo con la estructura:

struct {
char *ptr; // puntero a buffer actual
int _cnt; // contador de byte actual
char *base; // direccin base de buffer E/S
char _flag; // flag (bandera) de control
char _file // fichero
}

// 10_01a.c: Escribir 2 registros de datos en el archivo test.txt

#include<stdio.h>
void main(void) {
FILE *fp; // declara el archivo "test.txt"
if((fp = fopen("test.txt", "w+")) != NULL){ // abre el archivo para escribir
fprintf(fp, "%d %s %f\n", 4, "abc", 4.2); // escribe datos: 4, "abc", 4.2
fprintf(fp, "%d %s %f\n", 2, "abf", 3.4); // escribe datos: 2, "abf", 3.4
fclose(fp); // cierra el archivo
} else printf("No pudo abrir el archivo test.txt\n");
}
Salida: ninguna

// 10_01b.c: leer los registros del archivo test.txt y los imprime

#include<stdio.h>
#include <stdlib.h>
void main(void) {
int dato1;
char dato2[4];
float dato3;
FILE *fp; // declara un archivo
if((fp = fopen("test.txt", "r"))==NULL) exit(1); // abre el archivo para leer
// leer y escribir registros:
while(fscanf(fp, "%d%s%f", &dato1, dato2, &dato3)>0) printf("%d %s %f\n", dato1, dato2, dato3);
fclose(fp); // cierra el archivo
}

PGINA: 1
 Lenguaje C
Salida:
4 abc 4.200000
2 xyz 3.400000

Ejercicio: Integre los dos programas en uno solo.

Principales funciones de archivos
Descripcin Sintaxis Ejemplos
Define apuntador a FILE *pf; FILE *pf;
archivo
Abrir archivo y apuntarlo FILE *fopen(const char *miArchivo, const char *modo) pf = fopen("test.txt", "r");
Entradas: pf = fopen("test.txt", "w+");
miArchivo: nombre del archivo fsico
modo: modo de apertura:
lectura : "r"
escritura : "w" Si existe miArchivo, graba encima.
Si no existe, lo crea.
Aadir "a" : Si existe miArchivo, lo contina.
Si no existe, lo crea.
Lectura/escritura: "w+"
Hay ms modos.
Proceso: abre a miArchivo
Salida: puntero a file.
Indicador de fin de int feof(FILE *pf); // eof: end of file While (!feof(pf)) {... }
archivo Entrada:
pf: Apuntador a archivo
Proceso: indica si se lleg a fin de archivo
Salida:
0 (falso) si no es fin de archivo
!=0 si es fin de archivo
Leer datos int fscanf(FILE *pf, const char *formato, .); // lee y escribe registros
Entradas: while(fscanf(fp, "%d%s%f", &dato1, dato2,
pf: Apuntador a archivo &dato3)>0) printf("%d %s %f\n", dato1,
formato: puntero de formato dato2, dato3);
lista de variables para el formato.
Proceso: Lee caracteres hasta que aparezca un espacio
en blanco ('\0') o LF ('\10' nueva lnea); similar a scanf()
Salida: Nmero de datos ledos, si no lee: -1
char *fgets(char *buff, int n, (FILE*)pf); #include <stdio.h>
Entradas: #include <stdlib.h>
buff: Cadena que contendr la cadena leda void main(void){
n: Se leern n-1 caracteres o hasta LF ('\10' nueva FILE *pf;
lnea) o fin de archivo (EOF) char dato[100];
pf: Apuntador a archivo de lectura if((pf = fopen("test.txt","r"))== NULL) exit(1);
Proceso: Lee una cadena de caracteres, similar a gets() while(fgets(dato, 100, pf) != NULL)
Salida: apuntador a buff printf("%s",dato);
fclose(pf);
}
char fgetc(FILE *pf); // lee e imprime todo el archivo
Entrada: char cc = fgetc(pf);
pf: Apuntador a archivo while (!feof(pf)) {
Proceso: Lee un caracter de pf, similar a getchar() printf("%c", cc);
Salida: Caracter ledo cc = fgetc(pf);
}
Escribir en archivo Int fprintf(FILE *pf, const char *formato, .); fprintf(pf, "%d %s %f\n", 2, "ab c", 3.4);
Entradas: // atento: dejar espacio entre formatos
pf: Apuntador a archivo de escritura
formato: formato de impresin
lista de variables a imprimir segn el formato
Proceso: imprime lista de variables, similar a printf()
Salida: 1 exitoso, 0 error
PGINA: 2
 Lenguaje C
int fputs(const char *buff, FILE *pf) char *dato = "hola mundo";
Entradas: fputs(dato, pf );
buff: una cadena
pf: apuntador a archivo de escritura
Proceso: Escribe buff en pf, similar a puts().
Salida: 0 en caso de xito; EOF en caso contrario.
int fputc(int cc, FILE *pf); // lee caracteres del teclado y los escribe en un
Entradas: archivo e imprime en el monitor
cc: entero a escribir char cc;
pf: apuntador a archivo de escritura while((cc = getchar()) != '\n') {
Proceso: Escribe cc en pf, similar a putc() printf("%c", fputc(cc, fp));
Salida: cc en caso de exito, EOF en caso contrario }
Escribir un arreglo. size_t fwrite(void *ptr, size_t size, size_t n, FILE *pf); #include <stdio.h>
Entradas: #include <string.h>
Se aparea con fread()
ptr : apuntador a arreglo a escribir void main (){
size: tamao de los elementos del arreglo FILE *fp;
n : nmero de elementos a escribir char cc1[] = "El sur tambin existe.", cc2[60],
pf : apuntador a archivo de escritura *pcc2 = cc2;
Proceso: Escribe el arreglo ptr de n elementos de tamao int l1 = strlen(cc1), l2;
size en pf. printf("%d: %s\n", l1, cc1);
Salida: nmero de elementos escritos, no el nmero de
bytes. fp = fopen ( "fichero.txt", "w+" );
fwrite( cc1, sizeof(char), l1, fp );
Leer un arreglo size_t fread (void *ptr, size_t size, size_t n, FILE *pf);
rewind( fp );
Entradas:
Se aparea con fwrite()
ptr : apuntador a arreglo que recibir datos
size: tamao de los elementos
l2 = fread (pcc2, sizeof(char), l1, fp);
n : nmero de elementos a leer
printf("%d: %s\n", l2, pcc2);
pf : apuntador a archivo de lectura
fclose(fp);
Proceso: Lee n elementos de tamao size al arreglo ptr
}
desde pf. El indicador de posicin de la cadena de
caracteres avanza hasta leer la totalidad de bytes. Salida:
Salida: size * n si fread es exitoso. 23: El sur tambin existe.
23: El sur tambin existe.
Podemos considerar un Int fseek(FILE *pf, size_t offset, int origen) // imprime todos los bytes de un archivo
archivo como un arreglo Entradas: long offset = 0L;
en disco duro y ubicarnos pf: apuntador a archivo FILE *fp;
en cualquier posicin. offset: desplazamiento a partir del origen fp = fopen ("fichero.txt", "r" );
origen: 0 principio del fichero while(fseek(pf, offset++,0) == 0)
1 posicin actual putchar(getc(pf));
2 final del archivo fclose (fp);
Proceso: Se ubica un byte del archivo pf
Salida: 0 si no hay error
rebobinar (rewind, se void rewind(FILE *pf); rewind(pf);
pronuncia riwaind) sita Entrada:
el cursor de pf: apuntador a archivo
lectura/escritura al inicio Proceso: Rebobina el archivo (vuelve al inicio)
del archivo.
Cerrar archivo y poner FILE *fclose(FILE *pf) fclose(pf);
nulo a puntero Entrada: pf: apuntador a archivo
Proceso: cierra un archivo fsico.
Salida: apuntador a archivo

PGINA: 3
 Lenguaje C
Ejercicio: Replique el ejemplo de fread() y fwrite() de la tabla anterior para arreglo de tipo entero
/* 10_02.c: Declarar una estructura (registro), asignarle valores
a los campos e imprimir el registro.
Escriba el registro dos veces en un archivo.
Lea los registros del archivo e imprima los datos de cada
registro.
*/
#include <stdio.h>
struct Datos {
int dato1;
char dato2[4];
int dato3[2];
};
void print(struct Datos *p);
void main (void){
struct Datos in ={1, "abc", 2, 3}, *pin = &in,
out, *pout = &out;
int nlen = sizeof(in);
FILE *fp;
printf("Entrada\n");
print(pin);

fp = fopen ("fichero.txt", "w+"); // Escrituras

fwrite(pin, nlen, 1, fp );
fwrite(pin, nlen, 1, fp );
rewind(fp);

printf("Salidas\n");
while(fread(pout, nlen, 1, fp) >0 ) print(pout);
fclose (fp);
}
void print(struct Datos *p){ // Impresin
printf("%d \n", p->dato1);
printf("%s \n", p->dato2);
printf("%d \n", p->dato3[0]);
printf("%d \n", p->dato3[1]);
printf("------\n");
}
Salida:
Entrada
1
abc
2
3
------
Salidas
1
abc
2
3
------
1
abc
2
3
------

PGINA: 4