Introduccin Los archivos tambin denominados ficheros (files); son una coleccin de informacin (datos relacionados entre s),

localizada o almacenada como una unidad en alguna parte de la computadora. Los archivos son el conjunto organizado de informaciones del mismo tipo, que pueden utilizarse en un mismo tratamiento; como soporte material de estas informaciones. Los archivos pueden ser contrastados con Arrays y registros; Lo que resulta dinmico y por esto en un registro se deben especificar los campos, l nmero de elementos de un arrays (o arreglo), el nmero de caracteres en una cadena; por esto se denotan como "Estructuras Estticas". En los archivos no se requiere de un tamao predeterminado; esto significa que se pueden hacer archivos de datos ms grandes o pequeos, segn se necesiten. Cada archivo es referenciado por su identificador (su nombre.). Los archivos como coleccin de datos sirven para la entrada y salida a la computadora y son manejados con programas a travs de Clases predefinidas para tal fin.

Clases predefinidas para el manejo de archivos en JAVA Todos los lenguajes de programacin tienen alguna forma de interactuar con los sistemas de ficheros locales; Java no es una excepcin. Cuando se desarrollan applets para utilizar en red, hay que tener en cuenta que la entrada/salida directa a fichero es una violacin de seguridad de acceso. Muchos usuarios configurarn sus navegadores para permitir el acceso al sistema de ficheros, pero otros no. Por otro lado, si se est desarrollando una aplicacin Java para uso interno, probablemente ser necesario el acceso directo a ficheros. Antes de realizar acciones sobre un fichero, necesitamos un poco de informacin sobre ese fichero. La clase File proporciona muchas utilidades relacionadas con ficheros y con la obtencin de informacin bsica sobre esos ficheros.

Creacin de un objeto File Para crear un objeto File nuevo, se puede utilizar cualquiera de los tres constructores siguientes:

File miFichero; miFichero = new File( "/etc/kk" ); o miFichero = new File( "/etc","kk" ); o File miDirectorio = new File( "/etc" ); miFichero = new File( miDirectorio,"kk" ); El constructor utilizado depende a menudo de otros objetos File necesarios para el acceso. Por ejemplo, si slo se utiliza un fichero en la aplicacin, el primer constructor es el mejor. Si en cambio, se utilizan muchos ficheros desde un mismo directorio, el segundo o tercer constructor sern ms cmodos. Y si el directorio o el fichero es una variable, el segundo constructor ser el ms til. Comprobaciones y Utilidades Una vez creado un objeto File, se puede utilizar uno de los siguientes mtodos para reunir informacin sobre el fichero: Nombres de fichero String getName() String getPath() String getAbsolutePath() String getParent() boolean renameTo( File nuevoNombre )

Comprobaciones boolean exists() boolean canWrite() boolean canRead() boolean isFile() boolean isDirectory() boolean isAbsolute() Informacin general del fichero long lastModified() long length() Utilidades de directorio boolean mkdir() String[] list() Ejemplo de una pequea aplicacin que muestra informacin sobre los ficheros pasados como argumentos en la lnea de comandos, InfoFichero.java:
import java.io.*; class InfoFichero

{ public static void main( String args[ ] ) throws IOException { if( args.length > 0 ) { for( int i=0; i < args.length; i++ ) { File f = new File( args[ i ] ); System.out.println( "Nombre: "+f.getName( ) ); System.out.println( "Camino: "+f.getPath( ) ); if( f.exists( ) ) { System.out.print( "Fichero existente " ); System.out.print( (f.canRead() ? " y se puede Leer" : "" ) ); System.out.print( (f.canWrite() ? " y se puede Escribir" : "" ) ); System.out.println( "." ); System.out.println( "La longitud del fichero son "+ f.length()+" bytes" ); } else System.out.println( "El fichero no existe." ); } } else System.out.println( "Debe indicar un fichero." ); } }

Streams de entrada Hay muchas clases dedicadas a la obtencin de entrada desde un fichero. Este es el esquema de la jerarqua de clases de entrada por fichero:

