Está en la página 1de 24

ENUNCIADO C16_02 Implementar en un programa, una clase cTexto2 que permita mostrar en pantalla el contenido de un archivo de texto.

Por cada 23 lneas mostradas se dar la posibilidad de continuar, presionando la tecla [Enter], o de abandonar, presionando la tecla [Esc]. El nombre del archivo ser ingresado desde el teclado. La clase debe considerar como dato un objeto de la clase ifstream definido en la librera fstream para el manejo del archivo del texto. Ctexto

Programa: C16_02 #include #include #include #include #include #include <conio.h> <iostream.h> <fstream.h> <string.h> udefteclas.h milib.h

//para el uso de la clase ifstream //para el uso de las teclas predefinidas //para el uso de las funciones de uso genrico

//definicin de la clase cTexto2 Class cTexto2 { Prvate: ifstream Arch texto; char texto[8l]; char NombreArch[4l]; int error; public: void inicializa(); void Ejecuta(); void finalizar(); }; //............................................................ //principal Void main() { cTexto2 objTexto; objTexto.inicializar(); objTexto.Ejecutar(); objTexto.finalizar(); } //desarrollo de la clase //............................................................ Void cTexto2::inicializa() { Clrscr(): Escribe Cad(1,1,Ingrese el nombre del archivo: ); strcpy(NombreArch, ingresa Cad(wherex(),wherey(),40)); Error=0; ArchTexto.open(NombreArch, ios::in \\ ios::nocreate); if(ArchTexto) { Error = 1; Mensaje(24,No puedo abrir el archivo); } } //........................................................... void cTexto2::Ejecuta() { char voRspta, voLetra;

//objeto de archivo para leer //incluye ruta y extensin

Int bolinea=0, voLetras=0; clrscr(); if(Error) if (ArchTexto.eof()) Mesaje(12,Archivo vacio); else { voRspta = cgTeclaEnter; while( !ArchTexto.eof() && voRspta == cgTeclaEnter) { voLetra = ArchText.get(); cout<<voLetra; voLetras++; if(voLetras == 79 \\voLetra == \n) { volinea++;voLetras = 0; ) if( volinea > 23) { EscribeCad(1,24, RepiteCad(79,_)); voRspta = EnterOEsc(25,ENTER= Continuar,ESC= Abandonar); if( voRspta == cgTeclaEnter) { clrscr(); bolinea=0; } } } } Mensaje(25,Fin del archivo); } } //.............................................................. void cTexto2::Finalizar() { If(!Error) ArchTexto.close(); } //.............................................................. //fin del programa

Observaciones: 1. La declaracin: Ifstream ArchTexto; //objeto de archivo leer Declara un objeto ArchTextode la clase ifstreamque se encuentra en la librera <fstream.h> 2. La sentencia: ArchTexto open(Nombre Arch,ios::

ENUNCIADO C16_03

PROGRAMA c16_03

#include #include #include #include #include #include

<conio.h> <iostream.h> <fstream.h> <string.h> milib.h udefteclas.h

//definicin de constes #define cgParaLectura 1 #define cgParaEscritura 0 //definicin de la clase cTexto3 Class cTexto3 { private: fstream ArchTexto; //objeto para el manejo del archivo char Texto[8l]; char Carcter; char NombreArch[4l]; //incluye ruta y extensin public: void Ejecutar(); int Menu(); void Crear(); void Adicionar(); void Mostrar(); void PantallaListado(); void PedirNombre(); int ExisteArchivo(); void CreaArchivo(); int ExisteArchivo(); void CreArchivo(); void AbreArchivo(int pvFormatoDeAcceso); void CierraArchivo(); }; //...................................................... //principal void main() { cTexto3 objTexto; objTexto.Ejecuta(); } //desarrollo de la clase //...................................................... Void cTexto3::Ejecutar() { int voOpcion; do { voOpcion = Menu(); switch (voOpcion) { case 1: Crear(); break; case 2: Adicionar(); break; case 3: Mostrar(); break; } } while (voOpcion!= 4 &&voOpcion !=0); } //........................................................ int cTexto3 :: Menu() { Char *opciones[]= { Crear archivo , Adicionar texto , Mostrar el contenido , Salir };

