Lenguaje C

Archivos
Conceptos generales
Fichero, en España; file en inglés, se pronuncia faiil (i alargada y suave).

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

• De texto: compuestos únicamente de caracteres sin formato -tamaño, 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 también como archivos de texto llano o texto
simple.
• Binario: contiene información de cualquier tipo, codificada en forma binaria para el propósito de almacenamiento y procesamiento
de ordenadores. Partes de un archivo binario pueden ser interpretados como texto.

Las operaciones básicas en archivos son:

• Creacion : FILE *fptr; fopen(..) // *fptr es un puntero de tipo FILE
• Apertura : fopen(..)
• Lectura : getc(..)
• Escritura : putc(..)
• Recorrido: fseek(..)

El lenguaje C representa a un archivo como una estructura:

struct {
char *-ptr; // puntero a buffer actual
int _cnt; // contador de byte actual
char *base; // dirección base de buffer E/S
char _flag; // flag (bandera) de control
char _file // fichero
}
Las funciones generales para manejar archivos están en la librería stdio.h.

Ejemplo: Escribir 2 registros de datos en el archivo test.txt, luego leerlos y mostrarlos

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

Programa de lectura:
#include<stdio.h>
void main(void) {
int n;
char a[4];
float ff;
FILE *fp; // declara el archivo
if((fp = fopen("test.txt", "r")) != NULL){ // abre el archivo para escribir
fscanf(fp, "%d%s%f", &n, a, &ff); // lee datos
printf("%d %s %f\n", n, a, ff);
fscanf(fp, "%d%s%f", &n, a, &ff);
printf("%d %s %f\n", n, a, ff);
fclose(fp); // cierra el archivo
} else printf("No pudo abrir el archivo test.txt\n");
}
Salida:
4 abc 4.200000 // La entrada fue: 4, "abc", 4.2
2 ab 4.200000 // La entrada fue: 2, "ab c", 3.4; note que se perdió una parte de los caracteres de la cadena.
PÁGINA: 1
 Lenguaje C

Ejercicio: Integre los dos programas en uno solo.

Principales funciones de archivos

Descripción Sintaxis Ejemplos
Definir puntero a archivo FILE *pf; FILE *pf;

