Comment conserver la valeur entière « 0 » dans un fichier .bin? (C ++)

Question

EDIT: Apparemment, le problème est dans la fonction de lecture: J'ai vérifié les données dans un éditeur de hex

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

Ainsi, le zéro est stocké sous forme de zéro, tout simplement pas lu zéro.

Parce que quand j'utilise ma fonction normale de fichiers magasin en-bin:

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

Il stocke 0 comme la version char, ou « \ 0 », ce qui est évidemment pas stocké (parce qu'il est une valeur nulle?) Quand je l'appelle ma fonction pour lire la valeur zéro, il lit la valeur juste après (ou juste avant si ce serait le dernier dans le fichier). Alors, comment puis-je stocker zéro dans un fichier .bin correctement?

EDIT: Voici quelques-unes des fonctions relatives à la procédure de lecture / écriture:

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

En outre, la sortie à l'aide de sector::Init est la suivante:

2
1
1

Le ouput que je tentais d'écrire dans la poubelle était

2
1
0

Donc, soit le 0 est en cours de lecture / écrite en tant que 1, ou son pas écrit et Init est en train de lire la dernière valeur deux fois.

Answer 1

Il est clair pas ce que vous entendez par « stockage valeur entière 0 » dans un fichier. Les fichiers contiennent des octets, des entiers non. Avez-vous besoin de stocker sizeof (int) 0-octets, ou juste un '\ 0' octet?

P.S. Je suppose que le problème aussi peut-être dans votre code de lecture. Est-ce que vous regardez votre fichier .bin dans un éditeur hexadécimal?

P.P.S. Votre problème est dans l'utilisation de la fonction seekg (). Au lieu de passer le décalage en octets, vous passez pos. Il devrait être pos * sizeof (int) à la place.

Answer 2

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

Answer 3

Je ne sais pas ce que vous voulez faire, il me semble le code que vous avez fourni fait ce que vous vous demandez:

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

Il en résulte un fichier de quatre octets de taille qui contient la représentation binaire d'un nombre entier de zéro:

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

Si vous voulez stocker l'entier car il est la représentation ASCII, vous devez utiliser la sortie de flux formaté avec <<:

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

De cette façon, vous obtenez:

$ cat /tmp/tst.out
0

Answer 4

Vous devez penser quel format le fichier binaire doit contenir - quelque chose que vous ne devez pas faire de la même manière avec des fichiers texte, ce qui explique pourquoi de fois un fichier texte est utilisé

.

En supposant une machine où sizeof (int) == 4 (et CHAR_BITS == 8), alors vous pouvez stocker 4 octets qui sont tous nuls à l'emplacement du fichier en cours (32 bits) en utilisant le format natif, alors ce que vous » ai obtenu il devrait y travailler, je pense. Vous pouvez expérimenter avec d'autres valeurs telles que 0x01020304, vous verrez la disposition des octets sur votre machine.

Bien sûr, vous devez faire attention en les lisant dans, inversant la procédure utilisée pour l'écriture. Et ne pas oublier de repositionner le fichier avant d'essayer de relire les données viennent d'être écrites.