clrscr(); CentraCad( 8, ACCIONES POSIBLES CON ARCHIVOS DE TEXTO); centraCad( 9, RepiteCad(39,-)); return MenuPopUp (28,11, opciones,4); } //................................................... Void cTexto3::Crear() { PedirNombre(); if ( ExisteArchivo()) Mensaje(12, Archivo ya existe); else { CreaArchivo(); Mensaje(12, Ya he creado el archivo); } } //.................................................... void cTexto3 ::Adicionar() { int voSalir; PedirNombre(); if( ExisteArchivo()) Mensaje(12, Archivo no existe); else { AbreArchivo(cg ParaEscritura); clrscr(); cout<< Ingrese el texto, digite slo FIN para terminar << endl; cout<< RepiteCad(47,-)<< endl; voSalir = 0; do { strcpy(Texto,IngresaCad(1,wherey()+1,80)); if (strcmp(strupr(Texto), FIN) ==0) voSalir = 1; else ArchTexto << Texto << endl; }while (!voSalir); CierraArchivo(); } } //.......................................................... void cTexto3 :: Mostrar() { char voRspta; PedirNombre(); if(!ExisteArchivo()) Mensaje(12, Archivo no existe); else { AbreArchivo( cgParaLectura); if( ArchTexto.eof()) Mensaje(12, Archivo vacio); else { PantallaListado(); voRspta = bcgTeclaEnter; while(!ArchTexto.eof() && voRspta == cgTeclaEnter) { ArchTexto. get(Caracter); cout << Caracter; if(wherey()> 23 && !ArchTexto.eof())

{ voRspta = EnterOEsc(25, ENTER= Continuar, Esc= Abandonar); if (voRspta == cgTeclaEnter) PantallaListado(); } } if (voRspta == cgTeclaEnter) Mensaje2(5, No hay mas informacin); } CierraArchivo(); } }; //........................................................... void cTexto3 :: PantallaListado() { clrscr(); EscribeCad(1,24, RepiteCad(80, -)); gotoxy(1,1); } //........................................................... void cTexto3 :: PedirNombre() { clrscr(); EscribeCad(1,1 Ingrese el nombre del archivo: ); strcpy(NombreArch, IngresaCad(wherex(), wherey(), 40)); } //.............................................................. int cTexto3 :: ExisteArchivo() { ArchTexto.open(NombreArch,ios::in \ ios::nocreate); if(!ArchTexto) return 0; else { ArchTexto.close(); return 1; } }; //........................................................... void c Texto3 :: CreaArchivo() { ArchTexo.open(NombreArch, ios::out); ArchTexto.close(); } //........................................................... void cTexto :: AbreArchivo(int pvFormatoDeAcceso) { if (pvFormaDeAcceso == cgParaLectura) ArchTexto.open(NombreArch, ios::in); else//pvFormaDeAcceso = cgParaEscritura aadiendo ArchivoTexto.open(NombreArch, ios::app); }; //..................................................... void cTexto3.close() } //.................................................... //fin del programa

Enunciado c16_04a Archivo de Cabecera: uTexto4a.h #include <fstream.h> //definicin de la clase cTexto4a class cTexto4a { prvate:

fstream ArchTexto; //objeto de la clase fstream del c++ char Caracter; char NombreArch[4l];// incluye ruta y extensin int Error; //], cuando ocurra error al abrir el erchivo public: cTexto4a() {PedirNombre(); } void Ejecuta(); voidPedirNombre(); void AbreArchivo(); void CierraArchivo() { ArchTexto.close(); } void Mostrar(); void PantallaListado(); int ErrorAlAbrir() {return Error;} int FinDeArchivo() {return ArchTexto.eof();} char LeerCaracter(); }; //fin del archive de cabecera

