Ficheros Texto Binarios
Ficheros Texto Binarios
Ficheros Texto Binarios
Grupo: 2
Materia: Programación
Objetivo General
Conocer sobre los tipos de archivos binarios y los archivos de texto, existentes en los lenguajes C++ y
en JAVA.
Objetivos Específicos
Establecer como se puede realizar el uso de archivos de texto, con distintos operadores
presentes en la consola en el lenguaje C++, tanto como en JAVA.
Reconocer las diferencias entre los archivos de texto y los archivos binarios que se pueden
usar en los leguajes de programación C++ y JAVA.
Argumento
Archivos
1. Archivos en C++
Los archivos o ficheros son la forma en la que C++ permite el acceso al disco.
Todos los procesos tienen abiertos, por defecto, los archivos 0(entrada), 1(salida) y 2(salida de
errores), de manera que en C++ se corresponden con los objetos cin, cout y cerr. De estos
últimos, el primero pertenece a la clase ifstream, que a su vez desciende de istream (flujo de
entrada). Los dos últimos pertenecen a la clase ofstream, que desciende de la clase ostream
(flujo de salida).
Lo bueno es que es posible manejar los flujos de la misma manera que se manejan cout y cin, es
decir, con los operadores de inserción y de extracción.
a. Archivos de texto
Los archivos de texto son los más sencillos de manejar, pues, como ya se ha mencionado,
para trabajar con ellos se emplean los operadores de inserción y extracción que ya se
conocen de la consola.
i. Archivos de entrada
El típico recorrido de un archivo de texto desconocido (al igual que uno binario),
se hace con lectura adelantada. Así, si en el directorio donde se ejecuta la
aplicación hay un archivo llamado entrada.txt, se puede volcar por pantalla de
la siguiente forma, utilizando la clase ifstream:
int main()
{
string s;
ifstream f( "salida.txt" );
if ( f.is_open() ) {
getline( f, s );
while( !f.eof() ) {
getline( f, s );
int main()
ofstream f( "salida.txt" );
if ( f.is_open() ) {
Para leer y volcar por pantalla este archivo que acabamos de generar, se haría lo siguiente:
int main()
string s;
ifstream f( "salida.txt" );
if ( f.is_open() ) {
getline( f, s );
getline( f, s );
b. Archivos binarios
Los archivos binarios se tratan con la clase fstream. En este caso, debemos especificar si
se desea entrada y salida, o sólo entrada o sólo salida. Uno de los usos más típicos es
utilizar el archivo como una pequeña base de datos, utilizando un registro (struct) como
referencia. Recordemos que los registros deben tener todo el mismo tamaño.
struct Persona {
char nombre[MaxNombre];
int edad;
char telefono[MaxTelefono];
};
Cuando se deseen guardar registros de este tipo en un archivo, se puede hacer de la manera siguiente:
Persona p1;
Persona p2;
p1.edad = 33;
p1.edad = 33;
if ( f.is_open() ) {
Persona p;
if ( f.is_open() ) {
while( !f.eof() ) {
volcar( cout, p );
Entrada y salida
Además, los archivos binarios permiten el posicionamiento, tanto del puntero de lectura (el lugar de
dónde se va a leer) como el de escritura (el lugar del archivo donde se va a escribir). Estos punteros
sólo entienden de una posición en bytes en el archivo, y no de registros. [2]
Siendo prácticos, para avanzar al registro n, será necesario emplear la fórmula: (n-1) * sizeof(Persona
). Así, para el tercer registro:
Es posible saber en qué punto del archivo se encuentra uno de los punteros mediante los métodos:
f.tellg();
f.tellp();
Así, para abrir un archivo como de lectura y escritura, se debe utilizar la clase fstream, y posicionarse
mediante el acceso directo para leer y escribir cuando sea preciso.
Persona p;
p.edad = 56;
2. Ficheros en JAVA
Para realizar operaciones sobre los ficheros necesitamos contar con la información referente sobre un
fichero (archivo). La clase File proporciona muchas utilidades relacionadas con ficheros y con la
obtención de información b5sica sobre esos ficheros. [3]
a. Escribir en un fichero de texto
Un primer tipo de ficheros, que resulta sencillo de manejar, son los ficheros de texto. Son
ficheros que podremos crear desde un programa en Java y leer con cualquier editor de
textos, o bien crear con un editor de textos y leer desde un programa en Java, o bien usar
un programa tanto para leer como para escribir.
Hay que recordar siempre esos tres pasos: si no guardamos o leemos datos, no hemos
hecho nada útil; si no abrimos fichero, obtendremos un mensaje de error al intentar
acceder a su contenido; si no cerramos el fichero (un error frecuente), puede que
realmente no se llegue a guardar ningún dato, porque no se vacíe el "buffer" (la memoria
intermedia en que se quedan los datos preparados hasta el momento de volcarlos a
disco). [4]
Veamos cómo leer y escribir ficheros de texto y binarios en java. También como acceder
a dichos ficheros a través de los Buffer de java y alguna cosilla más.
Podemos abrir un fichero de texto para leer usando la clase FileReader. Esta clase tiene
métodos que nos permiten leer caracteres. Sin embargo, suele ser habitual querer las
líneas completas, bien porque nos interesa la línea completa, bien para poder analizarla
luego y extraer campos de ella. FileReader no contiene métodos que nos permitan leer
líneas completas, pero sí BufferedReader. Afortunadamente, podemos construir un
BufferedReader a partir del FileReader de la siguiente forma:
...
La apertura del fichero y su posterior lectura pueden lanzar excepciones que debemos capturar. Por
ello, la apertura del fichero y la lectura debe meterse en un bloque try-catch.
Además, el fichero hay que cerrarlo cuando terminemos con él, tanto si todo ha ido bien como si ha
habido algún error en la lectura después de haberlo abierto. Por ello, se suele poner al try-catch un
bloque finally y dentro de él, el close() del fichero.
El siguiente es un código completo con todo lo mencionado.
import java.io.*;
class LeeFichero {
FileReader fr = null;
BufferedReader br = null;
try {
br = new BufferedReader(fr);
String linea;
while((linea=br.readLine())!=null)
System.out.println(linea);
catch(Exception e){
e.printStackTrace();
}finally{
// una excepcion.
try{
if( null != fr ){
fr.close();
}
}catch (Exception e2){
e2.printStackTrace();
Como opción para leer un fichero de texto línea por línea, podría usarse la clase Scanner en vez de el
FileReader y el BufferedReader.
import java.io.*;
PrintWriter pw = null;
try
pw = new PrintWriter(fichero)
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
fichero.close();
e2.printStackTrace();
Si se quiere añadir al final de un fichero ya existente, simplemente debemos poner un flag a true como
segundo parámetro del constructor de FileWriter.
b. Ficheros binarios
Para ficheros binarios se hace exactamente igual, pero en vez de usar los "Reader" y los
"Writer", se usan los "InputStream" y los "OutputStream". En lugar de los readLine() y
println(), hay que usar los métodos read() y write() de array de bytes. [4]
package chuidiang.ejemplos;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
{
try
bufferedOutput.write(array,0,leidos);
leidos=bufferedInput.read(array);
bufferedInput.close();
bufferedOutput.close();
catch (Exception e)
e.printStackTrace();
Conclusiones
Se logro conocer como se debe realizar el uso de ficheros de texto y binarios en los lenguajes
C++ y JAVA, gracias al uso de ejemplos para su posterior utilización.
Se pudo establecer ciertas diferencias entre los ficheros de texto y los binarios, en donde los
archivos de texto tienen una mayor facilidad de uso y de modificación, a diferencia de los
archivos binarios, en donde su modificación, si no se realiza desde el propio compilador, y por
el uso de caracteres alfanuméricos, se puede generar que estos ficheros se vean corrompidos.
Bibliografía