Professional Documents
Culture Documents
Archivos y Registros
INTRODUCCION: Son estructuras cuyos componentes pueden ser de diferente tipo. Para declarar un tipo registro se debe incluir el nombre y el tipo de cada componente del mismo. En C++ se usa la palabra reservadastruct para indicar que el tipo que se est definiendo es un registro o estructura. A continuacin se presenta el desarrollo del tema Registros y Archivos.
Archivos y Registros
Contenido
Registros ................................................................................................................................................................. 4 Tipos de Registros .......................................................................................................................................... 4 a-. Registros de Datos ................................................................................................................................... 4 b-. Registro Fin de Fichero .......................................................................................................................... 4 Declaracin de Registros.............................................................................................................................. 4 Archivos ................................................................................................................................................................... 5 Tipos de Archivos ............................................................................................................................................ 6 Clasificacin de Archivos .............................................................................................................................. 6 Segn su Funcin ............................................................................................................................................ 6 Segn sus Elementos ..................................................................................................................................... 7 Declaracin de Archivos ............................................................................................................................... 7 MANEJO DE ARCHIVOS EN C++ ................................................................................................................... 8 Entrada/Salida de archivos .......................................................................................................................... 9 Modos de apertura de archivo ................................................................................................................ 11 Operaciones de lectura de archivos....................................................................................................... 12 Operaciones con archivos binarios ........................................................................................................ 15 Lectura y escritura en un archivo ............................................................................................................ 16 Salida a impresora ........................................................................................................................................ 19 Ejemplo de Archivos y registros ................................................................................................................... 20
Archivos y Registros
Registros
Son estructuras cuyos componentes pueden ser de diferente tipo. Para declarar un tipo registro se debe incluir el nombre y el tipo de cada componente del mismo. En C++ se usa la palabra reservadastruct para indicar que el tipo que se est definiendo es un registro o estructura.
Tipos de Registros a-. Registros de Datos Un registro de datos se corresponde con una sucesin de valores. Se suele representar, esquemticamente, como un conjunto de cajas pequeas, cada una conteniendo un valor. Los valores se representan de dos formas, formateados o sin formatear. Si los valores de los datos son caracteres legibles por una persona, cada carcter es un valor y diremos que el dato est formateado. Por ejemplo la sentencia.
b-.
Registro
Fin
de
Fichero
struct hostname[LONG_HOST];
char int port; } type_address; Declara a type_address como un registro caracteres hostname y el entero port. con dos
campos,
el
vector
de
Para asignar el valor 1001 al campo port, se indica: type_address.port = 1001; Donde el operador "." indica que se ha seleccionado un miembro del registro.
Archivos y Registros
const int MAXCAD = 20; typedef char TCadena[MAXCAD+1]; // MAXCAD caracteres + FINCAD struct Tfecha { int dia, mes, anho; }; struct TPersona { TCadena nombre, apellido1, apellido2; int edad; TCadena nif; Tfecha fecha_nacimiento; }
Las declaraciones de variables se realizan normalmente, es decir: TPersona per; Tfecha f1; Los nombres de los campos de un registro son locales a l, por lo que no hay conflicto con otros nombres usados en el mdulo. Una referencia a un campo de un registro consiste en el nombre de la variable registro y el nombre del campo, separados por un punto, por ejemplo: per.edad = 30; Un registro completo puede aparecer en cualquier parte de una sentencia de asignacin y como parmetros de procedimientos, por ejemplo: per.fecha_nacimiento = f1;
Archivos
Son una recopilacin de informacin (datos relacionados entre s), localizada o almacenada como una unidad en alguna parte del computador, manejados a travs de programas. Los archivos estn formados por mltiples caracteres que deben ser interpretados en conjunto para poder ejecutarse o visualizarse (exceptuando el texto puro). El tipo de interpretacin de cada archivo est dado por el formato que utiliza (un archivo grfico de formato GIF debe tomarse e interpretarse como tal y no como si fuese de formato ZIP, que es un archivo comprimido). Los archivos pueden contener diferentes tipos de informacin segn su formato: archivos de texto (.txt,), de documentos enriquecidos (.doc, .rtf, .pdf),
Archivos y Registros
ejecutables (.exe, .com), datos (.xls, .dbs), imagen (.jpg, .png, .bmp, .gif), audio (.wav, .mp3, .au, .mid), video (.mpg, .avi, .asf), entre otros.
Tipos de Archivos
r: Slo abre un fichero para su lectura. w: Si el fichero no existe, lo crea. Si existe, lo borra y aade uno nuevo. a: El fichero debe ( no) existir. Lo abre para aadir informacin al final. r+: El fichero ya existe y lo abre para actualizarlo. w+: Crea un nuevo fichero para actualizarlo y si existe, sobrescribe en l. a+: Abre un fichero para aadir informacin al final. Si no existe, lo crea.
Clasificacin de Archivos Segn su Funcin a.- Archivos Permanentes: Son aquellos cuyos registros sufren pocas o ninguna variacin a lo largo del tiempo, se dividen en: - Constantes: Estn formados por registros que contienen campos fijos y campos de baja frecuencia de variacin en el tiempo. - De Situacin: Son los que en cada momento contienen informacin actualizada. - Histricos: Contienen informacin acumulada a lo largo del tiempo de archivos que han sufridos procesos de actualizacin o bien acumulan datos de variacin peridica en el tiempo. b.- Archivos de Movimiento: son aquellos que se utilizan conjuntamente con los maestros (constantes), y contienen algn campo comn en sus registros con aquellos, para el procesamiento de las modificaciones experimentado por los mismos. c.- Archivo de Maniobra o Transitorio: son los archivos creados auxiliares creados durante la ejecucin del programa y borrados habitualmente al terminar el mismo.
Archivos y Registros
Segn sus Elementos - Archivo de Entrada: Una coleccin de datos localizados en un dispositivo de entrada. - Archivo de Salida: Una coleccin de informacin visualizada por la computadora. - Constantes: estn formados por registros que contienen campos fijos y campos de baja frecuencia de variacin en el tiempo. - De Situacin: son los que en cada momento contienen informacin actualizada. - Histricos: Contienen informacin acumulada a lo largo del tiempo de archivos que han sufrido procesos de actualizacin, o bien acumulan datos de variacin peridica en el tiempo. - Archivos de Movimiento o Transacciones: Son aquellos que se utilizan conjuntamente con los maestros (constantes), y contienen algn campo comn en sus registros con aquellos, para el procesamiento de las modificaciones experimentado por los mismos. - Archivos de Maniobra o Transitorios: Son los archivos auxiliares creados durante la ejecucin del programa y borrados habitualmente al terminar el mismo.
Declaracin de Archivos La secuencia que usaremos para realizar operaciones con archivos es la siguiente: - Crear un apuntador del tipo FILE * - Abrir el archivo utilizando la funcin fopen y asignndole el resultado de la llamada a nuestro apuntador. - Hacer las diversas operaciones (lectura, escritura, etc). Cerrar el archivo utilizando la funcin fclose. Los prototipos correspondientes de fopen y fclose son:
FILE * fopen (const char *filename, const char *opentype); int fclose (FILE *stream);
Ejemplo
Archivos y Registros
El siguiente programa abre un archivo que contiene un nombre y cedula de identidad. Luego abre un archivo de salida y escribe estos datos (pero en orden invertido). El archivo de entrada fue creado con un editor de texto. Archivo de entrada: entrada.txt Pedro 18878798
#include int main() { char ifilename[] = "entrada.txt"; char ofilename[] = "salida.txt"; char name[30]; int idNum; FILE *ofp, *ifp; /* Declara apuntadores a archivo */ ifp = fopen(ifilename,"r"); /* Abre archivo de entrada */ fscanf(ifp,"%s %d",name,&idNum); /* Lee datos de entrada */ ofp = fopen(ofilename,"w"); /* Abre archivo de salida */ fprintf(ofp,"%d %s\n",idNum, name); /* Escribe los datos */ fclose(ifp); fclose(ofp); /* Cierra los archivos */ return 0; } Archivo de salida: salida.txt 18878798 Pedro
Archivos y Registros
Entrada/Salida de archivos
Trataremos los principales aspectos de las operaciones de E/S en archivos.
//*********************************************** // archiv01.cpp // Demuestra la escritura bsica en archivo // 1999, Jaime Virgilio Gmez Negrete //*********************************************** #include <fstream.h> int main() { ofstream archivo;
archivo.open("datos.txt"); archivo << "Primera lnea de texto" << endl; archivo << "Segunda lnea de texto" << endl; archivo << "ltima lnea de texto" << endl; archivo.close(); return 0; }
En el programa se ha creado un objeto de la clase ofstream llamado archivo, posteriormente se utiliza la funcin miembro open para abrir el arcivo especificado en la cadena de texto que se encuentra dentro del parntesis de la funcin. Podemos invocar a la funcin constructora de clase de tal manera que el archivo tambin se puede abrir utilizando la siguiente instruccin:
ofstream archivo("datos.txt");
// constructora de ofstream
Archivos y Registros
Naturalmente, al utilizar la funcin constructora ya no es necesario utilizar la funcin miembro open, sta forma de abrir un archivo es preferida porque el cdigo es ms compacto y fcil de leer. De la misma forma que se utilizan manipuladores de salida para modificar la presentacin en pantalla de los datos del programa, igual es posible utilizar stos manipuladores al escribir datos en un archivo como lo demuestra el programa archiv02.cpp, observe que se utiliza un constructor para crear y abrir el archivo llamado Datos.txt:
//*********************************************** // archiv02.cpp // Demuestra el uso de manipuladores // 1999, Jaime Virgilio Gmez Negrete //*********************************************** #include <iostream.h> #include <fstream.h> #include <iomanip.h> int main() { ofstream archivo("Datos.txt"); int numero;
// constructor de ofstream
cout << "Introduzca un numero:" << endl; cin >> numero; archivo << "El valor introducido en base 10 es: " << numero << en dl; archivo << resetiosflags(ios::dec); archivo << setiosflags(ios::oct); archivo << "en base octal es: " << numero << endl; archivo << resetiosflags(ios::oct); archivo << setiosflags(ios::hex); archivo << "y en base hexadecimal es: " << numero << endl; archivo << setiosflags(ios::uppercase|ios::showbase); archivo << "utilizando los manipuladores uppercase y showbase" << " el valor es: " << numero << endl; archivo archivo archivo archivo y fixed: " << << << << << resetiosflags(ios::uppercase|ios::showbase); resetiosflags(ios::hex); setiosflags(ios::showpos|ios::showpoint|ios::fixed); "Utilizando los manipuladores showpos," << " showpoint (float)numero << endl;
archivo << resetiosflags(ios::showpos|ios::showpoint|ios::fixed); archivo << "Finalmente el valor es " << numero << endl; archivo.close(); return 0; }
10
Archivos y Registros
Modos de apertura de archivo
Al especificar la apertura de un archivo como se ha mostrado en los programas anteriores, el programa sobreescribe cualquier archivo existente llamado Datos.txt en el directorio de trabajo del programa. Dependiendo del propsito del programa es posible que sea necesario agregar datos a los ya existentes en el archivo, o quiz sea necesario que las operaciones del programa no se lleven a cabo en caso de que el archivo especificado exista en el disco, para stos casos podemos especificar el modo de apertura del archivo incluyendo un parmetro adicional en el constructor, cualquiera de los siguientes:
ios::in Operaciones de lectura. Esta es la opcin por defecto para objetos de la clase ifstream.
ios::out Operaciones de escritura. Esta es la opcin por defecto para objetos de la clase ofstream.
ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operacin se suspende.
11
Archivos y Registros
ios::binary Operaciones binarias.
De esta manera, podemos modificar el modo de apertura del programa archiv02.cpp para que los datos del programa se concatenen en el archivo Datos.txt simplemente escribiendo el constructor as: ofstream archivo("Datos.txt", ios::app);. Si deseamos que el programa no sobreescriba un archivo existente especificamos el constructor de sta manera: ofstream archivo("Datos.txt", ios::noreplace);. Utilizando los especificadores de modo de apertura se puede conseguir un mayor control en las operaciones de E/S en archivos.
//*********************************************** // archiv03.cpp // Demuestra operaciones de lectura de archivos // 1999, Jaime Virgilio Gmez Negrete //*********************************************** #include <fstream.h> int main() { ifstream archivo("Pruebas.txt", ios::noreplace); char linea[128]; long contador = 0L; if(archivo.fail()) cerr << "Error al abrir el archivo Pruebas.txt" << endl; else while(!archivo.eof()) { archivo.getline(linea, sizeof(linea)); cout << linea << endl; if((++contador % 24)==0) { cout << "CONTINUA..."; cin.get(); } } archivo.close();
12
Archivos y Registros
return 0; }
El programa crea un objeto de la clase ifstream para abrir el archivo llamado Pruebas.txt utilizando el constructor de clase y especificando la bandera ios::noreplace que evita que el archivo sea sobreescrito. Si por algn motivo ocurre un error al abrir el archivo se genera el mensaje de error especificado en la lnea 16. En ausencia de errores el programa entra en un bucle while el cual est evaluado por efecto de la funcin miembro eof( ) de tal manera que el bucle se ejecuta hasta encontrar el final del archivo. Utlizando la funcin miembro getline( ) se obtiene una lnea de texto y se exhibe en pantalla, lnea 21, luego utilizamos una instruccin condicional if con el operador de mdulo (%) para determinar si se han ledo 24 lneas de texto. Cada vez que el contador de lneas dividido entre 24 d como resultado un resduo de cero el programa se detiene permitiendo leer las 24 lneas de texto previas. Para continuar se debe presionar la tecla enter y entonces el programa leer y mostrar en pantalla las siguientes 24 lneas de texto, lneas 22 a la 26.
Tres de las cuatro funciones enlistadas quedan demostradas en el siguiente programa llamado archiv04.cpp el cual copia el contenido del archivo llamado Pruebas.txt en uno llamado Copia.txt. En primer lugar se crea un objeto de la clase ifstream llamado origen que nos sirve para abrir el archivo Pruebas.txt para operaciones de lectura, la funcin miembro origen.fail( ) nos indica la existencia de un error, en caso de que ste exista se despliega un mensaje en pantalla y el programa termina. Si la apertura del archivo Pruebas.txt fu exitosa se procede entonces a la siguiente parte del programa donde se crea un
13
Archivos y Registros
objeto de la clase ofstream llamado destino para operaciones de escritura el cual especifica que el archivo a crear se llamar Copia.txt y de acuerdo a la bandera ios::noreplace, si existe un documento con el nombre deCopia.txt la funcin constructora fallar, ste proceso es detectado por la funcin miembro destino.fail( ) desplegando un mensaje en pantalla y terminando el programa. archiv04.cpp es un programa que sirve para copiar un archivo basado en caracteres ASCII.
//********************************************************* // archiv04.cpp // Demuestra xito en operaciones de E/S de archivos // 1999, Jaime Virgilio Gmez Negrete //********************************************************* #include <fstream.h> #include <stdlib.h> int main() { ifstream origen("Pruebas.txt"); char linea[128]; if(origen.fail()) cerr << "Error al abrir el archivo Pruebas.txt" << endl; else { ofstream destino("Copia.txt", ios::noreplace); if(destino.fail()) cerr << "Error al crear el archivo: Copia.txt" << endl; else { while(!origen.eof()) { origen.getline(linea, sizeof(linea)); if(origen.good()) // si lectura ok y if(origen.eof()) // si eof, -> termina exit(1); // el programa else destino << linea << endl; if(destino.fail()) { cerr << "Fallo de escritura en archivo" << endl; exit(1); } } } destino.close(); } origen.close(); return 0; }
14
Archivos y Registros
En caso que las operaciones de apertura de los archivos involucrados en el programa archiv04.cpp sean exitosas, entonces se inicia un bucle en donde se lee en primer lugar una lnea de texto, lnea 27 del programa, el xito de sta operacin es monitoreado por la funcin miembro origen.good( ), si sta funcin indica que la lectura del archivo fu exitosa entonces la funcin miembro origen.eof( ) verifica si la lnea en cuestin es el final del archivo, si no es as, entonces la lnea leda se escribe en el archivo Copia.txt, entonces le corresponde a la funcin miembro destino.fail( ) verificar que el proceso de escritura tuvo xito, lnea 33 del programa. El bucle se repite hasta encontrar el final del archivo, condicin que se verifica tanto en la linea 25 como en la 29 del programa.
//********************************************************* // archiv05.cpp // Demuestra operaciones con archivos binarios // 1999, Jaime Virgilio Gmez Negrete //********************************************************* #include <fstream.h> #include <stdlib.h> int main() { ifstream origen("Archiv04.exe", ios::binary); char linea[1]; if(origen.fail()) cerr << "Error al abrir el archivo: Archiv04.exe" << endl; else { ofstream destino("Copia.exe", ios::binary); if(destino.fail()) cerr << "Error al crear el archivo: Copia.exe" << endl; else { while(!origen.eof()&&!origen.fail()) { origen.read(linea, sizeof(linea)); if(origen.good())
15
Archivos y Registros
{ destino.write(linea, sizeof(linea)); if(destino.fail()) { cerr << "Error en el archivo: Copia.exe" << e ndl; exit(1); } } else if(!origen.eof()) { cerr << "Error en el archivo: Archiv04.exe" << en dl; exit(1); } } } destino.close(); } origen.close(); return 0; }
Observar que se utiliza la funcin miembro origen.read( ) para leer un byte del archivo especificado por el objeto de la clase ifstream llamado origen, lnea 27. En forma similar, se utiliza la funcin miembro destino.write( ) para escribir un byte en el archivo especificado para el objeto de la clase ofstream llamado Copia.EXE, lnea 30 del programa. La comprobacin de las operaciones de E/S se realizan como se indic para el programa archiv04.cpp. Si se desea utilizar los operadores de insercin y extraccin para operaciones de E/S en archivos binarios se requiere sobrecargar stos operadores, sto lo trataremos ms adelante cuando se aborde el tema de la sobrecarga de operadores en C++.
16
Archivos y Registros
escritura de archivo en un lugar especfico, y seekp( ) mueve el apuntador de lectura a una posicin especfica en el archivo, la sintxis de las funciones es sta:
El parmetro desplazamiento especifica la cantidad de bytes que se mover el apuntador de archivo, puede ser un valor positivo negativo. El parmetro posicion especifica el lugar del archivo a partir del cual se mover el apuntador de archivo, de acuerdo a las siguientes banderas
Para demostrar las operaciones aleatorias conviene generar un breve archivo de texto en donde poder efectuar algunas operaciones de E/S, use el siguiente cdigo:
//*********************************************** // letras.cpp // Genera un abecedario // 1999, Jaime Virgilio Gmez Negrete //*********************************************** #include <fstream.h> int main() { ofstream archivo("Letras.txt"); for(char letra='A'; letra <='Z'; letra++) archivo << letra; archivo.close();
17
Archivos y Registros
return 0; }
El cdigo genera un alfabeto en el archivo llamado Letras.txt, ahora utilizaremos el programa archiv06.cpp para "navegar" por el contenido del archivo y generar una palabra amigable en pantalla:
//********************************************************* // archiv06.cpp // Demuestra lectura y escritura en un archivo // 1999, Jaime Virgilio Gmez Negrete //********************************************************* #include <fstream.h> int main() { char letra; fstream letras("Letras.txt", ios::in|ios::out); letras.seekg(7, ios::beg); // obtiene la letra H letra=letras.get(); letras.seekp(0, ios::end); letras << letra; // coloca la letra al final letras.seekg(-13, ios::end); // obtiene la letra O letra = letras.get(); letras.seekp(0, ios::end); letras << letra; letras.seekg(-17, ios::end); // obtiene la letra L letra = letras.get(); letras.seekp(0, ios::end); letras << letra; letras.seekg(0, ios::beg); letra = letras.get(); letras.seekp(0, ios::end); letras << letra; letras.seekg(-4, ios::end); while(!letras.eof()) cout.put((char)letras.get()); letras.close(); return 0; // obtiene la letra A
18
Archivos y Registros
}
Observe que para posicionar el apuntador de lectura de archivo a partir del fin del mismo se utiliza un nmero negativo y adems la lectura avanza hacia el final del archivo. Por la naturaleza del programa archiv06.cpp solo desplegar el mensaje HOLA en pantalla una sola vez, esto es porque las letras que forman la palabra "HOLA" se leen del archivo y a su vez se escriben al final del mismo, el cdigo toma en cuenta las letras previamente escritas, lineas 19 a la 32. Para un mejor entendimiento del funcionamiento del programa utilice el depurador de errores de su compilador en la modalidad de paso por paso.
Salida a impresora
De la misma manera en que es posible escribir la salida en un archivo, habr ocasiones en las que es necesario producir constancia en papel utilizando una impresora. En general es posible tratar a la impresora como uno ms de los dispositivos disponibles para la salida de datos, se crea un objeto de la clase ofstream especificando como nombre de archivo la palabra PRN, tal y como lo demuestra el ltimo programa de este tutorial, archiv07.cpp:
//*********************************************** // archiv07.cpp // Demuestra la salida a impresora // 1999, Jaime Virgilio Gmez Negrete //*********************************************** #include <fstream.h> #include <stdlib.h> int main() { char texto[256]; ofstream impresora("PRN"); ifstream archivo("Pruebas.txt"); if (archivo.fail()) cerr << "Error al abrir el archivo: Pruebas.txt" << endl; else { while (!archivo.eof()) { archivo.getline(texto, sizeof(texto)); if (archivo.good()) { impresora << texto << endl; if (impresora.fail()) {
19
Archivos y Registros
cerr << "Error de escritura en impresora" << endl ; exit(1); } } else if (!impresora.eof()) { cerr << "Error al leer el archivo: Pruebas.txt" << en dl; exit(1); } } archivo.close(); impresora.close(); } return 0; }
#include <conio.h>
#include <string.h>
struct {
int clave;
char nombre[30];
void main() {
20
Archivos y Registros
clrscr();
FILE *archdisco;
archdisco = fopen("cpp:acarchivo1.dat","wb" ;
fclose(archdisco);
printf("ARCHIVO CREADO";
getchar();getchar();
21
Archivos y Registros
CONCLUSIONES Los archivos son una recopilacin de informacin (datos relacionados entre s), localizada o almacenada como una unidad en alguna parte del computador, manejados a travs de programas. Los nombres de los campos de un registro son locales a l, por lo que no hay conflicto con otros nombres usados en el mdulo. Una referencia a un campo de un registro consiste en el nombre de la variable registro y el nombre del campo, separados por un punto. Para abrir un archivo y realizar operaciones de lectura se crea un objeto de la clase ifstream.
Archivos y Registros
RECOMENDACIONES: Investigar acerca de registros y archivos. Utilizar los archivos para guardar los datos de los programas.
Archivos y Registros