Archivo De desarrollo: uTexto4a //desarrollo de la clase cTexto4a #include <conio.h> #include <fstream.h> #include <string.h> #include milib.h #include undefteclas.h #include utexto4a.h //................................................................. void cTexto4a :: Ejecutar() { AbreArchivo(); if (!Error) { Mostrar(); CierraArchivo(); } } //................................................................ void cTexto4a ::PedirNombre() { clrscr(); EscribeCad(1,1, Ingrese el nombre del archivo:); stcrpy(NombreArch, IngreseCad(wherex(), wherey(),40)); } //................................................................ void cTexto4a :: AbreArchivo() { int voResult; ArchTexto.open(NombreArch, ios::in \ ios::nocreate); if (!ArchTexto) { Mensaje(12,strcat(No existe el archivo: ,NombreArch)); Error=1; } else Error = 0; } //.................................................... void cTexto4a :: Mostrar() { char voRspta;

if (ArchTexto.eof()) Mensaje(12, Archivo vacio); else { PantallaListado(); voRspta = cgTeclaEnter; while (!ArchTexto.eof() && voRspta == cgTeclaEnter) { ArchTexto.get(Caracter); cout<<Caracter; if (wherey()>23 && !ArchTexto.eof()) { voRspta = EnterOEsc(25, ENTER= Continuar, ESC= Abandonar); if (voRspta == cg TeclaEnter) PantallaListado(); } } if (voRspta == cgTeclaEnter) Mensaje(25, No hay mas informacion); } } //................................................................ void cTexto4a :: PantallaListado() { clrscr(); EscribeCad(1,24, RepiteCad(80,-)); gotoxy(1,1); } //................................................................ char cTexto4a :: LeerCaracter() { ArchTexto.get(Caracter); Return Caracter; } //................................................................ //fin del archivo de desarrollo

Archivo de programa: ptexto4a

#include utexto4a.h void main() { cTexto4a objTexto4a; //Declaracion del objeto objTexto4a.Ejecuta(); //puesta en marcha del objeto } //fin del archivo de programa Construir Proyecto: pTexto4a.prj insertar los siguientes archivos: pTexto4a.cpp uTexto4a.cpp milib.cpp

ENUNCIADO C16_04b

Archivo de cabecera: yTexto4b.h

#include <fstream.h> #include utexto4a.h //definicin de la clase derivada cTexto4b class Ctexto4b : public cTexto4a { private: ofstream Impresora; public: cTexto4b(){Impresora.open(PRN,ios::out);} ~cTexto4b() {Impresora.close();} void Ejecuta(); int Menu(); void MostrarEnPantalla(); void MoatrarPorImpresora(); void Mostrar(); void PantallaListado(int &voNumLinea, char &voRspta); void Encabezado(); void NuevaPagina(); void IniciaLinea(); }; //Fin del archivo de cabecera

ARCHIVO DE DESARROLLO: uTexto4b.cpp

#include <conio.h> #include milib.h #include udefteclas.h #include utexto4b.h //DESARROLLO DE LA CLASE DERIVADA cTexto4b //............................................ void cTexto4b :: Ejecuta() { int voOpcion; do{ voOpcion = Menu(); switch (voOpcion) { case1: MostrarEnPantalla(); break; case2: MostrarPorImpresora(); break; } } while (voOpcion !=3); } //........................................................... int cTexto4b :: Menu() { char *opciones[]= { En Pantalla , En Impresora, Salir }; clscr(); CentraCad(8, MOSTRAR CONTENIDO DE ARCHIVO DE TEXTO); CentraCad(9, RepiteCad(37,-)); return MenuPopUp(30,11,opciones, 3); } //...............................................................

