Streams para archivos o ficheros

Por definición, un archivo es una colección de datos almacenados en algún lugar. En C++, el programador
puede considerar que un archivo es un stream, de tal manera que los objetos vistos en la sección anterior ( cin,
cout, cerr y clog ) son una especie de archivo manipulados por streams. Este punto es de suma importancia, ya
que todo lo que se ha mencionado acerca de los atributos, banderas y manipuladores; que son miembros de los
objetos ( stream ) para entrada y salida estándar, son aplicables a los streams que usemos para trabajar con
archivos en disco y/o cualquier otro dispositivo de almacenamiento. Hasta este momento, solamente se ha
mencionado que los streams poseen banderas y que las mismas pueden alterarse a traves de los manipuladores,
sin embargo, hace falta hablar acerca de los métodos o funciones que son miembros de dichos streams. Así,
antes de ver un ejemplo para mostrar el uso de archivos en disco listaremos una tabla más, o sea, la de los
métodos aplicables a los streams.

Tabla I/O : 05, métodos para objetos istream, ostream y fstream

Función Descripción
bad true si ha ocurrido un error
clear limpia las banderas de estado (status flags)
close cierra un stream
eof true si se alcanzó el fin de archivo
fail true si ha ocurrido un error
fill establecer manipulador de caracter de relleno
flags accesa o manipula las banderas de formato de un stream
flush vaciar el buffer de un stream
gcount número de caracteres leidos durante la última operación de entrada
get lectura de caracteres
getline lectura de una línea de caracteres
good true si no ha ocurrido un error
ignore leer y descartar caracteres
open abrir un stream de entrada y/o salida
peek verifica la siguiente entrada de caracter
precision manipula la precisión del stream
put escritura de caracteres
putback regresar caracteres al stream
rdstate regresa la bandera de estado de stream
read lee datos de un stream hacia un buffer
seekg realiza acceso aleatorio sobre un stream de entrada
seekp realiza acceso aleatorio sobre un stream de salida
setf cambiar las banderas de formato
tellg lee el puntero del stream de entrada
tellp lee el puntero del stream de salida
unsetf limpiar las banderas de formato
width accesa y manipula la longitud minima del campo
write escritura datos desde un buffer hacia un stream

[editar] Abrir y cerrar archivo

A diferencia de los streams para dispositivos estándar, los cuales son creados y abiertos de manera automática,
para trabajar con archivos en discos se debe primeramente "abrir el archivo", y luego de haber terminado de leer
o escribir datos en el mismo, se debe "cerrar el archivo". En C++, en orden de trabajar con archivos en disco,
podemos emplear las clases fstream, ifstream, y ofstream. Si usted desea abrir un archivo específico en modo
de lectura y escritura use un objeto de la clase fstream, por el contrario, si desea abrir un archivo solo para
lectura o solo para escritura use objetos de la clase ifstream y ofstream, respectivamente.

La sintaxis para crear objetos de las tres clase mencionadas es:

'''streams para lectura y escritura'''

fstream();
fstream(const char*, int, int = filebuf::openprot);
fstream(int);
fstream(int _f, char*, int);

'''streams solo para lectura'''

ifstream();
ifstream(const char*, int, int = filebuf::openprot);
ifstream(int);
ifstream(int _f, char*, int);

'''streams solo para escritura'''

ofstream();
ofstream(const char*, int, int = filebuf::openprot);
ofstream(int);
ofstream(int _f, char*, int);

Observe que la sintaxis para crear objetos de las tres clases mostradas arriba es la misma. Es decir,

1. El primer método constructor crea un objeto que no está (aún) asociado a un archivo en disco, en estos
casos, se tendrá que usar el método stream.open("nombre de archivo"); para establecer la conección
entre el stream y el archivo en disco.
2. El segundo método constructor crea un objeto asociado a un archivo en disco, en estos casos, el archivo
en el disco queda abierto y asociado al stream. En este, el parámetro char * apunta a una cadena de
caracteres con el nombre del archivo.
3. El tecer método crea un stream a raiz de un identificador de archivo.
4. El cuarto método crea un stream a raiz de un identificador de archivo, un buffer y tamaño de buffer
específicos.
Para nuestro primer ejemplo usaremos el segundo de los constructores mencionados. Así, el programa que se
muestra en seguida realiza las siguientes tareas:

