ARCHIVO
Desde un
punto de vista técnico, un archivo es un conjunto de información de un mismo
tipo, almacenada en un medio físico, lógicamente estructurada para facilitar su
acceso, modificación y eliminación.
Son Datos estructurados que pueden recuperarse fácilmente y usarse en
una aplicación determinada. Se util iza como sinónimo de fichero. El archivo no contiene elementos de la
aplicación que lo crea, sólo los datos o información con los que trabaja el
usuario.
Conjunto
de bytes almacenados como una entidad individual.
Todos los datos en disco se almacenan como un archivo con un nombre de archivo
asignado que es único dentro del directorio en que reside.
Para el
computador, un archivo no es más que una serie de bytes.
La estructura de archivo es conocida para el software que lo maneja. Por
ejemplo, los archivos de bases de datos están compuestos por una serie de
registros. Los archivos de procesamiento de texto, también llamados documentos,
contienen un flujo continuo de texto.
Se conocen varios tipos de archivos
pero en esta ocasión solo hablare de los Archivos de texto y binarios.
ARCHIVOS DE
TEXTO
Los archivos de texto son archivos
normales que contienen información que el usuario puede leer. Esta información
se almacena en ASCII. Puede visualizar e imprimir dichos archivos.
La denominación archivo de texto no impide la inclusión de
caracteres de control o de otros caracteres no imprimibles (distintos de NUL).
Por lo tanto, los programas de utilidad estándar que listan archivos de texto
como entradas o salidas o bien son capaces de procesar correctamente los
caracteres especiales o bien describen explícitamente sus limitaciones dentro
de sus secciones individuales.
El final
del archivo se indica mediante el carácter ASCII 26, que también se expresa
como ^Z o EOF.
Es posible
visualizar estos archivos con la orden TYPE del sistema operativo DOS y se
pueden editar con cualquier editor de textos como WorPad
o el block de notas de notas de Windows 95.
Este tipo
de archivos solo permite operaciones de lectura y escritura secuenciales,
la única forma de modificarlos es agregando líneas al final del archivo.
Los pasos para leer o escribir en un archivo de este tipo son:
v Declarar una variable de tipo texto y asociarla al nombre de un archivo. A esto también se le llama declarar el archivo.
v Abrir el archivo ya sea para lectura o escritura.
v Leer o escribir datos en el archivo.
v Cerrar el archivo .
CREACIÓN ARCHIVO DE TEXTO
/* Crear un archivo secuencial
*/
#include
<stdio.h>
main()
{
int cuenta;
char nombre[30];
float balance;
FILE *cfPtr; /* cfPtr =
Apuntador archivo clientes.dat */
if( (cfPtr = fopen(''clientes.dat'', ''w'') )
== NULL)
printf(''Archivo no puedo abrirsenn'');
else {
printf(''Dar la cuenta, nombre, y balance:\n'');
printf(''Dar un EOF para terminar la captura.\n'');
printf(''? '');
scanf(''%d%s%f'',
&cuenta, nombre, %balance);
while ( !feof(stkin) ) {
fprintf(cfPtr, '' %d %s
%.2fnn'', cuenta, nombre, balance);
printf(''? '');
scanf(''%d%s%f'', &cuenta, nombre, &balance);
}
fclose(cfPtr);
}
return 0;
}
LECTURA / ESCRITURA ARCHIVO
SECUENCIAL
/* Leyendo y escribiendo un archivo secuencial */
#include
<stdio.h>
main()
{
int cuenta;
char nombre[30];
float balance;
FILE *cfPtr; /* cfPtr
= Apuntador archivo clientes.dat */
if( (cfPtr = fopen(''clientes.dat'', ''r'') )
== NULL)
printf(''No se pudo abrir el archivo\n'');
else {
printf(''%-10s%-13s%s\n'',
''Nombre'', ''Balance'');
fscanf(cfPtr, ''%d%s%f'', &cuenta, nombre, &balance);
while( !feof(cfPtr) ) {
printf(''%-10d%-13s%7.2fnn'', cuenta, nombre,
balance);
fscanf(cfPtr, ''%d%s%f'', &cuenta, nombre, &balance);
}
fclose(cfPtr);
} return 0;
}
Los archivos binarios son archivos normales que contienen información
que el sistema puede leer,son
diferentes a los archivos de texto principalmente porque los datos no están
organizado en líneas con terminadores de nueva línea, y porque pueden contener
cualquier valor de ocho bits.
Sin embargo, los archivos binarios se abren en la misma forma que los
archivos de texto, excepto por la bandera ios::binary que se pasa a la función
de apertura. Este tipo de archivos representa sus datos numéricos con su
representación binaria . pueden
ser archivos que contienen instrucciones de lenguaje maquina listas para ser ejecutadas por ejemplo cuando
escribimos un archivo en un lenguaje en particular (como C++ ,pascal, Fortan) tenemos las
instrucciones almacenadas en un archivo de texto llamado fuente , perro
una vez que lo sometemos a un proceso de compilación y ejecución nuestro programa
lo traslada a un programa ejecutable (en lenguaje maquina ) , que directamente
entendido por la computadora y se crea un archivo binario. Entes tipo de
archivo también se pueden almacenar
diferentes tipos de datos incluyendo datos numéricos sin embargo cabe
destacar que los datos numéricos se graban
con su representación binaria (no con su representación ASCII), por tal
control cuando se despliega con un editor de texto o por medio de comandos en
un sistema operativo , aparecen caracteres raros que no
se interpretan . por ejemplo: si e guarda un dato 27
en un archivo binario , se almacena como 00001111 y no como 27.
Los archivos binarios podrían ser archivos ejecutables que indicaran al
sistema que ha de realizar un trabajo. Los mandatos y los programas se
almacenan en archivos binarios ejecutables. Los programas de compilación
especial convierten texto ASCII en código binario.
La única diferencia entre los archivos de texto y los archivos binarios
es que los archivos de texto tienen líneas de menos de {LINE_MAX}
bytes, sin caracteres NUL, que terminan con un
carácter de nueva línea.
/////////////////////////////////////////////////////
// GARCHBIN.CPP : GRABA UN ARCHIVO EN MODO BINARIO ///////////////////////////////////////////////////////
#include <iostream.h> #include <fstream.h> struct empleado
{ int numero; char nombre[31];
float sueldo;
};
void main() { ofstream salida("EMPRESA.DAT", ios::binary); if(!salida)
{ cout << "\nNo puede abrirse el archivo EMPRESA.DAT\n"; return; } empleado unempleado; do{ cout << "Número ( 0="Fin" ) : "; cin>> unempleado.numero; cin.ignore(); if(!unempleado.numero) return; cout << "Nombre : "; cin.getline(unempleado.nombre,31); cout << "Sueldo : "; cin>> unempleado.sueldo; cin.ignore(); salida.write((char*) &unempleado,sizeof(unempleado)); }while(unempleado.numero != 0); }
///////////////////////////////////////////////////// // LARCHBIN.CPP : Lee un archivo en modo binario /////////////////////////////////////////////////////// #include <iostream.h> #include <fstream.h> #include <iomanip.h> struct empleado {int numero;
char nombre[31];
float sueldo; };
void main() { ifstream entrada("EMPRESA.DAT", ios::binary); if(!entrada) { cout << "\nNo puede abrirse el archivo EMPRESA.DAT\n"; return; } empleado unemp; cout << setiosflags(ios::showpoint | ios::fixed) << setprecision(2) << '\n'; cout << setiosflags(ios::left) << setw(6) << "NUM." << setw(35) << "N O M B R E" << setw(10) << "SUELDO" << "\n="==========================" << setfill('.'); while(entrada) { if(entrada.read((char*) &unemp,sizeof(unemp))) { cout << setiosflags(ios::left) << setw(6) << unemp.numero << setw(35) << unemp.nombre << setiosflags(ios::right) << " $ " << setw(10) << unemp.sueldo << '\n'; } } }
//////////////////////////////////////////////////////////// // LARCHBI2.CPP : Lee un archivo de texto en modo binario // ////////////////////////////////////////////////////////////
#include <iostream.h> #include <fstream.h> void main()
{ // Abre un archivo en modo binario ifstream entrada("LARCHBI2.CPP", ios::binary); // Verifica la existencia del archivo if(!entrada) { cout << "\nNo puede abrirse el archivo"; return; } // Despliega el contenido del archivo char c; while(entrada) { entrada.get(c); cout << c ; } }
ARCHIVOS BINARIOS
+ Abrir archivos de nombre path, con bandera of lag en modo mode
int open(const char
*path, int oflag,
/* mode—t mode
*/x ...))
+ Escritura en archivo apuntado por f ildes
int write(int fildes,
const void *buf, size—t nbyte);
+ Lectura archivo apuntado por f ildes
int read(int fildes,
void *buf, size—t nbyte);
+ Cerrar archivo f ildes
int close(int fildes);
+ Posicionar el apuntador en el archivo
off—t lseek(int fildes,
off—t offset, int whence);
+ Creación de archivo
con nombre path
int creat(const char *path,
mode—t mode);
#include <unistd.h> y #include <fcntl.h>
EJEMPLO
USO ARCHIVOS BINARIOS
/* Programa que copia el contenido de un archivo en otro */
#include <unistd.h>
#include <fcntl.h>
char
buffer[2048];
main(argc)
int argc;
char *argv[];
{
int fdold, fdnew;
if (argc != 3) {
printf('' Faltan parametros
\n'');
exit(1);
}
/* abrir archivo fuente modo lectura */
fdold = open(argv[1], O_RDONLY);
if (fdold == -1) {
printf('' El archivo %s no se puede abrir \n'', argv[1]);
exit(1);
}
/* creación del archivo destino en modo rw para todos */
fdnew = creat(argv[2], 0666);
if (fdnew == -1) {
printf('' Imposible de crear el archivo: %s \n'', argv[2]);
exit(1);
}
copia(old,
new)
int old, new;
{
int count;
/* copiando bloques de 2048 bytes de un archivo a otro */
while ((count = read(old, buffer, sizeof(buffer))) ? 0)
write(new, buffer, count);
}
v Normalmente, los archivos binarios los puede
crear únicamente el programa, y al acceso a las componentes de tales archivos
es posible sólo dentro del programa.
v La información en un archivo binario es
ilegible porque está utilizando un esquema de representación binario interno,
que depende de la computadora que se use, y esta representación no se puede
mostrar correctamente en forma de caracteres en un dispositivo de salida.
v La información en los archivos binarios se
puede transferir más rápidamente entre la memoria principal y la memoria
secundaria, y los elementos se almacenan de forma más compacta.