void cTexto4b :: MostrarEnPantalla() { cTexto4a :: Ejecuta(); } //...................................................................... void cTexto4b :: MostrarPorImpresora() { AbreArchivo(); if (!ErrorAlAbrir()) { Mostrar(); CierraArchivo(); } }; //.......................................................................... void cTexto4b :: Mostrar() { char voRspta, voCaracter; int voNumLinea; if (FinDeArchivo()) Mensaje(12, Archivo vacio); else { PantallaListador(voNumLinea, voRspta); Encabezado(); IniciaLinea(); while (!FinDeArchivo() && voRspta == cgTeclaEnter) { voCaracter = LeerCaracter(); Impresora<<voCaracter; if (voCaracter == cgTeclaEnter) { Impresora<< LeerCaracter(); voNumLinea++; InicialLinea(); if (voNumLinea ==55 && !FinDeArchivo()) { NuevaPagina(); voRspta = EnterOEsc(12, ENTER= Continuar,Esc= Abandonar); if (voRspta == cgTeclaEnter) { PantallaListado(voNuminea, voRspta); Encabezado(); IniciaLinea(); } } } } if (voRspta == cgTeclaEnter) { NuevaPagina(); Mensaje(12, No hay mas informacin); } } } //.................................................................... void cTexto4b :: PantallaListado(int &voNumLinea, char &voRspta) { clrscr(); CentroCad(12, Imprimiendo...); voNumLinea = 0; voRspta =cgTeclaEnter; } //.................................................................... void cTexto :: Encabezado() {

Impresora<< \10\10\10\10\10; } //............................................................ void cTexto4b :: NuevaPagina() { Impresora<< 12: } //........................................................... void cTexto4b :: IniciaLinea() { Impresora<< RepiteCad(10, ): } //.......................................................... //fin del archivo de desarrollo

ARCHIVO DE PROGRAMA: pTexto4b.cpp

#include utexto4b.h void main() { cTexto4b obj Texto4b: // declaracin del objeto objTexto4b.Ejecuta(); //puesta en marcha el objeto } //fin del archivo de programa

APLICANDO POLIMORFISMO SIN CLASES ABSTRACTAS

ENUNCIADO C16_05 Archivo de cabecera: uTexto5a.h

#include <conio.h> #include <fstream.h> #include <iostream.h> // definicion de la clase cTexto5a class cTexto5a { private: fstream ArchTexto; char Linea [8l]; char NombreArch[4l];// incluye ruta y extension int LineasPorPag; intError; public: cTexto5a(int pvLineasPorPag=23): LineasPorPag(pvLineasPorPag) {} ~cTexto5a() { clrscr();} void Ejecutar(); virtual void IniciaListado(); virtual voidImpreimeLinea() { cout<<Linea <<endl; } virtual void NuevaPagina() {} char * LineaLeida() { return Linea; };

private: void PedirNombre(); void AbreArchivo(); void CierraArchivo(); Void Mostrar(); }; // fin del archivo de cabecera Archivo de desarrollo: uTexto5a #include <string.h #include milib.h #include udefteclas.h #include utexto5a.h //DESARROLLO de la clase cTexto5a //..................................................... void cTexto5a :: Ejecuta() { PedirNombre(); AbreArchivo(); if (!Error) { Mostrar(); CierraArchivo(); } } //........................................................ void Ctexto5a :: IniciaLiastado()// virtual { clrscr(); EscribeCad(1, 24, RepiteCad(80,-)); gotoxy(1,1); } //......................................................... void cTexto5a :: Mostrar() { char voRspta: int voNumLinea; if (ArchTexto.eof()) Mensaje(12, Archivo vacio); else { IniciaListado(); voNumLinea = 0; voRspta = cgTeclaEnter; while (!ArchTexto.eof() && voRspta == cgTeclaEnter) { ArchTexto.getline(Linea,80,\-); ImprimeLinea(); voNumLinea++; if (voNumLinea== LineasPorPag && !ArchTexto.eof()) { NuevaPagina(); voRspta= EnterOEsc(25, ENTER= Continuar, ESC= Abandonar); if( voRspta== cgTeclaEnter) { IniciaListado(); voNumLinea= 0; } } } if (voRspta == cgTeclaEnter) {

NuevaPagina(); Mensaje(25, No hay mas infomacion); } } } //................................................................. void cTexto5a :: PedirNombre() { clrsscr(); EscribeCad(1,1, Ingrese el nombre del archivo:); strcpy(NombreArch,IngreseCad(wherex(), wherey(),40)); } //.................................................................... void cTexto5a :: AbreArchivo() { Error = 0; ArchTexto.open(NombreArch, ios::in \ ios::nocreate); if (!ArchTexto) { Mensaje(25, strcat(No puedo abrir el archivo:,NombreArch)); Error=1; } } //..................................................................... //fin del archivo de desarrollo

