Convertir un décimal en hexa

Version imprimable

Bonjour,

Je viens de coder une fonction qui permet de convertir un décimal en hexadécimal. Je l'ai fait pour tout nombre de type unsigned int, sachant qu'en fait le plus grand nombre qui sera passé à ma fonction ne dépassera pas la valeur décimale du dernier caractère de la table ASCII étendue, soit 255 ( besoin de cette fonction pour écrire des données en hexa dans le registre ).

La voici :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
char *conversion_HEXA(unsigned int i)
{
    char *res = NULL;
    int r = 0;
    int q = 0;
    int taille = 0;
 
    q = i / 16;
    taille++;
 
    do
    {
        q /= 16;
        taille++;
 
    }while (q != 0);
 
    if ((res = malloc(taille)) == NULL)
    {
        printf("Erreur d'allocation mémoire...\n");
    }
 
    r = i % 16;
    q = i / 16;
 
    res[taille] = '\0';
    taille--;
 
    if (r == 10)
            res[taille] = 65;
        else if (r == 11)
            res[taille] = 66;
        else if (r == 12)
            res[taille] = 67;
        else if (r == 13)
            res[taille] = 68;
        else if (r == 14)
            res[taille] = 69;
        else if (r == 15)
            res[taille] = 70;
        else if (r == 16)
            res[taille] = 71;
        else
            res[taille] = 48+r;
 
    do
    {
        taille--;
 
        r = q % 16;
        q /= 16;
 
        if (r == 10)
            res[taille] = 65;
        else if (r == 11)
            res[taille] = 66;
        else if (r == 12)
            res[taille] = 67;
        else if (r == 13)
            res[taille] = 68;
        else if (r == 14)
            res[taille] = 69;
        else if (r == 15)
            res[taille] = 70;
        else if (r == 16)
            res[taille] = 71;
        else
            res[taille] = 48+r;
 
    }while (q != 0);
 
    return(res);
}
 
int main ()
{
    char *tab = NULL;
 
    printf("%s\n", tab = conversion_HEXA(1000));
 
    return(0);
}

J'aurais aimé avoir vos commentaires et avis sur ce bout de code : est-ce bien codé ? Peut-on faire plus simple ?

J'aimerais un retour critique dessus.

Merci par avance.

:ccool:

02/11/2009, 15h13
Médinoc

C'est mal codé: Tu devrais utiliser les constantes caractères au lieu des codes ASCII.
De plus, je déconseille l'allocation dynamique pour ça, utilise plutôt un buffer passé en paramètre. Surtout que dans ton exemple de code, il y a une fuite mémoire.

Ensuite, il y a abus de langage: Tu ne convertis pas "un décimal" en hexadécimal, tu exprimes un nombre en notation hexadécimale. Et tes chaînes de if() sont inutilement compliquées, alors que les caractères A à F sont alignés même en EBCDIC...
02/11/2009, 15h17
Merillym

Merci pour ta réponse Médinoc.

Citation:

Tu devrais utiliser les constantes caractères au lieu des codes ASCII.

Ceux que je passe en paramètre de la fonction, c'est bien ça ? C'est ce qui est prévu, là c'est juste un exemple généraliste.

Citation:

De plus, je déconseille l'allocation dynamique pour ça, utilise plutôt un buffer passé en paramètre. Surtout que dans ton exemple de code, il y a une fuite mémoire.

Comment connaître la taille du buffer à l'avance ? (bon ok, pour mon besoin, le buffer aura toujours une taille de 3, donc oui je peux effectivement simplifier) Mais dans le cas général, on ferait comment ?

Citation:

Surtout que dans ton exemple de code, il y a une fuite mémoire.

Pourrais-tu m'en dire plus ?

Citation:

Et tes chaînes de if() sont inutilement compliquées, alors que les caractères A à F sont alignés même en EBCDIC...

Ah oui, j'y avais pas pensé, merci.

:ccool:
02/11/2009, 15h19
jabbounet
pourquoi ne pas utiliser sprintf?
Code:

1 2 3 4 5 6 7 char maString[9]; unsigned int i = 15558; sprintf(maString,"%x", i) // ou sprintf(maString,"%X", i)
maintenant un octet = 2 digits en hexa, donc un entier sur 4 octets fait ....?

Je conseille plutôt un truc de ce genre:

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
#include <limits.h>
#include <string.h>
 
/* (c) Eric Sosman 2001 */
#define BIG_ENOUGH (1 + (sizeof(long long) * CHAR_BIT + 2) / 3 + 1)
 