Abrir archivo y apuntarlo FILE *fopen(const char *miArchivo, const char *modo) pf = fopen("test.txt", "r");
Retorna puntero a file. pf = fopen("test.txt", "w+");
miArchivo: nombre del archivo físico
modo: modo de apertura:
lectura : “r”
escritura: “w” Si existe miArchivo, graba encima.
Si no existe, lo crea.
Apéndice “a” Si existe miArchivo, lo continúa.
Si no existe, lo crea.
Lectura/escritura “w+”
Hay más modos.
Fin de archivo int feof(FILE *pf); while (feof(pf) == 0) {... }
devuelve 0 (falso) si no es fin de archivo
!=0 si no es fin de archivo-
Leer datos Int fscan(FILE *pf, const char *formato, ….); fscanf(pf, "%d%s%f", &n, a, &ff);
Lee hasta que aparezca un espacio en blanco o '\0'
Similar a scanf( ) solo se agrega el primer parámetro
retorno: 1 exitoso, 0 error
char fgets(char *buff, int n, (FILE*)pf); char buff[255];
Lee de pf hasta n-1 caracteres o hasta LF ('\10' nueva while(fgets(buff, 255, (FILE*)pf) != NULL);
línea) o fin de archivo (EOF) y los aloja en *buff y le // Retorna NULL para fin de archivo
agrega '\0' , retorna
char fgetc(FILE *pf); char cc;
Lee un caracter de pf while (feof(pf) == 0) {
cc = fgetc(pf);
printf("%c", cc);
}
Escribir en archivo Int fprintf(FILE *pf, const char *formato, ….); fprintf(pf, "%d %s %f\n", 2, "ab c", 3.4);
Similar a printf( ) solo se agrega el primer parámetro // atento: dejar espacio entre formatos
retorno: 1 exitoso, 0 error
int fputs(const char *buff, FILE *pf) char *buff = “hola mundo”;
Escribe la buff en pf, devuelve: fputs(buff, pf );
Negativo en caso de éxito
EOF si hay un error de escritura.
int fputc(int buff, FILE *pf); char cc;
Escribe cc en pf, retorna cc si la escritura fue exitosa, en while((cc = getchar()) != '\n') {
caso contrario retorna EOF. printf("%c", fputc(cc, fp));
}
Leer un arreglo size_t fread (void *ptr, size_t size, size_t n, FILE * pf); #include <stdio.h>
Lee un arreglo de n elementos de tamaño size, cada #include <string.h>
Se aparea con fwrite()
uno desde el archivo pf y lo guarda en la memoria void main ( int argc, char **argv){
apuntado por pf. El indicador de posición de la cadena FILE *fp;
de caracteres avanza hasta leer la totalidad de bytes. Si char cc1[] = "Mostrando el sur.", cc2[60],
fread es exitodo retorna (size*n). *pcc2 = cc2;
int st;
Escribir un arreglo. size_t fwrite(void *buff, size_t tamano, size_t n, FILE
st = strlen(cc1);
*pf);
Se aparea con fread() printf("%d: %s\n", st, cc1);
Escribe en pf el arreglo buff de n elementos de tamaño
size*n. Retorna el número de registros escritos, no el
fp = fopen ( "fichero.txt", "w" );
número de bytes.
fwrite( cc1, sizeof(char), st, fp );
fclose ( fp );

PÁGINA: 2
 Lenguaje C
fp = fopen ("fichero.txt", "r" );
st = fread (pcc2, sizeof(char), st, fp);
printf("%d, %s\n", st, pcc2);
fclose (fp);
}
Salida:
17: Mostrando el sur.
17, Mostrando el sur.
Podemos considerar un Int fseek(FILE *pf, size_t offset, int origen) // imprime todos los bytes de un archivo
archivo como un arreglo en En el archivo pf, se ubica un byte según: long offset = 0L;
disco duro y ubicarnos en origen: 0 prindicipio del fichero FILE *fp;
cualquier posición. 1 posición actual fp = fopen ("fichero.txt", "r" );
2 final del archivo while(fseek(pf, offset++,0) == 0)
offset: desplazamiento a partir del origen putchar(getc(pf));
Retorna 0 si no hay error fclose (fp);
rebobinar (rewind, se void rewind(FILE *pf); rewind(pf);
pronuncia riwaind) sitúa el
cursor de lectura/escritura
al principio del archivo.
Cerrar archivo y poner nulo FILE *fclose(FILE *pf) fclose(pf);
a puntero

Ejercicio: Replique el ejemplo de fread() y fwrite() de la tabla anterior para arreglo de tipo entero

Ejemplo:
Declare una estructura (registro), asigne datos e imprima el registro
Escriba el registro dos veces en un archivo
Lea los registros del archivo e imprima los datos de cada registro.
Programa:
#include <stdio.h>
#include <string.h>
struct Datos {
int dato1;
char dato2[4];
int dato3[2];
};
void print(struct Datos *p);
void main (void){
struct Datos in, *pin = &in, out, *pout = &out;
int nlen = sizeof(in);
in.dato1 = 1;
char *pdato2 = in.dato2;
strcpy(pdato2, "abc");
in.dato3[0] = 2;
in.dato3[1] = 3;
printf("Entrada\n");
print(pin);

FILE *fp;
fp = fopen ("fichero.txt", "w"); // Escritura
fwrite(pin, nlen, 1, fp );
fwrite(pin, nlen, 1, fp );
fclose ( fp );

fp = fopen ("fichero.txt", "r" ); // Lecturas

int n;
printf("Salidas\n");
while((n = fread(pout, nlen, 1, fp)) >0 ) print(pout);
fclose (fp);
}
PÁGINA: 3
 Lenguaje C
void print(struct Datos *p){ // Impresión
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
------

PÁGINA: 4