Discussion :

[apesle]

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

Code :

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

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

[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é.

[Emmanuel Delahaye]

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 :

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

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 :

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
 
#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 :

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
 
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 :

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

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 :

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
 
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 :

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

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

[apesle]

Code :

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

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.

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.

[diogene]

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

[apesle]

cf post #2

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