39 Trabajar con ficheros

Usar streams facilita mucho el acceso 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 acceso 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.cpp", y que pretendemos que se autoimprima en pantalla:

#include <iostream>
#include <fstream>
using namespace std;

int main() {
   char cadena[128];
   ifstream fe("streams.cpp");

   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);
   
   strcpy(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 acceso 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 acceso 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 acceso 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);
   
   // Acceso secuencial:
   cout << "\nAcceso secuencial:" << endl;
   fentrada.read(cad, 20);
   do {
      cout << cad << endl;
      fentrada.read(cad, 20);
   } while(!fentrada.eof());

   fentrada.clear();
   // Acceso aleatorio:
   cout << "\nAcceso 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 acceso 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) {
   strcpy(nombre, n);
   strcpy(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 acceso 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 acceso 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 de los usuarios (18)

aJ
2011-03-21 19:31:45

Buenas,

En el ejemplo de Ficheros de acceso aleatorio me lanza error copilando con GNU GCC Compliler y Visual C++ 2010, en la siguiente parte :

pos = fentrada.tellg();

Si alguien sabe la solución admin o cualquier otra persona estaré atento a los comentarios.

Saludos.

Steven
2011-03-21 22:48:14

Hola aJ,

Si el compilador te lanza un error, siempre ayuda escribir el mensaje, para los demás.

Hay dos errores y los mensajes lanzados son:

- 'cout' no fue declarado en este ámbito

- 'pos' no fue declarado en este ámbito

Para solucionar el problema de 'cout', incluimos <iostream> al principio:

#include <iostream>

Para 'pos', se nos ha olvidado definirla. Técnicamente, el tipo de dato correcto es 'streampos'. Por lo tanto, escribimos lo siguiente:

streampos pos = fentrada.tellg();

En cuanto podamos, lo corregiremos. Espero haber aclarado la duda.

Steven

aJ
2011-03-22 01:17:45

Gracias otra ves Steven, ya aclare las dudas jejeje.

En esta parte se equivocaron con la tilde de la ú :

cout << "\nNúmero de registros: " << pos/20 << endl;

Aunque no entorpece la funcionalidad del programa, aquí incluyo mi corrección :

cout << "\nN\xa3mero de registros : " << pos/20 << endl;
Juan
2011-05-08 04:29:37

Hola, es que tengo que hacer un programa que me abra cualquier archivo ingresando la direccion y me lo copie en otr direccion ej:

Que el archivo c:\users\juan\pictures\juan.jpeg

lo copie en c:\users\juan\pictures\nueva carpeta\nuevo juan.jpeg que yo ingrese esas direcciones por teclado, el programa copie los archivos pero sin hacer invocaciones del comando copy al sistema.. gracias de antemano si me pueden ayudar.

jose
2011-07-31 15:12:11

todo los ejemplos que estas no se compilan ningunos...

SalvaTúar
2012-06-30 23:30:37

Exelente informe!!!

SalvaTúar
2012-06-30 23:36:13

Compilé todos los ejemplos y si me funsionaron...

El único que no logré compilar fue el ejemplo de: Sobrecarga de operadores << y >>

Me retorna varios errores. Espero de su ayuda!!!

Salvador Pozo
2012-07-01 16:25:17

Hola:

Ya está corregido el ejemplo de sobrecarga del operador <<.

nivram
2012-11-18 17:33:24

Hola acabo de ver todos las sintaxis para guardar datos en un archivo mi duda es cual es la funcion que se utiliza para guardar datos tras datos cada vez q se ejecute el programa como el append en visual basic-

por lo necesito-

Gracias.

Steven R. Davidson
2012-11-18 17:47:47

Hola Nivram,

No hay una función específica para lo que pides, ya que se trata de una escritura, usaremos siempre las mismas funciones de escritura.

Ahora bien, para la funcionalidad o el comportamiento de escribir siempre al final de un fichero, abrimos el fichero con el modo, 'ios::app'. Ahora todas las escrituras se realizarán siempre al final del fichero, ignorando cualesquier movimientos del cursor de posición (o puntero) del fichero para escrituras realizados con 'seekoff()' o 'seekpos()'.

Espero haber aclarado la duda.

Steven

nivram
2012-11-18 18:23:04

Gracias por tu aporte si funciona....

Tengo una segunda consulta, por ejemplo no utilizando la funcion ::app que otro procedimiento se utilizaria para poder reguardar datos.

Por favor----

Steven R. Davidson
2012-11-18 21:19:40

Hola Nivram,

Otra solución sería realizar el desplazamiento del cursor del fichero para escrituras explícitamente. Como he dicho antes, puedes usar 'seekoff()' y además puedes ir directamente al final del fichero con la constante, 'ios::end'. Ahora puedes realizar las escrituras que quieras.

Hasta pronto,

Steven

matt
2013-03-21 21:13:44

como puedo ver los registros guardados:

necesito ingresar codigo de la persona,codigo de producto,cantidad,el valor del producto,ingresar la fecha.

listado de ventas por fecha

struct ventas

{ int cantidad;

char codigo[10],codproducto[15];

float valor;

time_t hora;

};

JCarlos
2013-09-12 10:08:01

Hola.

En el primer ejemplo supusetamente se crea un fichero de texto "nombre.txt", pero lo he buscado en el disco duro y no lo encuentro.¿Es que no lo crea?. Que tengo que hacer para crear un archivo d texto desde c++ y leer su contenido dede windows.

Gracias y un saludo.

JCarlos
2013-09-12 10:34:45

Hola.

Perdon si lo crea pero para ello he tenido que desactivar el antivirus.

Gracias y un saludo

Lucho12344
2013-11-22 21:35:14

quiero saber como crear un programa con ficheros, que al ejecutarlo, si tengo una cadena de caracteres repetidos, los comprima a todos en parentesis, y a la vez, si estan comprimidos, que los descomprima. Tambien tengo que lograr que esto solo ocurra cuando los caracteres se repiten más de cuatro veces.

por ejemplo: Si tengo AAAAA, tiene que salir (A5), pero si tengo AAAA debe permanecer igual

Steven R. Davidson
2013-11-25 17:12:21

Hola Lucho12344,

Necesitas abrir dos ficheros: el primero es la fuente y es de sólo lectura mientras que el segundo es el resultado y es de sólo escritura. La idea es que vayas leyendo los caracteres del primer fichero entrante y vayas escribiendo los caracteres resultantes al segundo fichero saliente. Si no hay repeticiones - esto es, no hay caracteres iguales consecutivos - entonces copias tal cual estos caracteres al fichero saliente. Si hay 5 o más caracteres repetidos consecutivamente, entonces tendrás que contar cuantas repeticiones y seguir el formato indicado por el enunciado, que viene a ser:

(<carácter><cantidad>)

Espero que esto te oriente.

Steven

destr
2013-11-28 02:19:00

hola,

hay alguna forma de cuando uno este leyendo un fichero(.txt) sepa cuando hay que hacer un salto de linea.

ej:

nombre,apellido,rut

nombre,apellido,rut

Entonces cada vez que llega a rut hay que hacer un salto de linea, pero no logro hacerlo, es posible hacerlo??