write(), bytes inversés et supplémentaires

Version imprimable

Bonjour à tous (et toutes),

Voila mon problème :

Je voudrais écrire cette structure
Code:

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:

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.

11/06/2011, 14h07
olivieram

pragma

Windows ou Linux ?
ajoute une pragma
Vois du côté de :pragma
11/06/2011, 14h15
droggo

Jai,

olivieram a raison : c'est encodé en Little Endian, comme tous les systèmes à base x86 ou x64. :)
11/06/2011, 16h28
tompus

Citation:

Envoyé par olivieram

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:

Citation:

Envoyé par droggo

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?
11/06/2011, 18h04
olivieram

encoder dans un fichier

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.
11/06/2011, 19h12
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.

Citation:

Envoyé par 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.

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!

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:

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

11/06/2011, 22h44
olivieram

Citation:

Envoyé par tompus

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 ?
12/06/2011, 13h45
tompus

Citation:

Envoyé par olivieram

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.
12/06/2011, 18h46
diogene

Citation:

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é.
13/06/2011, 00h18
olivieram

@tompus
a vous de choisir, c'est des bytes ou des bits ?
13/06/2011, 17h03
tompus

Citation:

Envoyé par diogene

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.
13/06/2011, 19h09
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.
13/06/2011, 20h43
tompus

Ok, merci diogene