Code sujet à l'endianness ?

Version imprimable

Bonsoir,
J'ai écrit cette petite fonction qui permet d'avoir la representation binaire d'un nombre dans une chaine de caractere.
Code:

1 2 3 4 5 6 7 8 /*récuperer dans une chaine de caractere la representation binaire 6 bits d'un nombre passé en param. */ static void representationBinaire(char *ch, int nb){ int i,j=0; for (i=5; i>=0; i--) ch[j++]= ( ((nb>>i)&1 )==0 ) ? '0' : '1' ; ch[6]='\0'; }
Elle fonctione sur ma machine, mais je me demande si le résultat ne dépend pas de l'endianness ... ?

11/05/2008, 12h01
diogene

la norme indique que nb>>i doit être égal à nb/(2^i) si nb est un entier non signé ou un entier signé non négatif. L'endianness ne doit donc pas être dans ce cas concerné.

Citation:

Envoyé par apesle

J'ai écrit cette petite fonction qui permet d'avoir la representation binaire d'un nombre dans une chaine de caractere.

Elle fonctione sur ma machine, mais je me demande si le résultat ne dépend pas de l'endianness ... ?

Pourquoi

Code:

1
2
3
4
 
   for (i = 5; i >= 0; i--)
<...>
   ch[6] = '\0';

C'est quoi ce 5, ce 6 ?

Sinon, l'ordre des bits est le même sur toutes les machines et il ne dépend pas de l'endianness, Je conseille de travailler avec un type non signé le plus grand possible
C90 : unsigned long
C99 : unsigned long long

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
 
#include "ed/inc/prt.h"
/*récuperer dans une chaine de caractere la representation binaire 6 bits d'un
nombre passé en param. */
static void representationBinaire (char *ch, unsigned long nb)
{
   int i, j = 0;
   for (i = 5; i >= 0; i--)
      ch[j++] = (((nb >> i) & 1) == 0) ? '0' : '1';
   ch[6] = '\0';
}
 
int main (void)
{
   int i;
   for (i = 0; i < 32; i++)
   {
      char s[33] = "????????????????";
 
      representationBinaire (s, 1ul << i);
      PRT_S (s);
   }
 
}

Ceci fonctionne, mais à l'évidence, il limite à une largeur de 6...

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
 
s            = '000001'
s            = '000010'
s            = '000100'
s            = '001000'
s            = '010000'
s            = '100000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
s            = '000000'
 
Press ENTER to continue.

Je préfère ça :

Code:

1
2
3
4
5
6
7
8
 
static void representationBinaire (char *ch, unsigned long nb)
{
   int i, j = 0;
   for (i = 31; i >= 0; i--)
      ch[j++] = (((nb >> i) & 1) == 0) ? '0' : '1';
   ch[32] = '\0';
}

ce qui donne :

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
 
s            = '00000000000000000000000000000001'
s            = '00000000000000000000000000000010'
s            = '00000000000000000000000000000100'
s            = '00000000000000000000000000001000'
s            = '00000000000000000000000000010000'
s            = '00000000000000000000000000100000'
s            = '00000000000000000000000001000000'
s            = '00000000000000000000000010000000'
s            = '00000000000000000000000100000000'
s            = '00000000000000000000001000000000'
s            = '00000000000000000000010000000000'
s            = '00000000000000000000100000000000'
s            = '00000000000000000001000000000000'
s            = '00000000000000000010000000000000'
s            = '00000000000000000100000000000000'
s            = '00000000000000001000000000000000'
s            = '00000000000000010000000000000000'
s            = '00000000000000100000000000000000'
s            = '00000000000001000000000000000000'
s            = '00000000000010000000000000000000'
s            = '00000000000100000000000000000000'
s            = '00000000001000000000000000000000'
s            = '00000000010000000000000000000000'
s            = '00000000100000000000000000000000'
s            = '00000001000000000000000000000000'
s            = '00000010000000000000000000000000'
s            = '00000100000000000000000000000000'
s            = '00001000000000000000000000000000'
s            = '00010000000000000000000000000000'
s            = '00100000000000000000000000000000'
s            = '01000000000000000000000000000000'
s            = '10000000000000000000000000000000'
 
Press ENTER to continue.

On pourrait passer la largeur en paramètre :

Code:

1
2
3
4
5
6
7
8
 
static void representationBinaire (char *ch, int larg, unsigned long nb)
{
   int i, j = 0;
   for (i = larg-1; i >= 0; i--)
      ch[j++] = (((nb >> i) & 1) == 0) ? '0' : '1';
   ch[larg] = '\0';
}

11/05/2008, 16h36
apesle
Citation:
Envoyé par Emmanuel Delahaye

Code:

1 2 3 4 for (i = 5; i >= 0; i--) <...> ch[6] = '\0';

C'est quoi ce 5, ce 6 ?
En fait je n'ai besoin que des 6 premiers bits, mais c'est sur que passer la longueur en param est plus élégant.

Citation:

Envoyé par Emmanuel Delahaye

Sinon, l'ordre des bits est le même sur toutes les machines et il ne dépend pas de l'endianness, Je conseille de travailler avec un type non signé le plus grand possible

ha bon?
mais par exemple le nombre 0xA0B70708
sera écrit
A0 B7 07 08 soit 10100000101101110000011100001000 en big endian
alors que
08 07 B7 A0 soit 1000000001111011011110100000 en little.

ou alors c'est le language qui assure que le résultat d'une opération de décalage binaire est le meme quelque soit l'endianness.

Merci pour vos précisions.
11/05/2008, 16h45
diogene

Citation:

ou alors c'est le language qui assure que le résultat d'une opération de décalage binaire est le meme quelque soit l'endianness.

cf post #2
11/05/2008, 17h19
apesle

Citation:

Envoyé par diogene

cf post #2

Je n'avais pas compris ta réponse. Maintenant c'est bon.
Je met résolu, merci à vous