Ecriture Binaire/Problème d'endianess

**DarKaa** · 03/07/2013, 13h39

Bonjour à tous,

J'essaye de réaliser un programme qui puisse écrire le contenu de variable en mode binaire dans un fichier. j'ai déjà posté sur dans la section Qt vu que je l'utilise mais je pense que la solution peut se trouver sans cette librairie, juste avec le C++.
Je dois pouvoir écrire ces variables en big ou little endian et ce peut importe ma machine.

Je m'y suis pris comme cela :

Code :

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
quint64 qi1 = 127;
quint64 qi2 = 18;
quint64 qi3 = 1;
quint64 qi4 = 10;
qint64 qi5 = 11;
qint64 qi6 = 4660;
// Je dois écrire ces variables en big endian dans cette exemple
FILE* fichier;
fichier = fopen("lol", "wb");
fwrite(&qi1, 2, 1, fichier); // l'access size de i1 est de 2
fwrite(&qi2, 1, 1, fichier); // l'access size de i2 est de 1
fwrite(&qi3, 1, 1, fichier); // l'access size de i3 est de 1
fwrite(&qi4, 1, 1, fichier); // l'access size de i4 est de 1
fwrite(&qi5, 1, 1, fichier); // l'access size de i5 est de 1
fwrite(&qi6, 2, 1, fichier); // l'access size de i6 est de 2
fclose(fichier);

Sur Ubuntu j'obtiens dans mon fichier (hexdump) :
007f 0112 0b0a 1234
Sur Windows j'obtiens :
7f00 1201 0a0b 3412
Hélas mon responsable me dit que je dois obtenir :
007f 12 01 0a0b 1234
Je suis vraiment pas calé dans ce domaine, je sais pas si je m'y prends bien ou si je dois faire autrement.
Si quelqu'un a une idée (pas trop compliqué (genre décallage de bit ), je le remercie)

**Médinoc** · 03/07/2013, 14h03

Ce que ton responsable demande, c'est du big-endian, mais sur des nombres de la bonne taille, pas sur des int64.

Il te faut un truc du genre:

Code :

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
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
void writeI1(unsigned char val, FILE *fout)
{
	unsigned char c[1];
	c[0] = (unsigned char)(val);
	fwrite(c, 1, 1, fout);
}
#define writeI1BE writeI1
#define writeI1LE writeI1
 
void writeI2BE(unsigned short val, FILE *fout)
{
	unsigned char c[2];
	c[0] = (unsigned char)(val >> 8);
	c[1] = (unsigned char)(val);
	fwrite(c, 1, 2, fout);
}
 
void writeI2LE(unsigned short val, FILE *fout)
{
	unsigned char c[2];
	c[0] = (unsigned char)(val);
	c[1] = (unsigned char)(val >> 8);
	fwrite(c, 1, 2, fout);
}
 
void writeI4BE(unsigned long val, FILE *fout)
{
	unsigned char c[4];
	c[0] = (unsigned char)(val >> 24);
	c[1] = (unsigned char)(val >> 16);
	c[2] = (unsigned char)(val >> 8);
	c[3] = (unsigned char)(val);
	fwrite(c, 1, 4, fout);
}
 
void writeI4LE(unsigned long val, FILE *fout)
{
	unsigned char c[4];
	c[0] = (unsigned char)(val);
	c[1] = (unsigned char)(val >> 8);
	c[2] = (unsigned char)(val >> 16);
	c[3] = (unsigned char)(val >> 24);
	fwrite(c, 1, 4, fout);
}
 
void writeI8BE(unsigned long long val, FILE *fout)
{
	unsigned char c[8];
	c[0] = (unsigned char)(val >> 56);
	c[1] = (unsigned char)(val >> 48);
	c[2] = (unsigned char)(val >> 40);
	c[3] = (unsigned char)(val >> 32);
	c[4] = (unsigned char)(val >> 24);
	c[5] = (unsigned char)(val >> 16);
	c[6] = (unsigned char)(val >> 8);
	c[7] = (unsigned char)(val);
	fwrite(c, 1, 8, fout);
}
 
void writeI8LE(unsigned long long val, FILE *fout)
{
	unsigned char c[8];
	c[0] = (unsigned char)(val);
	c[1] = (unsigned char)(val >> 8);
	c[2] = (unsigned char)(val >> 16);
	c[3] = (unsigned char)(val >> 24);
	c[4] = (unsigned char)(val >> 32);
	c[5] = (unsigned char)(val >> 40);
	c[6] = (unsigned char)(val >> 48);
	c[7] = (unsigned char)(val >> 56);
	fwrite(c, 1, 8, fout);
}

Bien sûr, on peut sans doute faire plus rapide et moins répétitif. Mais cette version est, je trouve, la plus facile à comprendre qui soit indépendante de l'endianness de la machine.

**DarKaa** · 03/07/2013, 14h39

Merci beaucoup ça marche niquel et je comprends a peu près le principe

J’implémente ça dans mon code et je reviendrai pour une autre question !

**Médinoc** · 03/07/2013, 15h40

Juste une remarque: Si tu as accès à des types à taille fixe (int64, int8, etc.) utilise-les à la place de char, short, long, et long long dans mon code.
Surtout long, sa taille n'est pas garantie être 32 bits (beaucoup de plate-formes 64 bits *n*x sont en LP64 au lieu de LLP64).

**DarKaa** · 03/07/2013, 16h07

Ok merci.
Donc à la place d'utiliser unsigned char, unsigned short, unsigned long et unsigned long long. Je dois utiliser respectivement int8_t, int16_t, int32_t, int64_t? Ou peut être les uintn_t?