Archivo de programa: pTexto5a #include utexto5a.h void amain() { ctExto5a objTexto5a(20);//declaracin del objeto objTexto5a.Ejecuta(); // puesta en marcha del objeto } //fin del archiuvo de programa

ENUNCIADO C16_05b:

Archivo de cabecera //polimorfismo sin clase bae genrica #include <fstream.h> #include utexto5a.h // definicion de la clase derivadacTexto5b class cTexto5b: public cTexto5a { private: ofstream Impresora; public: cTexto5b(int pvLineasPorPag=50); ~cTexto5b(); private: virtual void InicialListado(); virtual void ImprimeLinea(); virtual void NuevaPagina();

}; // fin del archivo de cabecera

Archivo de desarrollo: uTexto5b #include <conio.h> #include <iostream.h #include milib.h #include uTexto5b.h //DESARROLLO DE LA CLASE cTesxto5b //............................................................ cTexto5b :: cTexto5b(int pvLineaPorPag); cTexto5a(pvLineasPorPag) { Impresora.open(PRN,IOS::OUT); } //............................................................. cTexto5b :: ~cTexto5b() { Impresora.close(); } //............................................................ void cTexto5b :: IniciaListado() //virtual { clrscr(); CentraCad(12, Imprimiendo...); Impresora<< \n\n\n\n\n; } //........................................................... void cTexto5b :: ImprimeLinea() //virtual { Impresora<<RepiteCad(10,)<<LineaLeida()<< endl; } //.............................................................. void cTexto5b :: NuevaPagina() //virtual { CentraCad(12, RepiteCad(14,)); Impresora<<\12; } //.............................................................. //fin del archivo de desarrollo

Archivo de programa: pTexto5b

#include utexto5b.h void main() { cTexto5b objTexto5b(50);// declaracion de objeto objTexto5b.Ejecuta(); //puesta en marcha del objeto } //fin del archivo de programa

APLUCANDO POLIMORFISMO CON CLASES ABSTRACTAS Enunciado C16_05c Archivo de cabecera: uTexto5c.h

// polimorfismo definiendo una clase genrica cListadoGen Class cListadoGen { private: int FilaIniList, FilaFinList, Error; public: cListadoGen(int pv FilaFinList = 23) { FilaFinList = pv FilaFinList; error = 1;} void Ejecutar(); virtual virtual virtual virtual virtual virtual int FinDeListado()= 0; //funcin virtual pura void IrAlInicio()= 0; //funcin virtual pura void IrAlSiguiente= 0; //funcin virtual pura void LeerInformacion()= 0 //funcin virtual pura char *Informacion()= 0 //funcin virtual pura char *Encabezado() {return\0;}

void RegistraExito() { Error=0; } void RegistraError() { Error=1; } int ExisteError() { return Error; } private: void PantallaListado(); }; // fin del archivo de cabecera

Archivo de desarrollo: uTexto5c //DESARROLLO DE LA CLASE BASE GENERICA uListadoGen #include <iostream.h> #include <conio.h> #include <string.h> #include milib.h #include uDefTeclas.h #include utexto5c.h //................................................... void cListadGen :: Ejecutar() { int voFila; char voRspta; char voRspta; if (!Error) { clrscr(); IrAlInicio(); if (FinDeListado()) Mensaje(12, No hay informacin registrada); else { PantallaListado(); voFila = FilaIniList voRspta= cgTeclaEnter; while (!FinDeListado() && voRspta == cgTeclaEnter) { LeerInfortmacion(); EscribeCad(1, voFila,Informacion()); IrAlSiguiente(); voFila++; if (voFila>FilaFinList &&!FinDeListado()) {

voRspta=EnterOEsc(25, ENTER= Continuar, ESC= Abandonar); if (voRspta == cgTeclaEnter) { BorraArea(1, FilaList,80, FilaFinList); voFila = FilaIniList; } } } if (voRspta == cgTeclaEnter) Mensaje(25, No hay mas informacin); clrscr(); } } } //.................................................. void cListadoGen :: PantallaListado() { char *voEncabezado; clrscr(); voEncabezado = Encabezado(); if (strlen(voEncabezado) ==0) FilaFinList = 1; else { EscribeCad(1,1, voEncabezado); EscribeCad(1,2, RepiteCad(80,-)); FilaIniList = 3; } EscribeCad(1,24, RepiteCad(80,-)); } //............................................................ //fin del archivo de desarrollo Archivo de programa: NO SE PUEDE DECLARAR OBJETOS DE CLASES ABSTRACTAS.

