Duda con fstream y familia.

[vangodp]

Hola compañeros.
Me siento derrotado por los puñeteros streams de C++, no se que me pasa hoy.
Pido ayuda por que ya no lo entiendo nada de lo que pasa. La teoría creo que la se correctamente, pero en la practica no me funciona, o eso creo.

A ver por donde empiezo....

primero diré lo que quiero hacer y diré lo que sé o creo que sé.

Tengo una estructura llamada paciente con 4 datos, int id, char nombre[30], char apellidos[30], int edad.

Quiero poner en un fichero BINARIO un contador tipo entero al principio del fichero para que me marque la cantidad de pacientes que hay en dicho fichero. Luego se van ingrasando pacientes con la funcion write, para eso uso un fstream fichero, el problema es que tengo que escribir y leer varias veces y pretendía usar un solo puntero de entrada y salida.

Después de comer toda la red para saber que es lo que pasa con el código que os pongo a continuación, me siento vencido por los puñeteros streams.

La tarea consiste en abrir el fichero, si no existe y crearlo y poner en el el contador inicializado a cero ya que aun no hay clientes, a cada cliente que vaya añadiendo tengo que volver al principio y incrementar ese contador, pero por alguna razón no me funciona no se que hago mal.

He leído muchos lugares sobre las funciones seekg/seekp, los modos de apertura:
ios: trunc(sobrescribe), app(agrega al final), ate(posiciona al final y permite escribir en cualquier parte del fichero), in(lectura), out(escriptura)...

¿Alguien puede echarme un cable y contestar algunas preguntas al final?
Dejo mi porqueria código al que le incluyo 2 clientes y intento incrementar el contador.

Código C++:

#include <iostream>
#include <fstream> 
#include <cstring>
 
using namespace std;
const int TAM_CADENA = 30;
 
typedef char cadena[TAM_CADENA];
struct paciente {
    int id;
    cadena nombre;
    cadena apellidos;
    int edad;
};
 
int main () {
    //abro para escriptura, creo que deberia ser una combinacion de out/binary/ate pero ya probe de todo ni se que hago más.
    std::fstream f ( "w.dat",   std::ifstream::binary | std::ifstream::out | std::ifstream::app );
    paciente p = { 222, "jose", "perez", 46 };
    
    //n será el contador que va al principio del fichero binario
    int n = 0;
    //Supuesta mente situo al principio y envio el contador al inicio del fichero con un valor de cero.
    f.seekp(0, f.beg);
    f.write( reinterpret_cast< char* >( &n )       , sizeof (int ) );
    
    //grabo la estructura p al fichero. Se supone que va a continuacion del contador. :S
    f.write( reinterpret_cast< char* >( &p.id ), sizeof (int ) );
    f.write( reinterpret_cast< char* >( &p.nombre ), ( sizeof (char)*30 ) );
    f.write( reinterpret_cast< char* >( &p.apellidos ), ( sizeof (char)*30 ) );
    f.write( reinterpret_cast< char* >( &p.edad ) , sizeof (int ) );
    
    //vuelvo al principio y incremento el contador
    f.seekp(0, f.beg);
    n++;
    f.write( reinterpret_cast< char* >( &n ), sizeof (int ) );        
    //cierro el fichero, para despues aprovecharlo para leer por ejemplo. Algunos piensan que seria más facil abrirlo en lectura y escriptura pero no puedo, debo reaprovecharlo =(
    f.close();
    
    //volvemos a repetir el proceso con otro paciente
    f.open ( "w.dat",   std::ifstream::binary | std::ifstream::out  | std::ifstream::app );
    
    f.seekp(0, f.end);
    p.id = 22334;
    strcpy( p.nombre, "miguel");
    strcpy( p.nombre, "miguel");
    p.edad = 64;
    
    f.write( reinterpret_cast< char* >( &p.id )       , sizeof (int ) );
    f.write( reinterpret_cast< char* >( &p.nombre )   , ( sizeof (char)*30 ) );
    f.write( reinterpret_cast< char* >( &p.apellidos ), ( sizeof (char)*30 ) );
    f.write( reinterpret_cast< char* >( &p.edad )     , sizeof (int ) );    
    
    f.seekp(0, f.beg);
    n = 2;
    f.write( reinterpret_cast< char* >( &n )       , sizeof (int ) );     
    f.close();
    
    return 0;
}
 

Si pueden arreglarmelo para que lo entienda os estaría muy grato.

Y si pueden aclararme algunos puntos entonces

¿Funciona igual seekg que seekp? Se que g es get y p es put. Si he entendido bien seekp se usa para posicionar para escritura y seekg para lectura.
Uno ley que trabaja de forma parecida a fseek de C, el otro es recibe no se que la de fpos que se supone que es un long. pfff

¿Pueden explicarme como funciona seekp y seekg para dumies? =)

¿me pueden explicar las combinaciones de modos de apertura?

¿Se puede reaprovechar un objeto fstream para abrirlo en un modo diferente? Hay que llamar el destructor o como se hace?

ppfff por mi quedaria todo el dia preguntando. Encontré buenos tutoriales de explicacion, pero no se que pasa, creo que falla al tratar de intentar reaprovechar el objecto pero no se por que pasa eso. pfff

Gracias chicos, intento no molestar pero es que así son los noobs, y es que eso me tiene alquilado todo el finde. No se por que me parece mucho mejor la forma de gestionar ficheros con C que con C++, me quede con mal sabor de boca con los streams.

Suerte

PD: No puedo usar un fichero para ambas cosas Entrada/salida lo que quiero es aprovechar el fstream fichero para abrirlo en diferentes modos.

[lareto]

Con las citas del estándar C++:

app -> seek to end before each write

Va a posicionar el cursor al final del archivo antes de cada escritura.
En tu caso, por ejemplo, no importa a dónde quieras posicionar el cursor antes de escribir (con f.seekp(0, f.beg);) porque de todos modos, todos y cada uno de los bytes que quieran escribirse, van a ir al final del archivo.

ate -> open and seek to end immediately after opening

Inmediatamente después de la apertura va a posicionar el cursor al final del archivo, pero a diferencia del modo app es posible escribir en cualquier posición.

Puedes usar dos modos para open, dependiendo de si el archivo existe o no. Al abrir un archivo existente, si no quieres destruir su contendido deberás abrirlo en modo in|out. Por otro lado, si el archivo no existe, al abrirlo con out crearás uno nuevo.

[vangodp]

Gracias lareto.
Hoy por enesima vez voy a ver si puedo buscar un mecanismo para eso.

[lareto]

Hola; la idea sería fijarse primero si el archivo existe. Si no existiera abrirlo (creándolo) con binary | out; mientras que si ya existiera, abrirlo con binary|in|out

[vangodp]

Ok.. Voy a probarlo y ya te comento.

Desde luego me esta fallando la lógica.

Hasta pronto.