**Médinoc** · 03/07/2013, 17h15

Plutôt les uintN_t. Quand on bosse avec ce genre de trucs, autant rester non-signé.

**DarKaa** · 03/07/2013, 17h32

Ok merci encore.
Par contre j'ai un problème quand il s'agit d'écrire une chaine ASCII. Je ne pense pas que l'endianess joue la dedans donc je n'ai pas utilisé vos fonctions.
Je fais en gros :

Code :

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

1
2
3
char toto[3];
memcpy(toto, "lol", 3);
fwrite(toto, 1, 3, fout);

Mais cela ne donne rien (fichier vide)

**Médinoc** · 03/07/2013, 17h42

Ça devrait pourtant marcher si lors de l'appel le fichier est bien ouvert...

**DarKaa** · 03/07/2013, 17h46

Autant pour moi j'ai oublié une info dans le dictionnaire de la librairie.

**DarKaa** · 03/07/2013, 18h13

Dernière question par rapport à vos fonctions : Est ce que cela fonctionne avec les floats, doubles. (Oui je dois pouvoir écrire tous les types

)

**Iradrille** · 03/07/2013, 19h09

Envoyé par DarKaa

Dernière question par rapport à vos fonctions : Est ce que cela fonctionne avec les floats, doubles. (Oui je dois pouvoir écrire tous les types

)

Il n'y a pas de raison que ça marche pas.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
void writeI4LE(unsigned long val, FILE *fout)
{
	unsigned char c[4];
	c[0] = (unsigned char)(val);
	c[1] = (unsigned char)(val >> 8);
	c[2] = (unsigned char)(val >> 16);
	c[3] = (unsigned char)(val >> 24);
	fwrite(c, 1, 4, fout);
}
 
void write4LE(float val, FILE *fout) {
	writeI4LE(*(reinterpret_cast<unsigned long*>(&val)), fout);
}

**Bousk** · 03/07/2013, 22h29

Bonsoir,

Est-on toujours dans le forum C++ ?
Toutes ces solutions sont du C. Je suis le premier à utiliser du "code C" quand besoin/envie/whatever, mais faudrait savoir ce que l'on veut.
Un bon coup de template spécialiser serait des plus efficace.

**Médinoc** · 03/07/2013, 23h13

Je n'avais même pas remarqué qu'on était dans le forum C++, en fait, vu que le premier message utilisait fwrite...

**Iradrille** · 04/07/2013, 02h09

Envoyé par Bousk

Bonsoir,

Est-on toujours dans le forum C++ ?
Toutes ces solutions sont du C. Je suis le premier à utiliser du "code C" quand besoin/envie/whatever, mais faudrait savoir ce que l'on veut.
Un bon coup de template spécialiser serait des plus efficace.

C'est vrai, mais l'algo (aussi simple soit-il) est beaucoup moins facile à comprendre, il se retrouve perdu au milieu de templates.

Code :

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
37
38
#include <iostream>
#include <fstream>
#include <stdint.h>
 
template <size_t> struct unsigned_ { };
template <> struct unsigned_<1> { typedef uint8_t type; };
template <> struct unsigned_<2> { typedef uint16_t type; };
template <> struct unsigned_<4> { typedef uint32_t type; };
template <> struct unsigned_<8> { typedef uint64_t type; };
 
template <class T>
void write(T val, std::ostream& os, bool big_endian=true) {
	const size_t size = sizeof(T);
	typedef unsigned_<size>::type type;
	for(size_t i=0; i<size; ++i) {
		type *ptr = reinterpret_cast<type*>(&val);
		os << static_cast<unsigned char>(((*ptr) >> (big_endian ? size-i-1: i)*8));
	}
}
 
int main() {
 
	std::ofstream file("tmp", std::ios::binary);
 
	write(uint16_t(127), file);
	write(uint8_t(18), file);
	write(uint8_t(1), file);
	write(uint8_t(10), file);
	write(uint8_t(11), file);
	write(uint16_t(4660), file);
 
	write(42.f, file); // float
	write(42.0, file); // double
 
	file.close();
 
	return 0;
}

**DarKaa** · 05/07/2013, 11h00

typedef unsigned_<size>::type type;

Il manque un typename entre typedef et unsigned_ et ça marche bien sur Windows. Par contre sur ma ubuntu j'obtiens : 7f00 0112 0b0a 3412. Ce qui n'est pas ce que je recherche

**Médinoc** · 05/07/2013, 11h08

Sur ta machine Ubuntu, CHAR_BIT est bien égal à 8?

**DarKaa** · 05/07/2013, 11h16

Avec limits.h CHAR_BIT vaut bien 8 sur ma machine Ubuntu

**DarKaa** · 08/07/2013, 09h21

Pas d'idée?

**DarKaa** · 08/07/2013, 13h05

Bonjour,

En fait je me re-suis mis à travailler sur ma machine Ubuntu et rien ne fonctionne en fait. J'étais en train de bidouiller le code avec les templates en m'inspirant du premier code (plus simple de compréhension) et en fait même ce dernier ne marche pas..

Impossible donc d'écrire 127 sur deux octets, 18, 1, 10, 11 chacun sur un octet et enfin 4660 sur deux octets sur ma machine little endian et obtenir
007f 1201 0a0b 1234..

**DarKaa** · 08/07/2013, 13h18

Bon ok, mon Windows aussi étais un little et le hexedit du fichier me donnait le bon résultat alors que ma ubuntu etait aussi une little endian mais le hexdump du fichier était faux.. Avec hexedit sur ubuntu ça marche nikel. Encore désolé pour tout ça..

Ecriture Binaire/Problème d'endianess

C++

Discussions similaires

Partager

Partager