/*(c) Medinoc 2009 */
int formatInt(
 char *sortie,     /*[out] Doit faire au moins BIG_ENOUGH caractères. */
 long long nombre, /*[in] Nombre à formater. */
 int base          /*[in] Base du nombre, entre 2 et 36. */
 ) /* Retourne 0 si OK, -1 si erreur. */
{
	static const char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	char buffer[BIG_ENOUGH];
	size_t i=BIG_ENOUGH;
	int bPremier = 1;
 
	if(base < 2 || base > 36 || sortie==NULL)
		return -1;
 
	/*Place un caractère nul à la fin du buffer interne.*/
	buffer[--i] = '\0';
 
	/*Remplit le buffer interne en partant de la fin.*/
	while(bPremier || nombre!=0)
	{
		bPremier = 0;
		buffer[--i] = digits[ nombre%base ];
		nombre /= base;
	}
	/*Recopie vers le buffer de sortie.*/
	strcpy(sortie, buffer+i);
	return 0;
}

En étant un peu plus téméraire, on pourrait même se passer du buffer interne: Écrire directement sur la sortie et décaler au début par un memmove().
Et quand j'ai vraiment besoin de performance, j'ai une fonction qui ne fait même pas de décalage, et retourne un pointeur sur la fin du buffer à la place.

02/11/2009, 15h26
Médinoc

Citation:

Pourrais-tu m'en dire plus ?

Tu oublies le free() sur tab. De plus, beaucoup de gens oublieraient tab aussi au passage, passant directement le résultat de la fonction à printf().
02/11/2009, 15h30
Merillym

Ah vi, j'oublie systématiquement le free pour libérer la mémoire dans mes programmes, je vais tout reprendre et rectifier ça, j'ai oublié. Merci pour cette importante remarque.

Citation:

Écrire directement sur la sortie et décaler au début par un memmove().

Je ne suis pas familier avec ces fonctions, il faudrait que je m'y mette.

Citation:

Et quand j'ai vraiment besoin de performance, j'ai une fonction qui ne fait même pas de décalage, et retourne un pointeur sur la fin du buffer à la place.

Ah vi...

Merci pour ton bout de code et tes remarques, je vais prendre tout cela en compte et aussi reprendre l'ensemble du code de mon command line tool afin de libérer la mémoire.

:)
02/11/2009, 15h46
Merillym

J'aurais deux dernières questions, sinon j'ai tout compris ;)

1) #define BIG_ENOUGH (1 + (sizeof(long long) * CHAR_BIT + 2) / 3 + 1)

=> Pourrais-tu m'expliquer cette ligne ? J'ai un peu du mal à comprendre comment cette constante est définie.

2) while(bPremier || nombre!=0)

=> Je ne saisis pas l'utilité de la constante bPremier.

Merci.
02/11/2009, 15h50
Médinoc
1. BIG_ENOUGH suppose qu'il faut un chiffre pour trois bits du nombre (donc, assez pour afficher le nombre en octal), arrondi au supérieur (ce à quoi sert le +2 avant la division), auxquels on ajoute un caractère pour le signe '-' et un autre pour le caractère nul terminal.
  Comme l'indique le commentaire, cette macro n'est pas de moi.
2. bPremier n'est pas une constante. C'est un booléen qui n'est vrai que lors de la première itération de la boucle: Il sert à ce qu'un nombre nul soit "0" au lieu de "".
  Mais en y réfléchissant, j'aurais sans doute pu mettre un do-while à la place, cela aurait été plus sensé...

Voici le code corrigé avec le do-while à la place du booléen:

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
#include <limits.h>
#include <string.h>
 
/* (c) Eric Sosman 2001 */
#define BIG_ENOUGH (1 + (sizeof(long long) * CHAR_BIT + 2) / 3 + 1)
 
/*(c) Medinoc 2009 */
int formatInt(
 char *sortie,     /*[out] Doit faire au moins BIG_ENOUGH caractères. */
 long long nombre, /*[in] Nombre à formater. */
 int base          /*[in] Base du nombre, entre 2 et 36. */
 ) /* Retourne 0 si OK, -1 si erreur. */
{
	static const char digits[] = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
	char buffer[BIG_ENOUGH];
	size_t i=BIG_ENOUGH;
 
	if(base < 2 || base > 36 || sortie==NULL)
		return -1;
 
	/*Place un caractère nul à la fin du buffer interne.*/
	buffer[--i] = '\0';
 
	/*Remplit le buffer interne en partant de la fin.*/
	do
	{
		buffer[--i] = digits[ nombre%base ];
		nombre /= base;
	}
	while(nombre!=0);
 
	/*Recopie vers le buffer de sortie.*/
	strcpy(sortie, buffer+i);
	return 0;
}

02/11/2009, 15h55
Merillym

Merci ;)

Je comprends mieux.

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
#include <stdio.h>
#include <stdlib.h>
 
static char * decimal2hexa(unsigned int decimal)
{
   static char const hexaset[] = "0123456789ABCDEF";
   char * hexa = NULL;
 
   unsigned int quotient = decimal;
   unsigned int size = 0;
 
   /* could be optimize */
   do
   {
      quotient /= 16;
      size++;
   }
   while(quotient != 0);
 
   hexa = malloc(size + 1);
 
   if(hexa == NULL)
   {
      perror("malloc");
   }
   else
   {
      hexa[size] = '\0';
 
      do
      {
         size--;
         hexa[size] = hexaset[decimal % 16];
         decimal /= 16;
      }
      while(decimal != 0);
   }
 
   return hexa;
}
 
