You are on page 1of 24

Archivos y Registros

BACHILLER INDUSTRIAL Y PERITO EN COMPUTACION PROGRAMACION ESTRUCTURADA PROF. ALVARO MARTINEZ

DELMAR ABISAI HERRERA HERRERA SEXTO GRADO 16 DE AGOSTO DE 2013

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

Declaracin de Registros typedef {

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.

Ejemplo const char FINCAD = char(0);

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

MANEJO DE ARCHIVOS EN C++

Archivos y Registros
Entrada/Salida de archivos
Trataremos los principales aspectos de las operaciones de E/S en archivos.

Operaciones de escritura en archivos


El archivo de cabecera fstream.h define las clases ifstream, ostream y fstream para operaciones de lectura, escritura y lectura/escritura en archivos respectivamente. Para trabajar con archivos debemos crear objetos de stas clases de acuerdo a las operaciones que deseamos efectuar. Empezamos con las operaciones de escritura, para lo cual bsicamente declaramos un objeto de la clase ofstream, despus utilizamos la funcin miembro open para abrir el archivo, escribimos en el archivo los datos que sean necesarios utilizando el operador de insercin y por ltimo cerramos el archivo por medio de la funcin miembro close, ste proceso est ilustrado en nuestro primer programa,archiv01.cpp.

//*********************************************** // archiv01.cpp // Demuestra la escritura bsica en archivo // 1999, Jaime Virgilio Gmez Negrete //*********************************************** #include <fstream.h> int main() { ofstream archivo;

// objeto de la clase ofstream

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::app Operaciones de aadidura.

ios::ate Coloca el apuntador del archivo al final del mismo.

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::nocreate Si el archivo no existe se suspende la operacin.

ios::noreplace Crea un archivo, si existe uno con el mismo nombre la operacin se suspende.

ios::trunc Crea un archivo, si existe uno con el mismo nombre lo borra.

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.

Operaciones de lectura de archivos


Para abrir un archivo y realizar operaciones de lectura se crea un objeto de la clase ifstream y se procede prcticamente de la misma forma que lo expuesto en el apartado anterior. Despus de abrir el archivo se puede leer su contenido utilizando la funcin miembro de la clase ifstream o bin el operador de extraccin. Cuando se lee un archivo, por lo general se empieza al principio del mismo y se leer su contenido hasta que se encuentre el final del archivo. Para determinar si se ha llegado al final del archivo se puede utilizar la funcin miembro eof como condicin de un bucle while. Adems se puede utilizar la funcin miembro fail para detectar un error al abrir el archivo, esto se demuestra en el siguiente programa, archiv03.cpp:

//*********************************************** // 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.

Analizando el xito de E/S de archivos


En el programa archiv03.cpp se utiliz la funcin miembro fail( ) para determinar el xito de la operacin de apertura del archivo Pruebas.txt. La funcin miembro fail( ) produce el valor de 1 si ocurre un error en la operacin de archivo. Similarmente es recomendable utilizar otras funciones para verificar no solo la apertura de archivo sino tambin las operaciones de lectura y escritura, las funciones miembro que nos permiten stas pruebas son las siguientes:

good Produce un 1 si la operacin previa fu exitosa.

eof Produce un 1 si se encuentra el final del archivo.

fail Produce un 1 si ocurre un error.

bad Produce un 1 si se realiza una operacin invlida.

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.

Operaciones con archivos binarios


Las operaciones de flujos de archivos se ejecutan en forma predeterminada en modo de texto, sin embargo hay ocasiones en donde se requiere realizar operaciones en archivos binarios, como sucede con archivos de estructuras de datos aquellos que contienen datos numricos de punto flotante. A manera de prueba trate de relaizar una copia de un archivo ejecutable utilizando el programa archiv04.cpp, se dar cuenta que si bin, el programa no marca errores, el resultado sencillamente no es el esperado. La prueba definitiva es comparar el tamao en bytes del archivo original contra el tamao del archivo copiado. El programa archiv05.cpp ejecuta operaciones de E/S en archivos utilizando el modo binario ( ios::binary), ste programa puede copiar efectivamente un archivo ejecutable, en el ejemplo Archiv04.EXE, generando un nuevo archivo llamado Copia.EXE, el nuevo cdigo, basado enarchiv04.cpp es el siguiente:

//********************************************************* // 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++.

Lectura y escritura en un archivo


Hasta este punto hemos efectuado operaciones, sea de escritura o bin de lectura en un archivo, tanto en formato de texto como en formato binario pero todava no se han efectuado mbas operaciones en un mismo archivo. En ciertas aplicaciones es necesario efectuar operaciones de lectura/escritura en un archivo como es el caso de una base de datos, para esto es necesario crear un objeto de la clase fstream. Cuando un programa abre un archivo para operaciones de E/S ste mantiene el registro de dos apuntadores de archivo, uno para operaciones de lectura y otro para operaciones de escritura. Como en la mayora de los casos en que se abre un archivo para operaciones de E/S se efecta acceso aleatorio, analizaremos sta condicin.

Acceso aleatorio de archivos


En los programas presentados hasta este punto se han realizados operaciones secuenciales en el archivo, ya sea para escritura lectura de datos, empezando por el principio y continuando hasta el final del mismo. Las operaciones aleatorias en un archivo no necesariamente inician por el principio del archivo, en lugar de sto es posible desplazarse por el contenido del archivo para realizar una operacin de E/S. Para mover los apuntadores de archivo a posiciones especficas se utilizan dos funciones: seekg( ) coloca el apuntador de

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:

seekp(desplazamiento, posicion) seekg(desplazamiento, posicion)

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

ios::beg Desde el principio del archivo

ios::cur Desde la posicin actual del apuntador

ios::end Desde el fin del archivo

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; }

Ejemplo de Archivos y registros


#include <stdio.h>

#include <conio.h>

#include <string.h>

struct {

int clave;

char nombre[30];

int edad;} animalito;

void main() {

20

Archivos y Registros
clrscr();

//creando y cerrando el archivo en disco

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

EGRAFIA http://solanyerequena-programacion.blogspot.com/ http://www.programacionenc.net/index.php?option=com_content&view=arti cle&id=69:manejo-de-archivos-en-c&catid=37:programacion-cc&Itemid=55