Objetos FileInputStream Los objetos FileInputStream tpicamente representan ficheros de texto accedidos en orden secuencial, byte a byte. Con FileInputStream, se puede elegir acceder a un byte, varios bytes o al fichero completo. Apertura de un FileInputStream Para abrir un FileInputStream sobre un fichero, se le da al constructor un String o un objeto File: FileInputStream mi FicheroSt; miFicheroSt = new FileInputStream( "/etc/kk" );

Tambin se puede utilizar: File miFichero FileInputStream miFicheroSt; miFichero = new File( "/etc/kk" ); miFicheroSt = new FileInputStream( miFichero );

Lectura de un FileInputStream Una vez abierto el FileInputStream, se puede leer de l. El mtodo read() tiene muchas opciones: int read(); Lee un byte y devuelve -1 al final del stream. int read( byte b[ ] ); Llena todo el array, si es posible. Devuelve el nmero de bytes ledos o -1 si se alcanz el final del stream. int read( byte b[ ],int offset,int longitud ); Lee longitud bytes en b comenzando por b[ offset ]. Devuelve el nmero de bytes ledos o -1 si se alcanz el final del stream.

Cierre de FileInputStream Cuando se termina con un fichero, existen dos opciones para cerrarlo: explcitamente, o implcitamente cuando se recicla el objeto (el garbage collector se encarga de ello).

Para cerrarlo explcitamente, se utiliza el mtodo close(): miFicheroSt.close(); Ejemplo: Visualizacin de un fichero Si la configuracin de la seguridad de Java permite el acceso a ficheros, se puede ver el contenido de un fichero en un objeto TextArea. El cdigo siguiente contiene los elementos necesarios para mostrar un fichero:
FileInputStream fis; TextArea ta; public void init( ) { byte b[ ] = new byte[1024]; int i; /* El buffer de lectura se debe hacer lo suficientemente grande o esperar a saber el tamao del fichero*/ String s; try { fis = new FileInputStream( "/etc/kk" ); } catch( FileNotFoundException e ) { /* Hacer algo */ } try { i = fis.read( b ); } catch( IOException e ) { /* Hacer algo */ } s = new String( b,0 ); ta = new TextArea( s,5,40 ); add( ta ); }

Objetos DataInputStream Los objetos DataInputStream se comportan como los FileInputStream. Los streams de datos pueden leer cualquiera de las variables de tipo nativo, como floats, ints o chars. Generalmente se utilizan DataInputStream con ficheros binarios.

Apertura y cierre de DataInputStream Para abrir y cerrar un objeto DataInputStream, se utilizan los mismos mtodos que para FileInputStream:

DataInputStream miDStream; FileInputStream miFStream; //Obtiene un controlador de fichero miFStream = new FileInputStream "/etc/ejemplo.dbf"); //Encadena un fichero de entrada de datos miDStream = new DataInputStream( miFStream );//Ahora se pueden utilizar los dos streams de entrada para acceder //al fichero (si se quiere...)

miFStream.read( b ); i = miDStream.readInt(); //Cierra el fichero de datos explcitamente, siempre se cierra primero el fichero stream de mayor nivel miDStream.close(); miFStream.close();

Lectura de un DataInputStream Al acceder a un fichero como DataInputStream, se pueden utilizar los mismos mtodos read() de los objetos FileInputStream. No obstante, tambin se tiene acceso a otros mtodos diseados para leer cada uno de los tipos de datos: byte readByte( ) int readUnsignedByte( ) short readShort( ) int readUnsignedShort( ) char readChar( ) int readInt( ) long readLong( ) float readFloat( ) double readDouble( ) String readLine( ) Cada mtodo leer un objeto del tipo pedido. Para el mtodo String readLine( ), se marca el final de la cadena con n, r, rn o con EOF.

