Conversion de little-endian à big-endian et inversement

Salut à tous !

Je me retrouve à lire (en C++) des fichiers non formatés (binaires) séquentiels générés en Fortran, ce qui met à mal le peu de santé mentale qu´il me reste. Au-delà des problèmes de délimiteurs d´enregistrements que je pense avoir réglé, j´ai besoin de faire des conversions depuis petit-boutsien (little-endian) à gros-boutsien (big-endian) et inversement. Voici un code qui semble donner satisfaction :

Code:

---

1 2 3 4 5 6 7 8 9 10

/**    * \brief Swap from little or big endian to the other.    * \param x Data to be converted.    * \todo This function has to be redone in a more secure way.    */ template <class T> inline void littleBigEndian (T &x) { // Number of bits for the swap. Infers that a char has 8 bits. const size_t n = sizeof(T) * 4; x = (x << n) | (x >> n); } // void littleBigEndian (T &)

---

Néanmoins, je crains qu´elle ne soit pas très sûr dans le cas de valeurs signées. De plus, je ne suis pas certain que ce soit le meilleur moyen d´effectuer cette conversion. Si quelqu´un s´est déjà attelé à ce problème et a des conseils, je suis preneur.

À bientôt.

Le Farfadet Spatial

Salut,

Ton code me semble correct pour des entiers de 16bits, par contre, pour des entiers de 32 bits, il ne swappe pas tous les octets, mais seulement les deux mots de 16bits intermédiaires.

Par exemple, l'entier 0x01020304 est stocké en mémoire comme :

• 01 02 03 04 en big endian
• 04 03 02 01 en little endian

Or si je ne m'abuse (il est encore tôt et je ne suis pas encore à mon troisième café), ta fonction va transformer 01 02 03 04 en 03 04 01 02.

Si c'est pour des communications réseau tu peux utiliser htonl, ntohl....
http://www.manpagez.com/man/3/htonl/

Maintenant si tu as un appli qui tourne sur deux archi différentes et que tu passe des fichier de l'une a l'autre écrit en format binaire tu peux aussi les utiliser.

Si c'est juste comment est fait la conversion le source est aussi dispo facilement trouvable sur le net:
http://www.raspberryginger.com/jbail...eab285a1b46019

Salut à tous !

Citation:

---

Envoyé par Niark13

Or si je ne m'abuse (il est encore tôt et je ne suis pas encore à mon troisième café), ta fonction va transformer 01 02 03 04 en 03 04 01 02.

---

Non, tu ne t´abuses pas, c´est bien ce qu´elle fait. Je suis allé un peu vite en besogne en imaginant que cela suffirait à la conversion quel que soit le type.

Citation:

---

Envoyé par jabbounet

Maintenant si tu as un appli qui tourne sur deux archi différentes et que tu passe des fichier de l'une a l'autre écrit en format binaire tu peux aussi les utiliser.

---

Je suis dans ce dernier cas. Malheureusement, je ne peux pas être totalement certains que les en-têtes seront installés sur toutes les machines sur lequel le code doit être compilé, je ne peux donc pas simplement réutiliser les macro-commandes.

Dans la mesure où il s´agit d´une conversion depuis des fichiers générés en Fortran, je n´ai à convertir que des entiers. J´ai donc repris le code pour créer cette fonction :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

/**    * \brief Swap from little or big endian to the other.    * \param x Data to be converted.    * \todo It has to be redone in a more secure way.    *    * Infers that sizeof(int) == 4.    */ inline void littleBigEndian (int &x) { x = ((x >> 24) & 0xffL) | ((x >> 8) & 0xff00L) | ((x << 8) & 0xff0000L) | ((x << 24) & 0xff000000L); } // void littleBigEndian (int &)

---

Son effet à l´air d´être bien plus approprié que le précédent code. Cela dit, j´ai encore des doutes quant à sa validité sur des entiers signés : il me semble bien que, dans un tel cas, le résultat est fonction du compilateur.

À bientôt.

Le Farfadet Spatial

Citation:

---

Envoyé par Le Farfadet Spatial

Je suis dans ce dernier cas. Malheureusement, je ne peux pas être totalement certains que les en-têtes seront installés sur toutes les machines sur lequel le code doit être compilé, je ne peux donc pas simplement réutiliser les macro-commandes.

---

Ce n'est pas standard, mais c'est dans la librairie C Unix et Windows si je ne m'abuse donc en encapsulant ça correctement, ça devrait bien se passer (si ton contexte le permet)

Salut à tous !

Citation:

---

Envoyé par jblecanard

si ton contexte le permet

---

Malheureusement non, le contexte ne me le permet pas (j´aurais préféré).

À bientôt.

Le Farfadet Spatial

Salut à tous !

Bon, encore une mauvaise nouvelle pour ma raison chancelante : de toute évidence, il y a des différences d´encodages entre petit-boutsien et gros-boutsien également pour les nombres à virgules flottantes. Est-ce que quelqu´un a une idée de comment effectuer la conversion tant pour la simple précision que pour la double précision ?

À bientôt.

Le Farfadet Spatial

Dans le pire des cas, les différences d'encodage des flottants peuvent aller bien plus loin qu'une simple histoire de boutisme.
Est-ce que tu es certain qu'il n'y a que ça ?

Salut à tous !

Citation:

---

Envoyé par JolyLoic

Dans le pire des cas, les différences d'encodage des flottants peuvent aller bien plus loin qu'une simple histoire de boutisme.
Est-ce que tu es certain qu'il n'y a que ça ?

---

Certains, non.

En revanche, je peux raisonnablement considérer que les nombres à virgules flottantes répondent à la norme IEEE 754. Dans un premier temps au moins, je pense qu´il est rentable de voir déjà la conversion entre petit et gros boutsien.

À bientôt.

Le Farfadet Spatial

Salut à tous !

J´ai réussi à produire un code générique qui à mon avis est sécurisé :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

/**    * \brief Convert from little or big endian to the other.    * \param x Data to be converted.    */ template <class T> inline void littleBigEndian (T &x) { // The new value. T tmp; // To interpret the value as an array of chars. unsigned char *toConvert = reinterpret_cast<unsigned char *>(&x); // The new value as an array of chars. unsigned char *converted = reinterpret_cast<unsigned char *>(&tmp);   for (size_t i = 0; i < sizeof(T); ++i) converted[i] = toConvert[sizeof(T) - i - 1]; x = tmp; } // template <class T> void littleBigEndian (T &)

---

Derrière, je fais confiance au compilateur pour produire un code optimisé (notamment pour dérouler les boucles).

Dans mes tests, cela résout tous mes problèmes de conversion. Je passe le sujet en résolu, mais n´hésitez pas à dire si vous trouvez qu´il y a des défauts à ce code.

Merci de votre aide.

À bientôt.

Le Farfadet Spatial

Salut,

Citation:

---

Envoyé par Le Farfadet Spatial

il y a des différences d´encodages entre petit-boutsien et gros-boutsien également pour les nombres à virgules flottantes.

---

Tout à fait. De mémoire, si tu convertis à l'aide de pointeurs petit* gros* et de swaps de bytes, tu peux appliquer la fonction de conversion autant aux flottants qu'aux entiers s'ils sont tous en 32 bits.

A+

Pfeuh