Discussion :

[tompus]

Bonjour à tous (et toutes),

Voila mon problème :

Je voudrais écrire cette structure

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
typedef struct{
  int i;
  unsigned char vote ;
} enr;

dans un fichier de type binaire. Pour faire simple, j'ai un tableau d'un milliard de bits, codé sur 125 millions bytes. Je voudrais sauver seulement les bytes non null (car il y en a que maximum 10 millions qui sont non null), puisque sauver des 0 c'est bien, mais ça prend de la place et c'est null

J'ai eu l'idée de faire une structure qui prend l'indice dans le tableau, suivit de la valeur, et d'écrire cette structure dans un fichier.

Voici le code

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
    int fd = 0;
    char* path = malloc (21);
    path = strcpy(path, getNameBKP());
 
    if((fd = open (path, O_CREAT|O_WRONLY, 00666 )) < 0)
        exit(-1);
 
    int i = -1;
    while(++i < NBVOTER) //NBVOTER = 1 000 000 000 /8 = 125 000 000
        if(vote[i]){
            enr en = {i, vote[i]};
            write(fd, &en, sizeof(en));
        }
    close(fd);

Le résultat que j'obtiens est assez bizarre.
Si dans mon tableau je n'ai (en hexa) que 04 à l'indice 3, dans mon fichier j'ai (en hexa) : 03 00 00 00 04 00 00 00

Si quelqu'un à une idée du pourquoi les bits de poids faible et fort sont inversés, et du comment les remettre dans le bon sens, ou du pourquoi un unsigned char passe sur 32 bits, ce serait chouette.


Merci d'avance

Ah oui, petits détails qui éviteront des posts inutiles, les chiffres 10E9 et 10E7 sont fixés, et je ne peux pas les changer, et j'ai pas envie de me retrouver avec des fichiers de 125Mo à chaque fois que je sauve mon tableau.

[olivieram]

Windows ou Linux ?
ajoute une pragma
Vois du côté de :pragma

[droggo]

Jai,

olivieram a raison : c'est encodé en Little Endian, comme tous les systèmes à base x86 ou x64.

[tompus]

Windows ou Linux ?
ajoute une pragma
Vois du côté de :pragma

C'est sous linux (ubuntu 10.04).

Merci, je regarde ce qu'est une pragma.


edit:

Jai,

olivieram a raison : c'est encodé en Little Endian, comme tous les systèmes à base x86 ou x64.

OK, je m'y connais pas trop en type de codages. Il y a plusieurs manières d'encoder dans un fichier?

[olivieram]

Non, il n'y a pas plusieurs manières d'écrire dans un fichier.
Cela s'appelle en fait des "facilities" parce que le fonctionnement de la librairie fournit, en standard, la possibilité d'écrire dans un format d'encodage particulier. Il s'agit le plus souvent de UTF-8, ISO ou Unicode pour du texte.

[tompus]

Pour les bytes en trop, j'ai trouvé une solution dégueulasse mais qui marche, au lieu d'écrire ma structure en une fois, j'écris d'abord le int, puis le unsigned char.

Apparemment, sizeof(enr) = 8, sizeof(enr.i) = 4 et sizeof(enr.vote) = 1, d'ou 4 +1 => 8
Un petit truc de fou qui sort de nulle part, et qui alimente les forums.

Non, il n'y a pas plusieurs manières d'écrire dans un fichier.
Cela s'appelle en fait des "facilities" parce que le fonctionnement de la librairie fournit, en standard, la possibilité d'écrire dans un format d'encodage particulier. Il s'agit le plus souvent de UTF-8, ISO ou Unicode pour du texte.

Sinon je cherche toujours pour écrire de hb vers lb, ou lire de lb vers hb. Si tu as une idée de la ligne qu'il faut taper pour changer le format d'encodage (si vraiment ça change quelque chose).
Merci d'avance.

EDIT:
Je viens de réessayer de lire le fichier, et apparemment ça ne pose pas de problème que ce soit écrit à l'envers, il me lis bien tous les éléments. Donc c'était juste un problème à cause de la structure, avec des bytes en trop lors de l'écriture.

Un grand Merci à ceux qui ont répondu au post!