Para leer un long, por ejemplo: long numeroSerie; ... numeroSerie = miDStream.readLong(); Streams de entrada de URLs Adems del acceso a ficheros, Java proporciona la posibilidad de acceder a URLs como una forma de acceder a objetos a travs de la red. Se utiliza implcitamente un objeto URL al acceder a sonidos e imgenes, con el mtodo getDocumentBase() en los applets:

String imagenFich = new String( "imagenes/pepe.gif" ); imagenes[0] = getImage( getDocumentBase(),imagenFich );

No obstante, se puede proporcionar directamente un URL, si se quiere: URL imagenSrc; imagenSrc = new URL( "http://enterprise.com/~info" imagenes[0] = getImage( imagenSrc,"imagenes/pepe.gif" ); );

Apertura de un Stream de entrada de URL Tambin se puede abrir un stream de entrada a partir de un URL. Por ejemplo, se puede utilizar un fichero de datos para un applet: ImputStream is; byte buffer[] = new getDocumentBase(),datos).openStream(); byte[24]; is = new URL(

Ahora se puede utilizar is para leer informacin de la misma forma que se hace con un objeto FileInputStream: is.read( buffer,0,buffer.length ); NOTA: Debe tenerse muy en cuenta que algunos usuarios pueden haber configurado la seguridad de sus navegadores para que los applets no accedan a ficheros.

Streams de salida La contrapartida necesaria de la lectura de datos es la escritura de datos. Como con los Streams de entrada, las clases de salida estn ordenadas jerrquicamente:

Examinaremos las clases FileOutputStream y DataOutputStream para complementar los streams de entrada que se han visto. En los ficheros fuente del

directorio $JAVA_HOME/src/java/io se puede ver el uso y mtodos de estas clases, as como de los streams de entrada ($JAVA_HOME es el directorio donde se halla instalado el Java Development Kit, en sistemas UNIX).

Objetos FileOutputStream Los objetos FileOutputStream son tiles para la escritura de ficheros de texto. Como con los ficheros de entrada, primero se necesita abrir el fichero para luego escribir en l.

Apertura de un FileOutputStream Para abrir un objeto FileOutputStream, se tienen las mismas posibilidades que para abrir un fichero stream de entrada. Se le da al constructor un String o un objeto File. FileOutputStream miFicheroSt; miFicheroSt = new FileOutputStream( "/etc/kk" ); Como con los streams de entrada, tambin se puede utilizar: File miFichero FileOutputStream miFicheroSt; File miFichero FileOutputStream miFicheroSt; miFichero = new File( "/etc/kk" ); miFicheroSt = new FileOutputStream( miFichero );

Escritura en un FileOutputStream Una vez abierto el fichero, se pueden escribir bytes de datos utilizando el mtodo write(). Como con el mtodo read() de los streams de entrada, tenemos tres posibilidades: void write( int b ); Escribe un byte. void write( byte b[ ] ); Escribe todo el array, si es posible. void write( byte b[ ],int offset,int longitud ); Escribe longitud bytes en b comenzando por b[offset].

Cierre de FileOutputStream Cerrar un stream de salida es similar a cerrar streams de entrada. Se puede utilizar el mtodo explcito: miFicheroSt.close(); O, se puede dejar que el sistema cierre el fichero cuando se recicle miFicheroSt.

Ejemplo: Almacenamiento de Informacin Este programa, Telefonos.java, pregunta al usuario una lista de nombres y nmeros de telfono. Cada nombre y nmero se aade a un fichero situado en una localizacin fija. Para indicar que se ha introducido toda la lista, el usuario especifica "Fin" ante la solicitud de entrada del nombre. Una vez que el usuario ha terminado de teclear la lista, el programa crear un fichero de salida que se mostrar en pantalla o se imprimir. Por ejemplo: 95-4751232,Juanito 3547621,Maria 564878,Luisa 123456,Pepe 347698,Antonio 91-

El cdigo fuente del programa es el siguiente:

import java.io.*; class Telefonos { static FileOutputStream fos; public static final int longLinea = 81; public static void main( String args[ ] ) throws IOException { byte tfno[ ] = new byte[longLinea]; byte nombre[ ] = new byte[longLinea]; fos = new FileOutputStream( "telefono.dat" ); while( true ) { System.err.println( "Teclee un nombre ('Fin' termina)" ); leeLinea( nombre ); if( "fin".equalsIgnoreCase( new String( nombre,0,0,3 ) ) ) break; System.err.println( "Teclee el nmero de telfono" ); leeLinea( tfno ); for( int i=0; tfno[i] != 0; i++ ) fos.write( tfno[i] ); fos.write( ',' ); for( int i=0; nombre[i] != 0; i++ )

fos.write( nombre[i] ); fos.write( 'n' ); } fos.close(); } private static void leeLinea( byte linea[ ] ) throws IOException { int b = 0; int i = 0; while( (i < ( longLinea-1) ) && ( ( b = System.in.read() ) != 'n' ) ) linea[i++] = (byte)b; linea[i] = (byte)0; } }

Streams de salida con buffer Si se trabaja con gran cantidad de datos, o se escriben muchos elementos pequeos, ser una buena idea utilizar un stream de salida con buffer. Los streams con buffer ofrecen los mismos mtodos de la clase FileOutputStream, pero toda salida se almacena en un buffer. Cuando se llena el buffer, se enva a disco con una nica operacin de escritura; o, en caso necesario, se puede enviar el buffer a disco en cualquier momento. Creacin de Streams de salida con buffer Para crear un stream BufferedOutput, primero se necesita un stream FileOutput normal; entonces se le aade un buffer al stream:

FileOutputStream miFileStream; BufferdOutpurStream miBufferStream; miFileStream = new FileOutputStream( "/tmp/kk" ); //Obtiene un controlador de fichero miBufferStream = new BufferedOutputStream( miFileStream ); //Encadena un stream de salida con buffer

Volcado y Cierre de Streams de salida con buffer Al contrario que los streams FileOutput, cada escritura al buffer no se corresponde con una escritura en disco. A menos que se llene el buffer antes de que termine el programa, cuando se quiera volcar el buffer explcitamente se debe hacer mediante una llamada a:
flush(): miBufferStream.flush( ); //Se fuerza el volcado del buffer a disco

miBufferStream.close(); //Cerramos el fichero de datos. Siempre se ha de cerrar primero el fichero stream de mayor nivel miFileStream.close();

Streams DataOutput Java tambin implementa una clase de salida complementaria a la clase DataInputStream. Con la clase DataOutputStream, se pueden escribir datos binarios en un fichero. Apertura y cierre de objetos DataOutputStream Para abrir y cerrar objetos DataOutputStream, se utilizan los mismos mtodos que para los objetos FileOutputStream:

DataOutputStream miDataStream; FileOutputStream miFileStream; BufferedOutputStream miBufferStream; miFileStream = new FileOutputStream( "/tmp/kk" ); // Obtiene un controlador de fichero miBufferStream = new BufferedOutputStream( miFileStream ); /* Encadena un stream de salida con buffer (por eficiencia)*/ miDataStream = new DataOutputStream( miBufferStream ); /* Encadena un fichero de salida de datos*/ miBufferStream.write( b ); /* Ahora se pueden utilizar los dos streams de entrada para acceder al fichero (si se quiere)*/ miDataStream.writeInt( i ); miDataStream.close( ); /* Cierra el fichero de datos explcitamente. Siempre se cierra primero el fichero stream de mayor nivel*/ miBufferStream.close( ); miFileStream.close( );

Escritura en un objeto DataOutputStream Cada uno de los mtodos write() accesibles por los FileOutputStream tambin lo son a travs de los DataOutputStream. Tambin encontrar mtodos complementarios a los de DataInputStream:

void writeBoolean( boolean b ); void writeByte( int i ); void writeShort( int i ); void writeChar( int i );

void writeInt( int i ); void writeFloat( float f ); void writeDouble( double d ); void writeBytes( String s ); void writeChars( string s ); Para las cadenas, se tienen dos posibilidades: bytes y caracteres. Hay que recordar que los bytes son objetos de 8 bits y los caracteres lo son de 16 bits. Si nuestras cadenas utilizan caracteres Unicode, debemos escribirlas con writeChars( ). Contabilidad de la salida Otra funcin necesaria durante la salida es el mtodo size( ). Este mtodo simplemente devuelve el nmero total de bytes escritos en el fichero. Se puede utilizar size( ) para ajustar el tamao de un fichero a mltiplo de cuatro. Por ejemplo, de la forma siguiente: . . . int numBytes = miDataStream.size( ) % 4; for( int i=0; i < numBytes; i++ ) miDataStream.write( 0 ); . . .

Ficheros de Acceso Aleatorio A menudo, no se desea leer un fichero de principio a fin; sino acceder al fichero como una base de datos, donde se salta de un registro a otro; cada uno en diferentes partes del fichero. Java proporciona una clase RandomAccessFile para este tipo de entrada/salida. Creacin de un Fichero de Acceso Aleatorio Hay dos posibilidades para abrir un fichero de acceso aleatorio: Con el nombre del fichero: miRAFile = new RandomAccessFile( String nombre,String modo ); Con un objeto File: miRAFile = new RandomAccessFile( File fichero,String modo ); El argumento modo determina si se tiene acceso de slo lectura (r) o de lectura/escritura (r/w). Por ejemplo, se puede abrir un fichero de una base de datos para actualizacin:

RandomAccessFile miRAFile; miRAFile = new RandomAccessFile( "/tmp/kk.dbf","rw" ); Acceso a la Informacin Los objetos RandomAccessFile esperan informacin de lectura/escritura de la misma manera que los objetos DataInput/DataOutput. Se tiene acceso a todas las operaciones read() y write() de las clases DataInputStream y DataOutputStream. Tambin se tienen muchos mtodos para moverse dentro de un fichero: long getFilePointer(); Devuelve la posicin actual del puntero del fichero void seek( long pos ); Coloca el puntero del fichero en una posicin determinada. La posicin se da como un desplazamiento en bytes desde el comienzo del fichero. La posicin 0 marca el comienzo de ese fichero. long length(); Devuelve la longitud del fichero. La posicin length() marca el final de ese fichero.

Actualizacin de Informacin Se pueden utilizar ficheros de acceso aleatorio para aadir informacin a ficheros existentes: miRAFile = new RandomAccessFile( "/tmp/kk.log","rw" ); miRAFile.seek( miRAFile.length() ); // Cualquier write( ) que hagamos a partir de este punto del cdigo aadir informacin al fichero

Ejemplo: Log.java, que aade una cadena a un fichero existente:

import java.io.*; //Cada vez que ejecutemos este programa, se incorporara una nueva lnea al //fichero de log que se crea la primera vez que se ejecuta class Log { public static void main( String args[ ] ) throws IOException { RandomAccessFile miRAFile; String s = "Informacion a incorporar\nTutorial de Java\n"; miRAFile = new RandomAccessFile( "/tmp/java.log","rw" );//Abrimos el fichero de acc. Aleatorio miRAFile.seek( miRAFile.length() ); // Nos vamos al final del fichero

miRAFile.writeBytes( s ); // Incorporamos la cadena al fichero miRAFile.close();// Cerramos el fichero } }

Clases para el manejo archivos en C++ Existen tres clases para manejar ficheros: ifstream, ofstream y fstream. La primera est orientada a ficheros de entrada, la segunda a ficheros de salida, y la tercera puede manejar cualquiera de los dos tipos o ficheros de entrada y salida. Clase ifstream: El constructor est sobrecargado para poder crear streams de varias maneras: ifstream(); ifstream(const char *name, int mode = ios::in, int = filebuf::openprot);El primero slo crea un stream de entrada pero no lo asocia a ningn fichero. El segundo lo crea, lo asocia al fichero con el nombre "name" y lo abre. Los parmetros son: el nombre del fichero, el modo, que para ifstream es ios::in por defecto. El tercer parmetro se refiere al buffer, y no nos preocupa de momento. Clase ofstream: Lo mismo pasa con ofstream, salvo que los valores por defecto de los parmetros son diferentes: ofstream(); ofstream(const char *name, int mode = ios::out, int = filebuf::openprot);Clase fstream:fstream(); fstream(const char *name, int mode = ios::in, int = filebuf::openprot);Mtodo open:Todas estas clases disponen adems del mtodo "open", para abrir el fichero a lo largo de la ejecucin del programa. void open(const char *name, int mode, int prot=filebuf::openprot);"name" es el nombre del fichero, mode es el modo en que se abrir, puede ser uno o una combinacin del tipo enumerado open_mode, de la clase "ios":

enum open_mode { in, out, ate, app, trunc, nocreate, noreplace, binary }; Cada uno de los valores se pueden combinar usando el operador de bits OR (|), y significan lo siguiente: in: modo de entrada. out: modo de salida. ate: abre el fichero y sita el cursor al final. app: modo append, parecido al anterior, pero las operaciones de escritura siempre se hacen al final del fichero. trunc: si se aplica a ficheros de salida, se crear el fichero si no existe previamente, o se truncar con un tamao de 0 bytes, si existe. nocreate: impide crear un fichero si no existe, en ese caso, la funcin falla. noreplace: lo ignoro. binary: abre el fichero en modo binario. Los tres ltimos modos probablemente no son estndar, y es posible que no existan en muchos compiladores. Mtodo close:void close(); Sencillamente, cierra el fichero asociado a un stream. Operador >>: Igual que sucede con el stream estndar cout, el operador de flujo de salida >> se puede usar con streams de salida cuando trabajemos con texto. Operador <<: Del mismo modo, al igual que sucede con el stream estndar cin, el operador de flujo de entrada << se puede usar con streams de entrada cuando trabajemos con texto. Mtodo de salida put:ostream& put(char ch); Sirve para cualquier stream de salida, e inserta un carcter en el stream. Mtodo de entrada get:int get(); istream& get(char*, int len, char = '\n'); istream& get(char&);

istream& get(streambuf&, char = '\n');La primera forma no se recomienda y se considera obsoleta, lee un carcter desde el stream de entrada. La segunda lee caracteres y los almacena en el buffer indicado en el primer parmetro hasta que se leen "len" caracteres o hasta que se encuentra el carcter indicado en el tercer parmetro, que por defecto es el retorno de lnea. La tercera forma extrae un nico carcter en la referencia a char proporcionada. Mtodo de entrada getline:istream& getline(char*, int, char = '\n'); Extrae caracteres hasta que se encuentra el delimitador y los coloca en el buffer, elimina el delimitador del stream de entrada y no lo aade al buffer. Mtodo eof: int eof(); Verifica si se ha alcanzado el final del fichero, devuelve un valor nulo si no es as. Mtodo clear:void clear(iostate state=0); Cada vez que se produzca una condicin de error en un stream es necesario eliminarla, ya que en caso contrario ninguna operacin que se realice sobre l tendr xisto. Por ejemplo, si llegamos hasta el final de fichero, el stream quedar en estado "eof" hasta que se elimine explcitamente ese estado. Eso se hace mediante el mtodo "clear", sin parmetros dejar el estado en 0, es decir, sin errores. Los estados posibles se definen en un enumerado: enum io_state { goodbit, eofbit, failbit, badbit }; goodbit: indica que el estado es correcto. eofbit: indica que se ha detectado fin de fichero. failbit: indica que una operacin sobre el stream ha fallado. badbit: se activa si falla una operacin de escritura de buffers. Mtodo bad:int bad(); Devuelve el estado del bit "badbit". Mtodo fail:int fail(); Devuelve el estado del bit "failbit".

Mtodo good:int good(); Devuelve el estado del bit "goodbit". Ejemplo: Mostrar dos veces un fichero escrito para C++ usando streams:
// ejemplo1.cpp: Muestra un fichero dos veces. #include <iostream> #include <fstream> using namespace std; int main() { ifstream fichero("ejemplo1.cpp"); char c; while(fichero.get(c)) cout.put(c); fichero.clear(); // (1) fichero.seekg(0); while(fichero.get(c)) cout.put(c); fichero.close(); cin.get(); return 0; }

Mtodo is_open:int is_open(); Devuelve un valor no nulo si el fichero est abierto. Mtodo flush:ostream& flush(); Realiza las operaciones de escritura pendientes que an se han realizado slo en el buffer.

Mtodos relacionados con acceso aleatorio. Disponemos de otro tipo enumerado en ios para indicar movimientos relativos dentro de un stream de acceso aleatorio: enum seek_dir { beg, cur, end}; beg: relativo al principio del fichero. cur: relativo a la posicin actual del cursor dentro del fichero. end: relativo al final del fichero.

Mtodo seekg: Cambia la posicin del cursor en streams de entrada. istream& seekg(streampos pos); istream& seekg(streamoff offset, seek_dir dir); La primera forma es para cambiar la posicin de modo absoluto. La segunda para cambios relativos, en la que se indica el salto en el primer parmetro y el punto de partida en el segundo, que puede ser cualquiera de los indicados anteriormente: ios::beg, ios::cur o ios::end. Mtodo seekp: Cambia la posicin del cursor en streams de salida. ostream& seekp(streampos pos); ostream& seekp(streamoff offset, seek_dir); Lo mismo que seekg, pero aplicado a estream de salida. Mtodo tellg:streampos tellg(); Devuelve la posicin actual del cursor dentro de un stream de entrada. Mtodo tellp:streampos tellp(); Devuelve la posicin actual del cursor dentro de un stream de salida. Mtodo read:istream& read(char*, int); Lee el nmero de caracteres indicado en el segundo parmetro dendro del buffer suministrado por el primero. Mtodo gcount:int gcount(); Devuelve el nmero de caracteres sin formato de la ltima lectura. Las lecturas sin formato son las realizadas mediante las funciones get, getline y read. Mtodo write:ostream& write(const char*, int); Escribe el nmero de caracteres indicado en el segundo parmetro desde el buffer suministrado por el primero.

Ejemplo: Copiar ficheros usando streams.

// copia.cpp: Copia de ficheros // Uso: copia <fichero_origen> <fichero_destino> #include <iostream> #include <fstream> using namespace std; int main(int argc, char **argv) { ifstream entrada; ofstream salida; char buffer[2048]; // Buffer de 2 Kbytes int bytesLeidos; if(argc != 3) { printf("Usar: copia <fichero_origen> <fichero_destino>\n"); return 1; } // Abrir el fichero de entrada en lectura y binario entrada.open(argv[1]); if(!entrada.good()) { printf("El fichero %s no existe o no puede ser abierto.\n", argv[1]); return 1; } // Crear o sobreescribir el fichero de salida en binario salida.open(argv[2]); if(!salida.good()) { printf("El fichero %s no puede ser creado.\n", argv[2]); entrada.close(); return 1; } // Bucle de copia: do { entrada.read(buffer, 2048); bytesLeidos = entrada.gcount(); salida.write(buffer, bytesLeidos); } while(bytesLeidos > 0); // Cerrar ficheros: entrada.close(); salida.close(); return 0; }

Conclusin La utilizacin de ficheros de datos facilita el intercambio de informacin entre programas por lo que puede ser una buena opcin para la entrada y salida de la informacin en nuestras aplicaciones.

Bibliografa

http://www.webtaller.com/manual-java/ficheros.php http://www.webtaller.com/manual-java/streams-entrada.php http://www.webtaller.com/manual-java/streams-salida.php http://www.webtaller.com/manual-java/ficheros-acceso-aleatorio.php http://c.conclase.net/ficheros/?cap=002b