1. Crea y escribe sobre el archivo de texto test.$$$

2. Abre y lee los datos del archivo test.$$
3. Cierra el archivo test.$$

Para el caso que se presenta se debe prestar atención a los metodos:

1. bad(), para verificar el estado de error del stream

2. get(), para leer caracteres del stream
3. put(), para escribir caracteres en el stream
4. close(), para cerrar el archivo.

// Ejemplo de ifstream y ofstream

// En este programa se demuestra la forma de crear un archivo
// en disco por medio de objeto ofstream, y la manera abrir y
// leer un archivo por medio de un objeto ifstream.

#include <iostream.h>
#include <fstream.h>
#include <string.h>

char *filename = "test.$$$";

char *data = "Esta línea de texto se guardará en el archivo test.$$$";

// crear un archivo en disco cuyo nombre es dado por filename

int crearArchivo(char *filename)
{
ofstream fichero(filename); // crear o rescribir archivo

// verificar la creación del archivo

if ( fichero.bad() ) {
cout << "Error al tratar de abrir archivo";
cin.get();
return 1;
}

// escribir datos al archivo

for (int t = 0; t < strlen(data); t++ )
fichero.put(data[t] );

fichero.close();
cout << "archivo creado exitosamente" << endl;
return 0;
}

// abrir un archivo en disco cuyo nombre es dado por filename

int leerArchivo(char *filename)
{
ifstream fichero(filename); // abrir archivo para lectura

// verificar la apertura del archivo

if ( fichero.bad() ) {
cout << "Error al tratar de abrir archivo";
cin.get();
return 1;
}
 // lectura de datos
while ( ! fichero.eof() ) cout << (char)fichero.get();
fichero.close();
cout << endl << "archivo leido exitosamente" << endl;
return 0;
}

int main()
{
crearArchivo(filename);
leerArchivo(filename);
cout << endl << "Presione <Enter>...";
cin.get();
return 0;
}

Usando operadores de redirección ( <<, >> )

sobre streams asociados con archivos en disco.

No hay que olvidar que si un archivo es asociado a un stream las operaciones de entrada y/o salida para dicho
archivo se hacen a travez del stream y, por lo tanto, se puede usar, no solo los operadores de redirección, sino
tambien todos los metodos, manipuladores y atributos que se ha mencionado hasta este momento. Así, el
objetivo del siguiente programa es demostrar como hacer uso del operador << sobre un archivo asociado a un
stream de salida, y del operador >> sobre un archivo asociado a un stream de entrada. El ejemplo que se
mostrará no es realmente útil, sin embargo cumple con su cometido, es decir, el punto de interes del mismo está
en las líneas de código:

while ( ! fin.eof() ) {
fin >> temp;
fout << temp ;
}

Encargadas de leer datos del archivo de entrada y de escribir los mismos en el archivo de salida.

#include <iostream.h>
#include <fstream.h>

char *filename = "test.$$$";

// abre y lee datos de un archivo en disco cuyo nombre es dado por filename
int leerArchivo(char *filename)
{
ifstream fichero(filename); // abrir archivo para lectura

// verificar la apertura del archivo

if ( fichero.bad() ) {
cout << "Error al tratar de abrir archivo";
cin.get();
return 1;
}

// lectura de datos
 while ( ! fichero.eof() ) cout << (char)fichero.get();
fichero.close();
cout << endl << "archivo leido exitosamente" << endl;
return 0;
}

// crea una copia del archivo test.$$$ hacia test.bak

// Nota: ningun caracter de espaciado en el origen le es tranferido al destino
int backup(char *filename)
{
char newname[80];
int i = 0;

// copia el nombre del archivo original y remplaza la extensión por "BAK".

while (filename[i] != '.' ) newname[i] = filename[i++];
newname[i] = '\0';
strcat(newname, ".BAK");

ifstream fin( filename ); // abrir archivo de entrada

ofstream fout( newname, ios::trunc ); // abrir archivo de salida

char temp;
while ( ! fin.eof() ) {
fin >> temp;
fout << temp ;
}

fin.close();
fout.close();
return 0;
}

int main()
{
backup(filename);
leerArchivo("test.bak");
cout << endl << "Presione <Enter>...";
cin.get();
return 0;
}