Discussion :

[ft1103]

Bonjour à tous,

Actuellement, j'essaie de résoudre le problème suivant, mais en vain :

Soit un hexadécimal X = 0x35AB.
char t[2] = {0x35, 0xAB}

J'ai une fonction f telle que :

f(t, taille = 2) -> return char tab_ret [4] = {0x33, 0x35, 0x41, 0x42}, i.e. qui pour chaque code ascii de X, retourne sa valeur héxa : '3' -> 0x33, '5' -> 0x35, 'A' -> 0x41, 'B' -> 0x42.

Pour tester ma fonction, je déclare uchar1 = 53 (pour 0x35) et uchar2 = 171 (0xAB), puis un char t_test[2], que je le remplis avec uchar1 et uchar2.
Pour l'instant, ça marche.

Ce que je souhaiterais faire, et que je n'arrive pas, c'est la fonction inverse, qui prend en paramètre char t_inv[4] = {0x33, 0x35, 0x41, 0x42}, et me return char t_ret [2] = {0x35, 0xAB}.

Merci d'avance pour votre aide, et si je n'ai pas été assez clair n'hésitez pas à me rependre.

[Obsidian]

Bonjour,

En premier lieu, si tu es sûr que ton format de sortie sera toujours le même (16 bits), tu peux utiliser un unsigned short int voire même simplement un unsigned int plutôt qu'un tableau.

Ensuite, pour convertir un nombre hexadécimal écrit en toutes lettres vers une valeur numérique binaire, il faut prendre chaque chiffre, un par un en partant de la gauche, déterminer sa valeur individuelle, décaler vers la gauche la valeur déjà présente dans ton accumulateur, et y ajouter celle que tu viens de déterminer.

Pour décaler d'un chiffre vers la gauche une valeur en hexadécimal, on la multiplie par 16, exactement de la même façon que l'on multiplie par 10 une valeur décimale pour obtenir le même résultat.

Ce qui donne quelque chose ressemblant à ceci :

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
#include <stdio.h>
 
int main (void)
{
    int i = 0;
    unsigned int total = 0;
    char t_inv[4] = {0x33, 0x35, 0x41, 0x42};
 
    for (i=0;i<sizeof t_inv;i++)
    {
        total *= 16;
 
        if      (t_inv[i] >= '0' && t_inv[i] <= '9') total += t_inv[i] - '0';
        else if (t_inv[i] >= 'A' && t_inv[i] <= 'F') total += t_inv[i] - 'A' + 10;
        else if (t_inv[i] >= 'a' && t_inv[i] <= 'f') total += t_inv[i] - 'a' + 10;
        else break;
    }
 
    printf ("%02x\n",total);
    return 0;
}

[Kirilenko]

Bonsoir,

Étant donné que, dans ton projet, tu sembles prendre pour acquis que l'utilisateur utilise le jeu de caractère ASCII, on va faire comme si c'était le cas, ie. je présumerai, dans la suite de ma réponse, que 'A'-'B'=1 par exemple, mais on notera que ce n'est pas une relation qui est portable, et qui serait donc à éviter si jamais les consignes qui te sont imposées n'en font pas la remarque (de même pour le nombre de bits dans un byte, qu'on présupposera à 8). Très simplement, tu pourrais récupérer, dans un premier temps, la valeur du caractère :

Code :

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

1
2
3
4
5
6
7
8
9
10
#include <string.h>
 
const char *alphabet="0123456789ABCDEF";
const char *position=strchr(alphabet, hexa);
 
if (position != NULL)
{
  ptrdiff_t offset=position-alphabet;
  /* ... */
}

Par conséquent, offset va donner la valeur du byte courant. Le reste n'est plus qu'une question de décalages de bits. On pourrait imaginer le code suivant :

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
/* Version portable. */
 
#include <stdlib.h>
#include <string.h>
 
unsigned char *not_f(const unsigned char *src,
                     const size_t length)
{
  const char *const alphabet = "0123456789ABCDEF";
  unsigned char *dst;
  size_t i;
 
  dst = malloc(length >> 1);
 
  for(i = 0; i < length; i += 2)
  {
    const char *const position[2] =
    {
      strchr(alphabet, src[i]), 
      strchr(alphabet, src[i + 1])
    };
 
    dst[i >> 1] = (unsigned char)((position[0] - alphabet) << 4) | (position[1] - alphabet);
  }
 
  return dst;
}

Par contre, il faudra évidemment placer des assertions un peu partout (taille multiple de 2, allocations et recherches qui causent un comportement indéterminé, etc.). Donc, la gestion des erreurs est entièrement à faire.

Bonne soirée !

[ft1103]

Merci à vos deux réponses, dont les explications d' Obsidian, et le code de Kirilenko qui fonctionne et me retourne bien les valeurs attendues.