ENUNCIADO C16_05d Archivo de cabecera: uTexto5d.h

//polimorfismo con clase base geberica #include <fstream.h> #include uTexto5c.h // definicin de la clase derivada cListArchTexto class cListArchTexto: public clistadoGen { private: ifstream ArchTexto; //objeto para manejar el archivo char Texto [8l]; public: cListArchTexto(char *pvNombreArch); ~cListArchTexto(); private: virtual int FinDeListado(); virtual void LeerInformacion(); virtual char* Informacion() { return Texto; } virtual void IrAlInicio() {} virtual void IrAlSiguiente() {} };

//fin del archivo de cabecera

Archivo de desarrollo: uTexto5d.cpp //DESARROLLO DE LA CLASE derivada cListArchTexto #include <string.h> #include milib.h #include utexto5d.h //............................................................. cListArchTexto :: cListArchTexto(char *pvNombreArch) { // cListadoGen(); ArchTexto.open(pvNombreArch); if (!ArchTexto) EscribeCad(1.1, strcat( No puedo abrir el archivo:, pvNombreArch)); else RegistraExito(); } //.................................................................. cListArchTexto :: ~cListArchTexto() { if(!ExisteError()) ArchTexto.close(); } //...................................................................... int cListArchTexto :: FinDeListado()//virtual { return ArchTexto.eof()?l:0; } //................................................................. void cListArchTexto :: LeerInformacion()//virtual { ArchTexto.getline(Texto,80,\n); //reemplaza cadatabulador por 3 espacios en blanco if (strlen(Texto)> 0) { char*nuevotexto = new char[8l]; nuevotexto[0]=\0; for (int i=0, j=0; i<strlen(Texto); i++) if(Texto[i]!= \i) nuevotexto[j++]= Texto[i]; else { strcat(nuevotexto, ); j+= 3; } nuevotexto[j]=0; strcpy(Texto,nuevotexto); delete nuevotexto; } } //...................................................................... //fin del archivo de desarrollo

Archivo de programa: pTexto5d.cpp #include utexto5d.h

void main() { cListArchTexto objListArchTexto(utexto); objListArchTexto.Ejecutar(); } //fin del archivo de programa

CAPTULO 17 ARCHIVOS BIANRIOS O STREAMS

Los archivos binarios se caracterizan porque su contenido son registros cuyo tipo de dato es una estructura C++ asume por defecto que todos sus archivos son de texto, por lo tanto, para indicarle que no lo son se debe especificar en el momento de la apertura del archivo que son binarios como lo veremos en las aplicaciones del presente capitulo. C++ dispone en su librera <fstream.h> la definicin de las siguientes calses:

Clase ifstream.- Permite declarar objetos que manejen archivos cuyo acceso sea solamente de entrada (input file stream), esta clase dispone de los siguientes mtodos o funciones mas utilizados. Open (Nombre); //abre el archivo Close (); //cierra el archivo Get (caracter); //obtinene un carcter o byte Eof() //Determina si se alcanz el fin del archivo Ejm: Mostrar en pantalla el contenido del archivo autoexec.bat #include <conio.h> #include <iostream.h> #include <fstream.h> void main () { ifstream archivoln; char caracter; clrscr(); archive.open(c:\autoexec.bat); while (! archivoln.eof()) { archivoln.get(caracter); //lee character del archivo cout<<caracter; //muestra caracter en pantalla } archivoln.close(); } //fin del programa ejemplo

Clase ofstream.- Permite declarar objetos que manejen archivos cuyo acceso sea solamente de grtabacion o salida (output file stream), esta clase dispone de los siguientes mtodos o funciones mas utilizados: open (nombre); //abre el archivo close (); //cierra el archivo put (caracter); //graba un carcter o byte eof() //determina si se alcanz el fin del archivo

