Cómo almacenar el valor entero “0” en un archivo .bin? (C ++)

Question

Edit: Al parecer, el problema está en la función de lectura: he comprobado los datos en un editer hexagonal

02 00 00 00 01 00 00 00 00 00 00 00

Así que el cero se almacena como cero, simplemente no lee como cero.

Debido a que cuando uso la función de archivo de almacén-en-bin normales:

int a = 0;
file.write(reinterpret_cast<char*>(&a), sizeof(a));

Almacena 0 como la versión char, o "\ 0", que obviamente no se almacena (porque es un valor nulo?) Así que cuando llamo a mi función para leer el valor cero, se lee el valor justo después de que (o justo antes de si sería la última en el archivo). Entonces, ¿cómo puedo almacenar cero en un archivo .bin correctamente?

EDIT: Estas son algunas de las funciones relacionadas con el proceso de lectura / escritura:

//Init program: creates a sector.bin for another program to read from.
#include<fstream>
using namespace std;

int main()
{
    fstream file;
    file.open("sector.bin", ios::out | ios::binary);
    if(!file.is_open())
    {
        file.open("sector.bin", ios::out | ios::binary);
        file.close();
        file.open("sector.bin", ios::out | ios::binary);
        if(!file.is_open())
        {
            return -1;
        }
    }
    file.seekp(file.beg);
    int a = 2;
    int b = 1;
    int c = 0;
    file.write(reinterpret_cast<char*>(&a), sizeof(a));
    file.write(reinterpret_cast<char*>(&b), sizeof(b));
    file.write(reinterpret_cast<char*>(&c), sizeof(c));
    file.close();
    return 0;
}

//Read function:  part of another program that intializes variables based off
//of sector.bin
void sector::Init(std::fstream& file)
{
    int top_i = FileRead(file,0);
    std::cout<<top_i<<std::endl;
    for(int i = 0; i < top_i; i++)
    {
        accessLV[i] = FileRead(file,i+1);
        std::cout<<accessLV[i]<<std::endl;
    }
    std::cin.ignore();
    viral_data.add(new X1(5,5,'X'));
    viral_data.add(new X1(9,9,'X'));
    player.set(0,0,'O');
    return;
}
//the FileRead used in init
int FileRead(std::fstream& file, int pos)
{
    int data;
    file.seekg(file.beg + pos);
    file.read(reinterpret_cast<char*>(&data), sizeof(data));
    return data;
}

Además, la salida para el uso de sector::Init es como sigue:

2
1
1

El ouput que yo estaba tratando de escribir en el cubo era

2
1
0

Así que, o se está leyendo el 0 / escrito como 1, o su no siendo escrita y Init está leyendo el último valor dos veces.

Answer 1

No está claro lo que quiere usted decir con "valor entero 0 almacenamiento" en un archivo. Los archivos contienen bytes, no enteros. ¿Es necesario almacenar sizeof (int) 0-bytes, o un solo '0 \' byte?

P.S. También pensaría que el problema podría estar en su código de lectura. ¿Has mirado en su archivo .bin en un editor hexadecimal?

P.P.S. Su problema está en seekg uso de la función (). En lugar de pasar el desplazamiento en bytes, se pasa pos. Debe ser pos * sizeof (int) en su lugar.

Answer 2

int num = 0;
write( fd, &num, sizeof( int ));

Answer 3

No estoy seguro de lo que quiere hacer, me parece que el código que ya ha proporcionado hace lo que está pidiendo:

int main() {
   std::ofstream file("/tmp/tst.out");
   int a = 0;
   file.write(reinterpret_cast<char*>(&a), sizeof(a));
   return 0;
}

Esto resulta en un archivo de tamaño cuatro bytes que contiene la representación binaria de un número entero de cero:

$ hexdump /tmp/tst.out
0000000 0000 0000
0000004

Si desea almacenar el número entero, ya que es la representación ASCII se debe utilizar salida de flujo de formateado con <<:

std::ofstream file("/tmp/tst.out");
int a = 0;
file << a << std::endl;

De esta manera se obtiene:

$ cat /tmp/tst.out
0

Answer 4

Es necesario pensar en lo que formatear el archivo binario debe contener - algo que no tiene que hacer de la misma manera con archivos de texto, por lo que muchos veces se utiliza un archivo de texto

.

Si se asume una máquina (32 bits), donde sizeof (int) == 4 (y CHAR_BITS == 8), entonces se puede almacenar 4 bytes que son todos cero en la ubicación del archivo actual utilizando el formato nativo, entonces lo que' hemos conseguido que debería trabajar, creo. Usted podría experimentar con otros valores como 0x01020304, verá el diseño de bytes en su máquina.

Por supuesto, hay que tener cuidado de leerlo de nuevo, invirtiendo el procedimiento utilizado para la escritura. Y no se olvide de volver a colocar el archivo antes de intentar volver a leer los datos que acaba de escribirse.