Operatorias con archivos en C
PUNTERO A ARCHIVO
Un puntero a archivo identifica a un archivo en disco y permite moverse a través de él, además de leer y escribir información. Se declara de la siguiente manera:
FILE *identificador;
Para asociar el identificador
con un archivo específico se utiliza la función fopen().
Esta función permite abrir el archivo indicado bajo un modo
específico.
Ejemplo:
FILE *fp;
fp = fopen("carta.txt";
"r");
La función fopen()
intenta abrir el archivo carta.txt para ser leído. Si no existe
tal archivo retorna el valor NULL. Como medida de seguridad se
recomienda hacer la siguiente operación cada vez que se abre un
archivo:
fp =
fopen("carta.txt"; "r");
if(fp==NULL)
{
printf("No se puede abrir el archivo carta.txt\n");
exit(0);
}
Existen dos modos para leer un archivo:
Modo Texto: Las secuencias retorno de carro/salto de línea se convierten a caracteres de salto de línea en la lectura. En la escritura, ocurre lo contrario.
Modo Binario: Lee byte a byte sin hacer conversión. Para utilizar este modo, se debe agregar la letra "b" al segundo parámetro de fopen.
Un archivo binario se puede leer
carácter a carácter utilizando la función getc().
Podremos saber cuando se llega al final del archivo mediante la
función feof(). Ejemplo:
fp =
fopen("prueba.txt", "rb")
if(fp==NULL)
{
printf("No se puede abrir el archivo carta.txt\n");
exit(0);
}
while(! feof(fp))
{
c = getc(fp); // lee desde el archivo
putc(c,stdout); //escribe en la pantalla
}
fclose(fp); //cierra el archivo
MAIN CON ARGUMENTOS
Cuando compilamos un archivo en C en el sistema operativo MS-DOS, se genera un archivo con extensión "obj" y otro con extensión "exe". Este último se utilizará para ejecutar el programa creado desde la línea de comando. Si deseamos ingresar a nuestro programa el nombre de uno o más archivos debemos enviarlos como parámetros al momento de ejecutarlo. Por ejemplo, consideremos que nuestro programa fuente se llama uno.c. Al compilarlo se generaría el programa uno.exe. Si el programa recibe como parámetro el nombre de un archivo, y queremos enviar el archivo carta.txt, debemos ejecutarlo de la línea de comandos de la siguiente forma:
C:\TC\BIN:> uno carta.txt
Por otra parte, en nuestro código fuente, escribiremos main de la siguiente forma:
int main( int argc, char
argv[])
El parámetro argc indica la cantidad de palabras escritas al momento de ejecutar el programa. En el ejemplo anterior argc=2 (el nombre del programa y el nombre del archivo). El parámetro argv hace referencia a los nombres ingresados al ejecutar el programa, en este caso, argv[0]="uno" y argv[1]="carta.txt".
Ejemplos:
/* Este programa escribe en un archivo lo que lee en pantalla*/
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main (int argc, char
*argv[])
{
FILE *fp;
char car;
if(argc != 2)
{
printf("\nOlvido introducir el nombre del archivo\n");
return 0;
}
if((fp=fopen(argv[1],"wb"))
== NULL)
{
printf("\nNo se puede abrir el archivo\n");
return 0;
}
do{
car=getchar();
putc(car,fp);
} while(car != '$');
// Al escribir $ se interrumpe el programa
fclose(fp);
return 0;
}
/* Este programa escribe en
pantalla lo que lee de un archivo */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main (int argc, char
*argv[])
{
FILE *fp;
char car;
if(argc != 2)
{
printf("\nOlvido introducir el nombre del archivo\n");
return 0;
}
if((fp=fopen(argv[1],"rb"))
== NULL)
{
printf("\nNo se puede abrir el archivo\n");
return 0;
}
car=getc(fp);
while(car != EOF)
{
putchar(car); // muestra el caracter en la pantalla
car = getc(fp);
}
fclose(fp);
return 0;
}
/* Este programa copia un archivo
en otro */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main (int argc, char
*argv[])
{
FILE *entrada, *salida;
char car;
if(argc != 3)
{
printf("\nOlvido introducir el nombre del archivo\n");
return 0;
}
if((entrada=fopen(argv[1],"rb"))
== NULL)
{
printf("\nNo se puede abrir el archivo fuente\n");
return 0;
}
if((salida=fopen(argv[2],"wb"))
== NULL)
{
printf("\nNo se puede abrir el archivo destino\n");
return 0;
}
/* el siguiente codigo realiza la copia*/
do{
car = getc(entrada);
putc(car, salida);
}while(!feof(entrada));
fclose(entrada);
fclose(salida);
return 0;
}
OTRAS FUNCIONES PARA EL MANEJO DE ARCHIVOS EN C
getw() y putw()
Además de getc() y putc(), Turbo C soporta dos funciones adicionales: putw() y getw(). Se usan para leer y
escribir enteros de y en un archivo de disco. Estas funciones trabajan exactamente igual que putc() y getc(),
excepto que en lugar de escribir o leer un carácter, leen o escriben 2 bytes. Por ejemplo, para escribir un número
entero en un archivo apuntado por pa:
int x=100;
putw(x,pa);
fputs() y fgets()
Leen y escriben cadenas de caracteres sobre archivos en disco. Tienen los siguientes prototipos:
int fputs(const char *cad, FILE *pa);
char *fgets(char *cad, int longitud, FILE *pa);
La función fputs() funciona como puts(), pero escribe la cadena en un archivo. La función fgets() lee una cadena
hasta que se lee un carácter salto de línea o hasta que se han leido longitud-1 caracteres. Si se lee un carácter
salto de línea, éste forn}ma parte de la cadena. Cuando fgets() termina, la cadena resultante acaba con un carácter nulo.
fread() y fwrite()
Se utilizan para leer y escribir bloques de datos. Sus prototipos son:
size_t fread(void *buffer, size_t num_bytes, size_t cuenta, FILE *pa);
size_t fwrite(const void *buffer, size_t num_bytes, size_t cuenta, FILE *pa);
En fread(), buffer es un puntero a una región de memoria en donde escribir los datos leidos del archivo. En
fwrite(), buffer es un puntero a la información que va a ser escrita en el archivo. El número de bytes a leer o
escribir se especifica con num_bytes. El argumento cuenta determina cuantos elementos (cada uno de num_bytes de longitud) se van a leer o escribir. Finalmente pa es un puntero a un archivo abierto previamente.
Las funciones fred() y fwrite() pueden leer y escribir cualquier tipo de información, siempre y cuando el archivo se haya abierto para operacioness con datos binarios. Por ejemplo, el siguiente programa escribe un float en un
archivo:
#include <stdio.h>
main()
{
FILE *fp;
float f=12.23;
if((fp=fopen("prueba.txt","wb"))=NULL){
printf("No se puede abrir el archivo\n");
return 0;
}
fwrite(&f, sizeof(float), 1, fp);
fclose(fp);
return 0;
}
Una de las aplicaciones más útiles de fread() y fwrite() es la lectura y escritura de arrays o estructuras. Por ejemplo, este fragmento escribe el contenido del array de flotantes balance en el archivo balance.txt, usando la sentencia fwrite(). Luego lee el array usando la sentencia fread().
#include <stdio.h>
main()
{
int i;
FILE *fp;
float balance[100];
/* abrir para escritura */
if((fp=fopen("balance.txt","wb"))=NULL){
printf("No se puede abrir el archivo\n");
return 0;
}
/*generar el array */
for(i=0; i<100; i++) balance[i] = (float) * 0.54;
/* guardar el array en el archivo */
fwrite(balance, sizeof(balance), 1, fp);
fclose(fp);
/* poner en cero el array */
for(i=0;i<100;i++) balance[i]=0.0;
/* abrir para lectura */
if((fp=fopen("prueba.txt","rb"))=NULL){
printf("No se puede abrir el archivo\n");
return 0;
}
/* leer el array */
fread(balance, sizeof(balance), 1,fp);
/*mostrar el contenido del array */
for(i=0; i<100; i++) printf("%f\n", balance[i]);
fclose(fp);
return 0;
}
fprintf() y fscanf()
Estas fuinciones se comportan exáctamente igual que printf() y scanf(), con la diferencia de que el primer argumento indica el puntero al archivo correspondiente. Por ejemplo, para leer un string y un entero del archivo apuntado por fp:
fscanf(fp, "%s%d", nombre, &x);
/* previamente se han declarado char nombre[TAM]; int x; FILE fp; y se ha abierto el archivo para lectura */
Ejemplo de fprintf():
fprintf(fp, "%d, %s", x,nombre);
Nota: Aunque fprintf() y fscanf() a menudo son la forma más fácil de escribir y leer datos ordenadamente en archivos de disco, no siempre son la más eficiente. Debido a que los datos se escriben en formato ASCII, como aparecerán en la pantalla (en lugar de binario), se produce una sobrecarga extra en cada llamada. Por esto, si lo importante es la velocidad o el tamaño del archivo, se debe utilizar fread() y fwrite().
Fecha última modificación: 20 - 6 - 2002
JBOM.-