tambin se puede utilizar el operador de insersin << que normalmente se utiliza con el objeto cout. Claro es que el objeto cout est relacionada con la pantalla por ello que todas las salidas con cout van hacia la pantalla. Ejm: Sacar una copia del archivo autoxec.bat grabndolo en otro archivo de nombre autoexec.bak. #include <conio.h> #include <iostream.h> #include <fstream.h> void main() { ifstream archivoln; //objeto para archivo de entrada ofstream archivoOut; //objeto para archivo de salida char carcter; clrscr(); archivoln.open(c:\autoexec.bat); archivoOut.open(c:\autoexeec.bak); while (!archivoln.eof()) { archivo ln.get(caracter); //lee character del archivo if (caracter!=13) //graba caracter en archive de salida archivoOut <<carcter; else //graba caracter de fin de lnea en archivo de salida archivoOut << endl; } archivoln.close(); //cierra archivo de entrada archivoOut.close();//cierra archivo de salida } //fin del programa ejemplo

Clase fstream.- Permite declarar objetos que manejan archivos cuyo acceso sea de entrada, de salida, o de entrada y de salida a la vez (file stream). Esta clase normalmente se utiliza para el manejo de archivos binarios como veremos en las plicaciones de este captulo. Esta clase dispone de los siguientes mtodos o funciones mas utilizados: //abre el archivo open (nombre, modo de acceso), modo de acceso: ios :: in solo entrada ios :: out solo salida ios :: binarybinario combinacin de los anteriores con el separador | ios :: in|ios::out|ios::binary //cierra el archivo close (); //lee cierta cantidad de bytes del archivo hacia una direccin de memoria de una variable que sea capaz de recibir la informacin de acuerdo a su estructura de datos. read((char*)&Registro, tamao en bytes); //graba cierta cantidad de bytes en el archivo desde la direccin de memoria de una variable que contiene informacin de acuerdo a una estructura de datos. write((char*)&Registro, tamao en bytes): //determina si se alcanz el fin del archivo: 1 Verdad, 0 Falso. eof()

//traslada el puntero de registro hacia una operacin de lectura: seekg(desplazamiento en bytes, referencia); referencia puede ser ios::beg //desde el inicio ios::end //despus del final ios::cur //posicin actual

posicin determinada

antes de una

desplazamiento en bytes, normlmente es una frmula: posicin*sizeof(registro) Ejm1: Trasadar al puntero de lectura al inicio de archivo: archivo.seekg(0,ios::beg); Ejm2: Trasladar al puntero de lectura al final del archivo archivo.seekg(0,ios::end); Ejm3: Trasladar al puntero de lectura a la posicin 5 del archivo: archivo.sekkg(5*sizeof(registro),ios::beg);

APLICANDO ENCAPSULAMIENTO: Enunciado C17_01 Nombre Programa : #include #include #include #include #include pBinl.cpp

<conio.h> <fstream.h> <string.h> milib.h udefteclas.h

//definicion de la clase cObrero class cObrero { //definicion de su estructura struc sRegObrero { char Codigo[5]; char Apellidos[21]; char Nombres[21]; char FechaIngreso[12]; float SueldoBasico; char Estado; //1 =activo, 0 =anulado }; //definicion de sus datos private: fstream ArchObrero; //objeto de la clase fstream del c++ sRegObrero RegObrero; int NumRegObreros, TamRegObrero; int ErrorAlAbrir; //definicin de sus procesos public: cObrero(char+pvNombreArch); void Ejecutar(); ~cObrero(); int Menu(); void Ingreso(); void FormatoDePantalla(); int IngresaCodigo(); int UbicaRegistro();

void void void void