int main(void)
{
   char * hexa = decimal2hexa(1000);
 
   if(hexa != NULL)
   {
      puts(hexa);
      free(hexa), hexa = NULL;
   }
 
   return 0;
}

EDIT: la fonction de Médinoc est à préférer car générique.

02/11/2009, 16h06
Médinoc

Citation:

Envoyé par nicolas.sitbon

EDIT: la fonction de Médinoc est à préférer car générique.

Je trouve que son principal avantage, c'est surtout de ne pas entretenir la fausse notion qu'un nombre est "en décimal".
02/11/2009, 16h14
nicolas.sitbon

Citation:

Envoyé par Médinoc

Je trouve que son principal avantage, c'est surtout de ne pas entretenir la fausse notion qu'un nombre est "en décimal".

On est d'accord :ccool:

et cette solution ne conviens pas?

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
#include <stdlib.h>
#include <stdio.h>
 
static char * dec2hex(unsigned int data) {
 
  char * hData = malloc(sizeof(char)*9);
  if (hData == NULL) {
    perror("malloc");
  }
 
  sprintf(hData,"%08X",data);
  hData[8] = 0;
 
  return hData;
}
 
int main(int argc, char ** argv) {
 
  char * s;
  unsigned int  i;
 
  for (i = 0; i < 500; i++) {
    s = dec2hex(i*50000);
    printf(" %11d --Hex--> %s\n",i*50000,s); 
    free(s);
  }
  return 0; 
}

J'obtiens finalement ça ( le but est d'obtenir le nombre hexadécimal d'un caractère ) :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <stdio.h>
#include <windows.h>
 
char *conv_ascii_hexa(unsigned char c);
 
char *conv_ascii_hexa(unsigned char c)
{
    char *res = NULL;
    static const char digits[] = "0123456789ABCDEF";
    unsigned int quotient = c;
    int size = 0;
 
    do
    {
        quotient /= 16;
        size++;
 
    }while (quotient != 0);
 
    if ((res = malloc(size)) == NULL)
    {
        printf("Erreur d'allocation mémoire...\n");
    }
 
    res[size] = '\0';
    quotient = c;
 
    do
    {
        size--;
        res[size] = digits[quotient % 16];
        quotient /= 16;
 
    }while (quotient != 0);
 
    return(res);
}
 
int main ()
{
    char *tab = NULL;
 
    printf("%s\n", tab = conv_ascii_hexa('¨'));
    free(tab);
    (char*)tab = NULL;
 
    return(0);
}

Ce n'est pas encore tout à fait "parfait" je pense, mais c'est déjà mieux et j'ai essayé de prendre en compte tous vos conseils.

;)

Citation:

Envoyé par Merillym

J'obtiens finalement ça ( le but est d'obtenir le nombre hexadécimal d'un caractère ) :

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
36
37
38
39
40
41
42
43
44
45
46
47
48
49
 
#include <stdio.h>
#include <windows.h>
 
char *conv_ascii_hexa(unsigned char c);
 
char *conv_ascii_hexa(unsigned char c)
{
    char *res = NULL;
    static const char digits[] = "0123456789ABCDEF";
    unsigned int quotient = c;
    int size = 0;
 
    do
    {
        quotient /= 16;
        size++;
 
    }while (quotient != 0);
 
    if ((res = malloc(size)) == NULL)
    {
        printf("Erreur d'allocation mémoire...\n");
    }
 
    res[size] = '\0';
    quotient = c;
 
    do
    {
        size--;
        res[size] = digits[quotient % 16];
        quotient /= 16;
 
    }while (quotient != 0);
 
    return(res);
}
 
int main ()
{
    char *tab = NULL;
 
    printf("%s\n", tab = conv_ascii_hexa('¨'));
    free(tab);
    (char*)tab = NULL;
 
    return(0);
}

Ce n'est pas encore tout à fait "parfait" je pense, mais c'est déjà mieux et j'ai essayé de prendre en compte tous vos conseils.

;)

Non dans ce cas là, mieux vaut que tu restes sur ma solution.

02/11/2009, 17h24
Merillym

Oui mais la tienne prend des arguments de type unsigned int alors que les arguments qui seront passés à ma fonction seront de type unsigned char... C'est pour ça que je n'ai pas pris la tienne.

Mais il est fort possible que quelque chose m'échappe ;)

edit: Enfin ça doit revenir au même en fait.
02/11/2009, 17h29
Médinoc

Aussi, le cast sur tab ne sert à rien.
02/11/2009, 17h45
Merillym

Citation:

Envoyé par Médinoc

Aussi, le cast sur tab ne sert à rien.

C'était un warning du compilo, mais c'est bien ce qu'il me semblait. Je compile en C.