Conversion héxadecimal -> decimal

**cout** · 21/06/2006, 16h50

Bonjour,

Voila j'ai un nombre en héxa sur 4 octets et stocké dans un tableau de char

Code :

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

1
2
3
4
5
6
7
8
 
fread(adresse,1,4,file);     //adresse[4] contient "03 00 00 C8"
c1[0] = adresse[0];         // c1[0] contient "03"
c2[0] = adresse[1];         // c2[0] contient "00"
c3[0] = adresse[2];         // c3[0] contient "00"
c4[0] = adresse[3];         // c4[0] contient "C8"
adresseEnreg = (c2[0])*256*256*256 + (c1[0])*256*256 + 
                                 (c4[0])*256 + c3[0];

Avec le debuger, je me suis aperçu que (c1[0])*256*256 contient 196608 (0x00030000),
(c4[0])*256 contient 51200 (0x0000C800) jusque là tout est normal,mais ensuite je me suis aperçu que adresseEnreg contient 182272 (0x0002C800) alors qu'il devrait contenir 247808 (0x0003C800)...

si qq'un voit l'erreur...

**PRomu@ld** · 21/06/2006, 16h54

Quel est le type utilisé pour adresseEnreg ?

**cout** · 21/06/2006, 16h55

type long

**PRomu@ld** · 21/06/2006, 17h02

Essaie en unsigned long.

Lorsque tu mets c[i] = ... , tu l'affiche réellement ou c'est une supposition ?

Et si tu ajoutes seulement les non nuls (C[1] et C[4])

**Foobar1329** · 21/06/2006, 17h05

Hello,

Envoyé par cout

Bonjour,

Voila j'ai un nombre en héxa sur 4 octets et stocké dans un tableau de char

Code :

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

1
2
3
4
5
6
7
8
 
fread(adresse,1,4,file);     //adresse[4] contient "03 00 00 C8"
c1[0] = adresse[0];         // c1[0] contient "03"
c2[0] = adresse[1];         // c2[0] contient "00"
c3[0] = adresse[2];         // c3[0] contient "00"
c4[0] = adresse[3];         // c4[0] contient "C8"
adresseEnreg = (c2[0])*256*256*256 + (c1[0])*256*256 + 
                                 (c4[0])*256 + c3[0];

Avec le debuger, je me suis aperçu que (c1[0])*256*256 contient 196608 (0x00030000),
(c4[0])*256 contient 51200 (0x0000C800) jusque là tout est normal,mais ensuite je me suis aperçu que adresseEnreg contient 182272 (0x0002C800) alors qu'il devrait contenir 247808 (0x0003C800)...

si qq'un voit l'erreur...

Quel est le rapport avec la conversion hexadécimal -> décimal ?