IngresaOtrosCampos(); AlmacenaRegistro(); Listado(); Titulos(int &pvNumFila);

}; //...................................................................... //principal void main() { cObrero objObrero(OBREROS.DAT): //declaracin del objeto objObrero.Ejecutar(); //puesta en marcha del objeto } //implementacion de la clase cObrero //.................................................................... void cObrero :: cObrero(char *pvNombreArch) { ArchObrero.open(pvNombreArch, ios::in|ios::outios::binary); if(!ArchObrero) { Mensaje(24,ERROR al Abrir el Archivo); ErrorAlAbrir = 1; } else { ErrorAlAbrir =0; TamRegObrero = sizeof(sRegObrero); ArchObrero.seekg(0,ios::end); NumRegObreros = ArchObrero.tellg()/TamRegObrero; } } //........................................................................ void cObrero :: Ejecuta() { int voOpcion; do{ voOpcion = Menu(); switch ( voOpcion) { case1: Ingreso(); break; case2: Listado(); break; } }while ( voOpcion !=0 && voOpcion !=3); } //........................................................................... void cObrero :: ~cObrero() { if(!ErrorAlAbrir) ArchObrero.close(); } //........................................................................ int cObrero ::Menu() { char*opciones[] = { Ingreso , Listado , Fin }; clrscr(); CentraCad(5, MENU de OPCIONES); return MenuPopUp(36.7, opciones,3); } //.................................................................. void cObrero ::Ingreso() { int voPosicion, voIngresaCodigo;

if(!ErrorAlAbrir) do { FormatoDePantalla(); voIngresaCodigo = IngresaCodigo(); if (voIngresaCodigo) { //busca el codigo ingresado en el archivo, secuencialmente voPosicion = UbicaRegistro(); if (voPoscicion!=-1)//lo encontr Mensaje(24,Codigo Repetido); else //no lo encuentro { IngresaOtrosCampos(); AlmacenaRegistro(); } } }while ( voIngresaCodigo ); } //........................................................... void cObrero :: FormatoDePantalla() { //muestra formato de pantalla para el ingreso de datos clrscr(); CentraCad(3,INGRESO DE NUEVOS OBREROS); EscribeCad(10,5,Codigo :); EscribeCad(10,6,Apellidos :); EscribeCad(10,7,Nombres :); EcsribeCad(10,8,Fecha Ingreso: ); EscribeCad(10,9,9Sueldo Basico: ); CentraCad(22,PARA TERMINAR, presione slo Enter al ingresar el CODIGO); } //................................................................. void Obrero :: Titulos(int &prNumFila) { clrscr(); EscribeCad(1, 1,CODIGO); EscribeCad(8,1,APELLIDOS); EscribeCad(30,1,NOMBRES); EscribeCad(52,1,FECHA ING.); EscribeCad(68,1,S.BASICO); EscribeCad(1,2,RepiteCad(80,=)); prNumFila =3; } //....................................................................... //fin del programa

APLICANDO HERENCIA Eninciadoc17_02 Archivo de cabecera: uBin2a.h

#if!defined_uBin2a_h_ #define_uBin2a_h_ #include <ifstream.h> //definicion de la clase cObrero class cObrero { //definicion de su estructura

struct sRegObrero { char Codigo[5]; char Apellidos[21]; char Nombres[21]; char FechaIngreso[12]; float SueldoBasico; char Estado; //1= activo, 0= anulado }; //definicion de sus datos private: fstream ArchObrero; //objeto de la clase fstream del c++ sRegObrero RegObrero; int NumRegObreros, TanRegObrero; int ErroAlAbrir; public: cObrero(char* pvNombreArch);} ~cObrero() void Ejecutar(); void Ingreso(); void Listado(); private: int Menu(); void Titulos(int &pvNumFila); public: void FormatoDePantalla(char*pvTitulo); int IngresaCodigo(); int UbicaRegistro(); void IngresaOtrosCampos(); void AdicionaRegistro(); //metodos que serviran como mensajes de comunicacion int mErrorApertura() { return ErrorAlAbrir; } void mIrAlInicio() { ArchObrero.seekg(0,ios::beg); } void mRcuperaRegistro(int pvPosicion, sRegObrero &prRegObrero); void mReGrabaRegistro(int pvPosicion, sRegObrero pvRegObrero); int mNumeroDeRegistros() { return NumRegObreros; } int MFinDeArchivo() { return ArchObrero.eof(); } }; #endif //fin del archive de cabecera

También podría gustarte