[Médinoc]

C'est pour cette raison qu'il est déconseillé d'écrire directement une structure dans un fichier binaire. Tu devrais en sérialiser le contenu toi-même pour l'écriture:

Code C :

Sélectionner tout - Visualiser dans une fenêtre à part

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
26
27
28
29
30
31
32
33
34
35
36
void write_uint(FILE* pfOut, unsigned int val)
{
	const unsigned int BITS_RIGHT = (sizeof(int)-1) * CHAR_BIT;
	const unsigned int LSBITS = ((unsigned int)-1) >> BITS_RIGHT;
	for(int i=0 ; i<sizeof(int) ; i++)
	{
		fputc((val >> BITS_RIGHT) & LSBITS, pfOut);
		val <<= CHAR_BIT;
	}
}
unsigned int read_uint(FILE* pfIn)
{
	unsigned int val = 0;
	for(int i=0 ; i<sizeof(int) ; i++)
	{
		val <<= CHAR_BIT;
		val |= fgetc(pfIn);
	}
}
 
void write_int(FILE* pfOut, int val)
{ write_uint(pfOut, (unsigned int)val; }
 
int read_int(FILE* pfIn)
{ return (int)read_uint(pfIn); }
 
void write_struct_enr(FILE* pfOut, enr const *pcObj)
{
	write_int(pfOut, pcObj->i);
	fputc(pcObj->vote, pfOut);
}
void read_struct_enr(FILE* pfIn, enr *pObj)
{
	pObj->i = read_int(pfIn);
	pObj->vote = fgetc(pfIn);
}

[olivieram]

Sinon je cherche toujours pour écrire de hb vers lb, ou lire de lb vers hb. Si tu as une idée de la ligne qu'il faut taper pour changer le format d'encodage (si vraiment ça change quelque chose).
Merci d'avance.

hb signifie high-byte et lb signifie low-byte ?

[tompus]

hb signifie high-byte et lb signifie low-byte ?

oui, normalement c'est lsb (Least Significant Bit), et msb (Most Significant Bit), merci de la correction.

[diogene]

oui, normalement c'est lsb (Least Significant Bit), et msb (Most Significant Bit), merci de la correction.

Non, la question ici concerne l'ordre d'écriture des bytes pas des bits. L'ordre des bits dans un byte n'est pas concerné.

[olivieram]

@tompus
a vous de choisir, c'est des bytes ou des bits ?

[tompus]

Non, la question ici concerne l'ordre d'écriture des bytes pas des bits. L'ordre des bits dans un byte n'est pas concerné.

Normalement j'écris toujours de msb a gauche, et lsb a droite, sauf que write les écris de lsb vers msb. Vu que read lis de lsb vers msb, ca perturbe ma petite nature quand j'ouvre le fichier en hexa, mais ca fonctionne.

Par exemple pour écrire 5 (en int), j'ai toujours écris 00000000 00000000 00000000 00000101, et dans le fichier il écris 00000101 00...00 .

Donc je crois que j'ai toujours mal écris, ou que pour des questions existentielles, on a décidé que write et read allaient écrire/lire des bytes dans l'autre sens.

[diogene]

Tu écris (comme tout le monde) en mettant MSB(it) à gauche et LSB(it) à droite.
La fonction write(), pour son compte, écrit une zone mémoire et le résultat est l'image de cette zone mémoire. Or il existe plusieurs systèmes (boutisme) pour coder en mémoire un nombre tenant sur plus d'un byte selon la machine (le processeur) utilisée. Les deux plus courants sont
- le boutisme BigEndian où le premier byte est celui qui contient les bits les plus significatifs et le dernier byte contient les bits les moins significatifs
- le boutisme LittleEndian où le premier byte est celui qui contient les bits les moins significatifs et le dernier byte contient les bits les plus significatifs.
Il y a donc entre les deux cas inversion des bytes.

Ta machine est donc dans le deuxième cas.

Naturellement, le read() procède de la même façon. Alors, si le write() et le read() sont faits sur une même machine (ou deux machines de même boutisme), le boutisme n'a pas d'incidence sur le fonctionnement.

[tompus]

Ok, merci diogene