Pour résumer, ici tu assumes un passage de la base 256 à la base 10, est-ce vraiment ce que tu veux (en faisant en plus joujou avec l'endianess...) ?

Pour un passage hexadecimal -> decimal c'est LSB*16^0 + (LSB+1)*16^1 + ... + MSB*16^N où N est (le nombre de bytes à traiter -1)

A+

**cout** · 21/06/2006, 17h06

Essaie en unsigned long

ça n'a rien changé

Et si tu ajoutes seulement les non nuls (C[1] et C[4])

ça n'a rien changé non plus

Lorsque tu mets c[i] = ... , tu l'affiche réellement ou c'est une supposition ?

j'ai pas trop compris ce que tu voulais dire là

**PRomu@ld** · 21/06/2006, 17h09

j'ai pas trop compris ce que tu voulais dire là

Et bien lorsque tu dis, c1[0] vaut 03, est ce que tu en es sur ou c'est ce que tu voudrais ?

**cout** · 21/06/2006, 17h10

Quel est le rapport avec la conversion hexadécimal -> décimal

Le resultat de l'addiction est sensé etre en décimal

**cout** · 21/06/2006, 17h14

Mon debugger m'indique que le contenu de c1[0] est égal à 3 (0x03),

et lorsque je lui demande le contenu de "(c1[0])*256*256" il m'indique
"196608 (0x00030000)" et "(c4[0])*256" il m'indique "51200 (0x0000C800)"

C'est vraiment bizarre... c'est au moment de l'addition que le resultat est modifié : 0x0002C800 au lieu de 0x0003C800

**Foobar1329** · 21/06/2006, 17h25

Re,

Envoyé par cout

Mon debugger m'indique que le contenu de c1[0] est égal à 3 (0x03),

et lorsque je lui demande le contenu de "(c1[0])*256*256" il m'indique
"196608 (0x00030000)"

C'est vraiment bizarre... c'est au moment de l'addition que le resultat est modifié : 0x0002C800 au lieu de 0x0003C800

Si c1, c2, c3 et c4 sont des char et que char est considéré comme étant signé, c'est normal, il faut en faire des unsigned char (et le resultat à mettre en unsigned long aussi).
0xC8 , ça donne 200 ou -56 ...

Démo:
3*256*256 (from c1) - 56*256 (from c8) = 182272

A+

**DaZumba** · 21/06/2006, 17h29

Le plus simple serait certainement de mettre tes quatre caracteres dans une chaine valide (i.e. terminee par un '\0') et d'utiliser strtol() en precisant la base 16.

EDIT: Reponse sans rapport avec la question originale - a ignorer.

**cout** · 21/06/2006, 17h32

Ben merci beaucoup Foobar1329, le problème venait de là... c'est parfait

**Foobar1329** · 21/06/2006, 17h37

Hello,

Envoyé par DaZumba

Le plus simple serait certainement de mettre tes quatre caracteres dans une chaine valide (i.e. terminee par un '\0') et d'utiliser strtol() en precisant la base 16.

L'idée est bonne mais...Ce n'est pas une conversion héxadécimale -> décimale que fait cout, c.a.d que le motif original même si il s'agit de cracatères hexadécimaux, ne représentent pas un nombre en base 16 !

A+

**DaZumba** · 21/06/2006, 17h54

Envoyé par Foobar1329

L'idée est bonne mais...Ce n'est pas une conversion héxadécimale -> décimale que fait cout, c.a.d que le motif original même si il s'agit de cracatères hexadécimaux, ne représentent pas un nombre en base 16 !

Bien vu, j'ai mal compris la question. Ceci dit, je ne comprend toujours pas ce que cout veut faire. En interne, la base de representation d'un nombre importe peu. Elle n'a d'importance que lors des operations d'I/O.

**Emmanuel Delahaye** · 22/06/2006, 08h33

Envoyé par cout

Bonjour,

Voila j'ai un nombre en héxa sur 4 octets et stocké dans un tableau de char

Code :

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

1
2
3
4
5
6
7
8
 
fread(adresse,1,4,file);     //adresse[4] contient "03 00 00 C8"
c1[0] = adresse[0];         // c1[0] contient "03"
c2[0] = adresse[1];         // c2[0] contient "00"
c3[0] = adresse[2];         // c3[0] contient "00"
c4[0] = adresse[3];         // c4[0] contient "C8"
adresseEnreg = (c2[0])*256*256*256 + (c1[0])*256*256 + 
                                 (c4[0])*256 + c3[0];

Avec le debuger, je me suis aperçu que (c1[0])*256*256 contient 196608 (0x00030000),
(c4[0])*256 contient 51200 (0x0000C800) jusque là tout est normal,mais ensuite je me suis aperçu que adresseEnreg contient 182272 (0x0002C800) alors qu'il devrait contenir 247808 (0x0003C800)...

si qq'un voit l'erreur...

Peut être qu'en soignant un peu la présentation, on arriverait à écrire du code moins buggé...

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
 
#include <stdio.h>
 
int main (void)
{
   unsigned char adresse[4] =
      {
         0x03, 0x00, 0x00, 0xC8
      };
   unsigned c1 = adresse[0];         // c1[0] contient "03"
   unsigned c2 = adresse[1];         // c2[0] contient "00"
   unsigned c3 = adresse[2];         // c3[0] contient "00"
   unsigned c4 = adresse[3];         // c4[0] contient "C8"
 
#if 0
 
   unsigned long adresseEnreg = c2 * 256 * 256 * 256
                                + c1 * 256 * 256
                                + c4 * 256
                                + c3;
#else
 
   unsigned long adresseEnreg = c1 * 256 * 256 * 256
                                + c2 * 256 * 256
                                + c3 * 256
                                + c4;
#endif
 
   printf ("c1 = %02X\n", c1);
   printf ("c2 = %02X\n", c2);
   printf ("c3 = %02X\n", c3);
   printf ("c4 = %02X\n", c4);
 
   printf ("adresseEnreg = %08lX\n", adresseEnreg);
   return 0;
}

Code :

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

1
2
3
4
5
6
7
8
 
c1 = 03
c2 = 00
c3 = 00
c4 = C8
adresseEnreg = 030000C8
 
Press ENTER to continue.

**DaZumba** · 22/06/2006, 11h03

Envoyé par Emmanuel Delahaye

Ben non. Ce ne sont pas de bouts de chaines, mais des valeurs numériques...

Oui, je n'avais pas compris la question. J'edite mon post pour preciser que cette reponse est a cote de la plaque...

Conversion héxadecimal -> decimal

C

Discussions similaires

Partager

Partager