Discussion :

[Le Farfadet Spatial]

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 :

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

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

[Niark13]

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.

[jabbounet]

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

[Le Farfadet Spatial]

Salut à tous !

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.

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 :

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

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

[jblecanard]

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)

[Le Farfadet Spatial]

Salut à tous !

si ton contexte le permet

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

À bientôt.

Le Farfadet Spatial

[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

[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 ?

[Le Farfadet Spatial]

Salut à tous !

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

[Le Farfadet Spatial]

Salut à tous !

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

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
  /**
   * \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

[pfeuh]

Salut,

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