Come conservare il valore intero “0” in un file .bin? (C ++)

Question

EDIT: A quanto pare, il problema è nella funzione di lettura: Ho controllato i dati in un editer esadecimale

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

Quindi lo zero viene memorizzata come pari a zero, non solo letto come zero.

Perché quando utilizzo il mio normale funzione di file store-in-bin:

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

Memorizza 0 come la versione char, o "\ 0", che ovviamente non è memorizzato (perché è un valore nullo?) Quindi quando chiamo la mia funzione di leggere il valore zero, legge il valore subito dopo (o subito prima se sarebbe stata l'ultima nel file). Così come posso conservare lo zero in un file .bin correttamente?

EDIT: sono Ecco alcune delle funzioni relative al processo di lettura / scrittura:

//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;
}

Inoltre, l'uscita per l'utilizzo sector::Init è la seguente:

2
1
1

L'output che stavo cercando di scrivere nel cestino era

2
1
0

Quindi, o lo 0 viene letto / scritto come 1, o la sua non è in fase di scrittura e Init sta leggendo l'ultimo valore due volte.

Answer 1

Non è chiaro che cosa si intende per "immagazzinare valore intero 0" in un file. I file contengono byte, non interi. Avete bisogno di memorizzare sizeof (int) 0-byte, o solo un '\ 0' byte?

P.S. Vorrei anche che il problema potrebbe essere nel vostro codice letto. Hai guardato il file .bin in un editor esadecimale?

P.P.S. Il tuo problema è in seekg () uso della funzione. Invece di passare l'offset in byte, si passa pos. Dovrebbe essere pos * sizeof (int), invece.

Answer 2

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

Answer 3

Non sono sicuro di ciò che si vuole fare, a me sembra il codice che hai fornito fa quello che stai chiedendo:

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

Questo si traduce in un file di formato quattro byte che contiene la rappresentazione binaria di un intero pari a zero:

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

Se si desidera memorizzare il numero intero in quanto è rappresentazione ASCII si consiglia di utilizzare l'uscita flusso formattato con <<:

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

In questo modo si ottiene:

$ cat /tmp/tst.out
0

Answer 4

È necessario pensare cosa formattare il file binario deve contenere - qualcosa che non c'è bisogno di fare allo stesso modo con i file di testo, che è il motivo per cui molte volte è utilizzato un file di testo

.

Supponendo una macchina (a 32 bit), dove sizeof (int) == 4 (e CHAR_BITS == 8), allora è possibile memorizzare 4 byte che sono tutti a zero alla posizione del file corrente utilizzando il formato nativo, allora ciò che si' ve ha ottenuto ci dovrebbe lavorare, credo. Si potrebbe sperimentare altri valori come 0x01020304, si vedrà il layout di byte sulla vostra macchina.

Naturalmente, è necessario stare attenti a leggere indietro nel, invertendo la procedura utilizzata per la scrittura. E non dimenticate di riposizionare il file prima di provare a rileggere i dati appena scritti.