Sie sind auf Seite 1von 11

Universidad Politécnica Salesiana

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

Un archivo o fichero es un conjunto de bits que son almacenados en un dispositivo. Un archivo es


identificado por un nombre y la descripción de la carpeta o directorio que lo contiene. A los archivos
informáticos se les llama así porque son los equivalentes digitales de los archivos escritos en
expedientes, tarjetas, libretas, papel o microfichas del entorno de oficina tradicional. [1]

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() ) {

cout << s << endl;

getline( f, s );

else cerr << "Error de apertura del archivo." << endl;

ii. Archivos de salida

Un archivo de salida de texto se maneja con la clase ofstream:

int main()

ofstream f( "salida.txt" );

if ( f.is_open() ) {

f << "hola " << endl;

f << 5 << endl;

else cerr << "Error de apertura del archivo." << endl;

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

cout << s << endl;

getline( f, s );

cout << atof( s.c_str() ) << endl;

else cerr << "Error de apertura del archivo." << endl;

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.

Así, suponiendo la struct Persona:

const unsigned int MaxNombre = 50;

const unsigned int MaxTelefono = 15;

struct Persona {

char nombre[MaxNombre];

int edad;

char telefono[MaxTelefono];

};

void volcar(ostream & o, const Persona &p)

o << nombre << ':' << edad << endl

<< "Tlf:" << telefono << ':' << endl

Cuando se deseen guardar registros de este tipo en un archivo, se puede hacer de la manera siguiente:
Persona p1;

Persona p2;

strcpy( p1.nombre, "Baltasar" );

strcpy( p1.telefono, "988387028" );

p1.edad = 33;

strcpy( p2.nombre, "Pedro" );

strcpy( p2.telefono, "988387018" );

p1.edad = 33;

ofstream f( "datos.bin", ios::binary );

if ( f.is_open() ) {

f.write( (char *) &p1, sizeof( Persona ) );

f.write( (char *) &p2, sizeof( Persona ) );

} else cout << "Error de apertura de archivo." << endl;

Es posible realizar una lectura de cada registro de la siguiente forma:

Persona p;

ifstream f( "datos.bin", ios::binary );

if ( f.is_open() ) {

f.read( (char *) &p, sizeof( Persona ) );

while( !f.eof() ) {

volcar( cout, p );

f.read( (char *) &p, sizeof( Persona ) );

} else cout << "Error de apertura de archivo." << endl;

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:

f.seekp( 2 * sizeof( Persona ), ios::beg ); // escritura

f.seekg( 2 * sizeof( Persona ), ios::beg ); // lectura

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;

fstream f( "datos.bin", ios::binary | ios::in, ios::out );

// ir al tercer registro y leerlo

f.seekg( 2 * sizeof( Persona ), ios::beg );

f.read( (char *) &p, sizeof( Persona ) );

// cambiar el registro y guardarlo

p.edad = 56;

f.seekp( 2 * sizeof( Persona ), ios::beg );

f.write( (char *) &p, sizeof( Persona ) );

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.

 Para manipular ficheros, siempre tendremos que dar tres pasos:


 Abrir el fichero
 Guardar datos o leer datos
 Cerrar el fichero

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]

i. Lectura y Escritura de Ficheros en Java

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.

1. Lectura de un fichero de texto en java

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:

File archivo = new File ("C:\\archivo.txt");

FileReader fr = new FileReader (archivo);

BufferedReader br = new BufferedReader(fr);

...

String linea = br.readLine();

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 {

public static void main(String [] arg) {

File archivo = null;

FileReader fr = null;

BufferedReader br = null;

try {

// Apertura del fichero y creacion de BufferedReader para poder

// hacer una lectura comoda (disponer del metodo readLine()).

archivo = new File ("C:\\archivo.txt");

fr = new FileReader (archivo);

br = new BufferedReader(fr);

// Lectura del fichero

String linea;

while((linea=br.readLine())!=null)

System.out.println(linea);

catch(Exception e){

e.printStackTrace();

}finally{

// En el finally cerramos el fichero, para asegurarnos

// que se cierra tanto si todo va bien como si salta

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

2. Escritura de un fichero de texto en java

El siguiente código escribe un fichero de texto desde cero. Pone en él 10 líneas

import java.io.*;

public class EscribeFichero

public static void main(String[] args)

FileWriter fichero = null;

PrintWriter pw = null;

try

fichero = new FileWriter("c:/prueba.txt");

pw = new PrintWriter(fichero)

for (int i = 0; i < 10; i++)

pw.println("Linea " + i);

} catch (Exception e) {

e.printStackTrace();

} finally {

try {

// Nuevamente aprovechamos el finally para

// asegurarnos que se cierra el fichero.


if (null != fichero)

fichero.close();

} catch (Exception e2) {

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.

FileWriter fichero = new FileWriter("c:/prueba.txt",true);

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]

El siguiente ejemplo hace una copia binaria de un fichero

package chuidiang.ejemplos;

import java.io.BufferedInputStream;

import java.io.BufferedOutputStream;

import java.io.FileInputStream;

import java.io.FileOutputStream;

public class CopiaFicheros {

public static void main(String[] args) {

copia ("c:/ficheroOrigen.bin", "c:/ficheroDestino.bin");

public static void copia (String ficheroOriginal, String ficheroCopia)

{
try

// Se abre el fichero original para lectura

FileInputStream fileInput = new FileInputStream(ficheroOriginal);

BufferedInputStream bufferedInput = new BufferedInputStream(fileInput);

// Se abre el fichero donde se hará la copia

FileOutputStream fileOutput = new FileOutputStream (ficheroCopia);

BufferedOutputStream bufferedOutput = new


BufferedOutputStream(fileOutput);

// Bucle para leer de un fichero y escribir en el otro.

byte [] array = new byte[1000];

int leidos = bufferedInput.read(array);

while (leidos > 0)

bufferedOutput.write(array,0,leidos);

leidos=bufferedInput.read(array);

// Cierre de los ficheros

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

[1] Wikipedia, "Archivo (informática)," [Online]. Available:


https://es.wikipedia.org/wiki/Archivo_(inform%C3%A1tica). [Accessed 20 Julio 2019].

[2] "Archivos en C++," [Online]. Available:


http://jbgarcia.webs.uvigo.es/asignaturas/TO/cursilloCpp/14_archivos.html. [Accessed 20 Julio
2019].

[3] R. H. J. Martin, "Manejo de Archivos en Java," [Online]. Available:


https://www.academia.edu/29669849/Manejo_de_Archivos_en_Java. [Accessed 20 Julio 2019].

[4] Aprendeaprogramar.com, "Ficheros en Java," [Online]. Available:


http://www.aprendeaprogramar.com/mod/resource/view.php?id=220. [Accessed 20 Julio
2019].

[5] Chuwiki, "Lectura y Escritura de Ficheros en Java," [Online]. Available:


http://chuwiki.chuidiang.org/index.php?title=Lectura_y_Escritura_de_Ficheros_en_Java.
[Accessed 20 Julio 2019].