C/Visual C - sobre seekg y seekp.

 
Vista:

sobre seekg y seekp.

Publicado por Oliver++ (339 intervenciones) el 27/09/2002 01:54:12
porque las funciones miembro de fstream write y read me aumentan cada una ambos punteros del archivo, osea el put y el get.
ej.
flujo.write ( (char*) &objeto, sizeof (objeto) );
si ambos punteros apuntaban al inicio del archivo al ejecutar esta instruccion ambos punteros avanzan, lo logico es que solo avance el putero put. Lo mismo sucede con read.

cual es la razon por la cual esto es asi?
Valora esta pregunta
Me gusta: Está pregunta es útil y esta claraNo me gusta: Está pregunta no esta clara o no es útil
0
Responder
Imágen de perfil de Alejandro

Comportamiento de punteros en `fstream` al usar `write` y `read`**

Publicado por Alejandro (913 intervenciones) el 24/03/2025 18:11:21
Oliver++, la razón por la cual tanto el puntero de escritura (put) como el puntero de lectura (get) avanzan al usar las funciones `write` y `read` en un objeto `fstream` en C++ se debe a la forma en que está diseñado el manejo de flujos en C++.

Cuando utilizas un objeto `fstream`, este combina las capacidades de entrada y salida, lo que significa que puede leer y escribir en el mismo archivo. Sin embargo, los punteros de lectura y escritura están interconectados. Esto significa que las operaciones de lectura y escritura afectan a ambos punteros.

Explicación detallada:



1. Interconexión de punteros: En un objeto `fstream`, el puntero de lectura (`get`) y el puntero de escritura (`put`) están interrelacionados. Cuando realizas una operación de escritura, el puntero de escritura avanza automáticamente, pero también se actualiza el puntero de lectura para reflejar la nueva posición en el archivo. Esto se hace para mantener la coherencia del flujo de datos.

2. Efecto de las operaciones: Cuando llamas a `flujo.write((char*)&objeto, sizeof(objeto));`, el puntero de escritura se mueve hacia adelante por el tamaño del objeto que estás escribiendo. Sin embargo, el puntero de lectura también se mueve, ya que el flujo necesita saber dónde está la próxima lectura válida. Esto puede llevar a confusiones si no se gestiona adecuadamente.

3. Uso de `seekg` y `seekp`: Para manejar esta situación, puedes utilizar las funciones `seekg()` y `seekp()` para reposicionar los punteros de lectura y escritura según sea necesario. Por ejemplo, si deseas leer desde el inicio del archivo después de haber escrito, deberías usar `flujo.seekg(0);` para mover el puntero de lectura de vuelta al inicio.

Ejemplo:



1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
#include <fstream>
 
struct MiObjeto {
    int id;
    char nombre[20];
};
 
int main() {
    std::fstream flujo("archivo.dat", std::ios::in | std::ios::out | std::ios::binary);
 
    MiObjeto objeto = {1, "Ejemplo"};
 
    // Escribir el objeto
    flujo.write((char*)&objeto, sizeof(objeto));
 
    // Aquí, tanto el puntero de lectura como el de escritura han avanzado.
 
    // Para leer desde el inicio, reposicionamos el puntero de lectura
    flujo.seekg(0);
 
    MiObjeto objetoLeido;
    flujo.read((char*)&objetoLeido, sizeof(objetoLeido));
 
    return 0;
}

Conclusión:



La interconexión de los punteros de lectura y escritura en `fstream` es una característica del diseño de C++ para facilitar el manejo de archivos. Sin embargo, es importante ser consciente de este comportamiento y utilizar `seekg` y `seekp` para controlar la posición de los punteros según sea necesario.
Valora esta respuesta
Me gusta: Está respuesta es útil y esta claraNo me gusta: Está respuesta no esta clara o no es útil
0
Comentar