0
Trabajar con ficheros
Usar streams facilita mucho el a ficheros en disco, veremos que una vez que creemos un stream para un fichero, podremos trabajar con él igual que lo hacemos con cin o cout.
Mediante las clases ofstream, ifstream y fstream tendremos a todas las funciones de las clases base de las que se derivan estas: ios, istream, ostream, fstreambase, y como también contienen un objeto filebuf, podremos acceder a las funciones de filebuf y streambuf.
En apendice E hay una referencia bastante completa de las clases estándar de entrada y salida.
Evidentemente, muchas de estas funciones puede que nunca nos sean de utilidad, pero algunas de ellas se usan con frecuencia, y facilitan mucho el trabajo con ficheros.
Crear un fichero de salida, abrir un fichero de entrada
Empezaremos con algo sencillo. Vamos a crear un fichero mediante un objeto de la clase ofstream, y posteriormente lo leeremos mediante un objeto de la clase ifstream:
|
#include <iostream>
#include <fstream>
using namespace std;
int main() {
char cadena[128];
// Crea un fichero de salida
ofstream fs("nombre.txt");
// Enviamos una cadena al fichero de salida:
fs << "Hola, mundo" << endl;
// Cerrar el fichero,
// para luego poder abrirlo para lectura:
fs.close();
// Abre un fichero de entrada
ifstream fe("nombre.txt");
// Leeremos mediante getline, si lo hiciéramos
// mediante el operador << sólo leeríamos
// parte de la cadena:
fe.getline(cadena, 128);
cout << cadena << endl;
return 0;
} |
Este sencillo ejemplo crea un fichero de texto y después visualiza su contenido en pantalla.
Veamos otro ejemplo sencillo, para ilustrar algunas limitaciones del operador >> para hacer lecturas, cuando no queremos perder caracteres.
Supongamos que llamamos a este programa "streams.p", y que pretendemos que se autoimprima en pantalla:
|
#include <iostream>
#include <fstream>
using namespace std;
int main() {
char cadena[128];
ifstream fe("streams.p");
while(!fe.eof()) {
fe >> cadena;
cout << cadena << endl;
}
fe.close();
return 0;
} |
El resultado quizá no sea el esperado. El motivo es que el operador >> interpreta los espacios, tabuladores y retornos de línea como separadores, y los elimina de la cadena de entrada.
Ficheros binarios
Muchos sistemas operativos distinguen entre ficheros de texto y ficheros binarios. Por ejemplo, en MS-DOS, los ficheros de texto sólo permiten almacenar caracteres.
En otros sistemas no existe tal distinción, todos los ficheros son binarios. En esencia esto es más correcto, puesto que un fichero de texto es un fichero binario con un rango limitado para los valores que puede almacenar.
En general, usaremos ficheros de texto para almacenar información que pueda o deba ser manipulada con un editor de texto. Un ejemplo es un fichero fuente C++. Los ficheros binarios son más útiles para guardar información cuyos valores no estén limitados. Por ejemplo, para almacenar imágenes, o bases de datos. Un fichero binario permite almacenar estructuras completas, en las que se mezclen datos de cadenas con datos numéricos.
En realidad no hay nada que nos impida almacenar cualquier valor en un fichero de texto, el problema surge cuando se almacena el valor que el sistema operativo usa para marcar el fin de fichero en un archivo de texto. En MS-DOS ese valor es 0x1A. Si abrimos un fichero en modo de texto que contenga un dato con ese valor, no nos será posible leer ningún dato a partir de esa posición. Si lo abrimos en modo binario, ese problema no existirá.
Los ficheros que hemos usado en los ejemplos anteriores son en modo texto, veremos ahora un ejemplo en modo binario:
|
#include <iostream>
#include <fstream>
#include <cstring>
using namespace std;
struct tipoRegistro {
char nombre[32];
int edad;
float altura;
};
int main() {
tipoRegistro pepe;
tipoRegistro pepe2;
ofstream fsalida("prueba.dat",
ios::out | ios::binary);
stry(pepe.nombre, "Jose Luis");
pepe.edad = 32;
pepe.altura = 1.78;
fsalida.write(reinterpret_cast<char *>(&pepe),
sizeof(tipoRegistro));
fsalida.close();
ifstream fentrada("prueba.dat",
ios::in | ios::binary);
fentrada.read(reinterpret_cast<char *>(&pepe2),
sizeof(tipoRegistro));
cout << pepe2.nombre << endl;
cout << pepe2.edad << endl;
cout << pepe2.altura << endl;
fentrada.close();
return 0;
} |
Al declarar streams de las clases ofstream o ifstream y abrirlos en modo binario, tenemos que añadir el valor ios::out e ios::in, respectivamente, al valor ios::binary. Esto es necesario porque los valores por defecto para el modo son ios::out e ios:in, también respectivamente, pero al añadir el flag ios::binary, el valor por defecto no se tiene en cuenta.
Cuando trabajemos con streams binarios usaremos las funciones write y read. En este caso nos permiten escribir y leer estructuras completas.
En general, cuando usemos estas funciones necesitaremos hacer un casting, es recomendable usar el operador reinterpret_cast.
Ficheros de aleatorio
Hasta ahora sólo hemos trabajado con los ficheros secuencialmente, es decir, empezamos a leer o a escribir desde el principio, y avanzamos a medida que leemos o escribimos en ellos.
Otra característica importante de los ficheros es la posibilidad de trabajar con ellos haciendo aleatorio, es decir, poder hacer lecturas o escrituras en cualquier punto del fichero. Para eso disponemos de las funciones seekp y seekg, que permiten cambiar la posición del fichero en la que se hará la siguiente escritura o lectura. La 'p' es de put y la 'g' de get, es decir escritura y lectura, respectivamente.
Otro par de funciones relacionadas con el aleatorio son tellp y tellg, que sirven para saber en qué posición del fichero nos encontramos.
|
#include <fstream>
using namespace std;
int main() {
int i;
char mes[][20] = {"Enero", "Febrero", "Marzo",
"Abril", "Mayo", "Junio", "Julio", "Agosto",
"Septiembre", "Octubre", "Noviembre",
"Diciembre"};
char cad[20];
ofstream fsalida("meses.dat",
ios::out | ios::binary);
// Crear fichero con los nombres de los meses:
cout << "Crear archivo de nombres de meses:" << endl;
for(i = 0; i < 12; i++)
fsalida.write(mes[i], 20);
fsalida.close();
ifstream fentrada("meses.dat", ios::in | ios::binary);
// secuencial:
cout << "n secuencial:" << endl;
fentrada.read(cad, 20);
do {
cout << cad << endl;
fentrada.read(cad, 20);
} while(!fentrada.eof());
fentrada.clear();
// aleatorio:
cout << "n aleatorio:" << endl;
for(i = 11; i >= 0; i--) {
fentrada.seekg(20*i, ios::beg);
fentrada.read(cad, 20);
cout << cad << endl;
}
// Calcular el número de elementos
// almacenados en un fichero:
// ir al final del fichero
fentrada.seekg(0, ios::end);
// leer la posición actual
pos = fentrada.tellg();
// El número de registros es el tamaño en
// bytes dividido entre el tamaño del registro:
cout << "nNúmero de registros: " << pos/20 << endl;
fentrada.close();
return 0;
} |
La función seekg nos permite acceder a cualquier punto del fichero, no tiene por qué ser exactamente al principio de un registro, la resolución de la funciones seek es de un byte.
Cuando trabajemos con nuestros propios streams para nuestras clases, derivándolas de ifstream, ofstream o fstream, es posible que nos convenga sobrecargar las funciones seek y tell para que trabajen a nivel de registro, en lugar de hacerlo a nivel de byte.
La función seekp nos permite sobrescribir o modificar registros en un fichero de aleatorio de salida. La función tellp es análoga a tellg, pero para ficheros de salida.
Ficheros de entrada y salida
Ahora veremos cómo podemos trabajar con un stream simultáneamente en entrada y salida.
Para eso usaremos la clase fstream, que al ser derivada de ifstream y ofstream, dispone de todas las funciones necesarias para realizar cualquier operación de entrada o salida.
Hay que tener la precaución de usar la opción ios::trunc de modo que el fichero sea creado si no existe previamente.
|
#include <fstream>
using namespace std;
int main() {
char l;
long i, lon;
fstream fich("prueba.dat", ios::in |
ios::out | ios::trunc | ios::binary);
fich << "abracadabra" << flush;
fich.seekg(0L, ios::end);
lon = fich.tellg();
for(i = 0L; i < lon; i++) {
fich.seekg(i, ios::beg);
fich.get(l);
if(l == 'a') {
fich.seekp(i, ios::beg);
fich << 'e';
}
}
cout << "Salida:" << endl;
fich.seekg(0L, ios::beg);
for(i = 0L; i < lon; i++) {
fich.get(l);
cout << l;
}
cout << endl;
fich.close();
return 0;
} |
Este programa crea un fichero con una palabra, a continuación lee todo el fichero e cambia todos los caracteres 'a' por 'e'. Finalmente muestra el resultado.
Básicamente muestra cómo trabajar con ficheros simultáneamente en entrada y salida.
Sobrecarga de operadores << y >>
Una de las principales ventajas de trabajar con streams es que nos permiten sobrecargar los operadores << y >> para realizar salidas y entradas de nuestros propios tipos de datos.
Por ejemplo, tenemos una clase:
|
#include <iostream>
#include <cstring>
using namespace std;
class Registro {
public:
Registro(char *, int, char *);
const char* LeeNombre() const {return nombre;}
int LeeEdad() const {return edad;}
const char* LeeTelefono() const {return telefono;}
private:
char nombre[64];
int edad;
char telefono[10];
};
Registro::Registro(char *n, int e, char *t) : edad(e) {
stry(nombre, n);
stry(telefono, t);
}
ostream& operator<<(ostream &os, Registro& reg) {
os << "Nombre: " << reg.LeeNombre() << "nEdad: " <<
reg.LeeEdad() << "nTelefono: " << reg.LeeTelefono();
return os;
}
int main() {
Registro Pepe((char*)"José", 32, (char*)"61545552");
cout << Pepe << endl;
return 0;
}
|
Comprobar estado de un stream
Hay varios flags de estado que podemos usar para comprobar el estado en que se encuentra un stream.
Concretamente nos puede interesar si hemos alcanzado el fin de fichero, o si el stream con el que estamos trabajando está en un estado de error.
La función principal para esto es good(), de la clase ios.
Después de ciertas operaciones con streams, a menudo no es mala idea comprobar el estado en que ha quedado el stream. Hay que tener en cuenta que ciertos estados de error impiden que se puedan seguir realizando operaciones de entrada y salida.
Otras funciones útiles son fail(), eof(), bad(), rdstate() o clear().
En el ejemplo de archivos de aleatorio hemos usado clear() para eliminar el bit de estado eofbit del fichero de entrada, si no hacemos eso, las siguientes operaciones de lectura fallarían.
Otra condición que conviene verificar es la existencia de un fichero. En los ejemplos anteriores no ha sido necesario, aunque hubiera sido conveniente, verificar la existencia, ya que el propio ejemplo crea el fichero que después lee.
Cuando vayamos a leer un fichero que no podamos estar seguros de que existe, o que aunque exista pueda estar abierto por otro programa, debemos asegurarnos de que nuestro programa tiene al stream. Por ejemplo:
|
#include <fstream>
using namespace std;
int main() {
char mes[20];
ifstream fich("meses1.dat", ios::in | ios::binary);
// El fichero meses1.dat no existe, este programa es
// una prueba de los bits de estado.
if(fich.good()) {
fich.read(mes, 20);
cout << mes << endl;
}
else {
cout << "Fichero no disponible" << endl;
if(fich.fail()) cout << "Bit fail activo" << endl;
if(fich.eof()) cout << "Bit eof activo" << endl;
if(fich.bad()) cout << "Bit bad activo" << endl;
}
fich.close();
return 0;
} |
Ejemplo de fichero previamente abierto:
|
#include <fstream>
using namespace std;
int main() {
char mes[20];
ofstream fich1("meses.dat", ios::out | ios::binary);
ifstream fich("meses.dat", ios::in | ios::binary);
// El fichero meses.dat existe, pero este programa
// intenta abrir dos streams al mismo fichero, uno en
// escritura y otro en lectura. Eso no es posible, se
// trata de una prueba de los bits de estado.
fich.read(mes, 20);
if(fich.good())
cout << mes << endl;
else {
cout << "Error al leer de Fichero" << endl;
if(fich.fail()) cout << "Bit fail activo" << endl;
if(fich.eof()) cout << "Bit eof activo" << endl;
if(fich.bad()) cout << "Bit bad activo" << endl;
}
fich.close();
fich1.close();
return 0;
} |
Comentarios