Discussion :

[Neal Morse]

Bonsoir,

J'ai fait une fonction qui transforme une chaine de 4 caractères hexadécimaux en caractères binaires, mais je ne trouve pas la façon de faire très esthétique, y a-t-il un moyen de faire sans la définition de mes deux tableaux ?

Merci

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
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
function HexaToBinaire(ChaineHexa: string):string;
 
Var
    i,j,Endj: integer;
    Return: string;
    CorrespondanceBinaire : Array[0..15] of string;
    ListePossibilitesHexa : Array[0..15] of char;
 
Begin //HexaToBinaire
    (* on initialise Return à '', car on va concaténer 
     *les caractères trouvés au fur et à mesure
     *)
    Return := '';
 
    ListePossibilitesHexa[0] := '0';
    ListePossibilitesHexa[1] := '1';
    ListePossibilitesHexa[2] := '2';
    ListePossibilitesHexa[3] := '3';
    ListePossibilitesHexa[4] := '4';
    ListePossibilitesHexa[5] := '5';
    ListePossibilitesHexa[6] := '6';
    ListePossibilitesHexa[7] := '7';
    ListePossibilitesHexa[8] := '8';
    ListePossibilitesHexa[9] := '9';
    ListePossibilitesHexa[10] := 'A';
    ListePossibilitesHexa[11] := 'B';
    ListePossibilitesHexa[12] := 'C';
    ListePossibilitesHexa[13] := 'D';
    ListePossibilitesHexa[14] := 'E';
    ListePossibilitesHexa[15] := 'F';
 
    CorrespondanceBinaire[0] := '0000';
    CorrespondanceBinaire[1] := '0001';
    CorrespondanceBinaire[2] := '0010';
    CorrespondanceBinaire[3] := '0011';
    CorrespondanceBinaire[4] := '0100';
    CorrespondanceBinaire[5] := '0101';
    CorrespondanceBinaire[6] := '0110';
    CorrespondanceBinaire[7] := '0111';
    CorrespondanceBinaire[8] := '1000';
    CorrespondanceBinaire[9] := '1001';
    CorrespondanceBinaire[10] := '1010';
    CorrespondanceBinaire[11] := '1011';
    CorrespondanceBinaire[12] := '1100';
    CorrespondanceBinaire[13] := '1101';
    CorrespondanceBinaire[14] := '1110';
    CorrespondanceBinaire[15] := '1111';
 
    (*
            * Pour chaque caractère hexadécimal on vérifie sa correspondance avec le tableau
            * si elle est trouvée on affiche l'équivalent en binaire
            * Endj sert à finir plus rapidement la boucle pour éviter des itérations inutiles si correpondance trouvée
            *)
    for i:= 1 to 4 do
        Begin
            Endj := 15;
            for j:= 0 to Endj do
                Begin
                    if ChaineHexa[i] = ListePossibilitesHexa[j] then
                        Begin
                            Return := Return+CorrespondanceBinaire[j];
                            Endj := 1;
                        End;
                End;
        End;
 
    HexaToBinaire := Return;
End; //HexaToBinaire

[krachik]

bonjour
pas terrible ta methode j'avoue mais que c'est quand un debut et forcement il y a toujours mieux et plus optimal,la ça fait pas mal de ligne
je pense que tu pourrais aussi ecrire de cotée une fonction qui converti un nombre decimal en binaire et du coup tu poura juste faire un test sur chaque caractere pour savoir si c'est un chiffre(1-9) ou une lettre(A-F)
et aussi une petite fonction quii fait ce genre de correspondance
A............10
....
...
F............15
apres reste a faire les calculs de conversion base 16----->(base 10)------>base 2
@+

[droggo]

Lai,

Assez d'accord avec krachik, c'est un peu lourd.

Dans un cas de ce genre, il vaut mieux décomposer le problème :

- Tu as une chaîne de 4 caractères en hexa, donc valeur sur 2 octets, soit un Integer pour TP7

- Il te faut une fonction pour traduire ta chaîne en Integer

- Et ensuite une fonction pour traduire la valeur d'un Integer en chaîne binaire.


Il s'agit là d'une démarche générale : diviser pour régner.

Pourquoi ?

- de petites fonctions sont plus faciles à écrire/maintenir

- moins une fonction fait de choses différentes, plus facilement elle peut être réutilisée.

Exemple pour le cas que tu veux faire :

Supposons que demain, par exemple, on te demande de faire
"convertir une chaîne en base octale en une chaîne en base 2",

- Avec la fonction comme tu l'as faite, il faudra que tu réécrives tout, y compris la déclaration des tableaux, ...

- Alors que si tu as fait les 2 fonctions comme je le suggère, tu n'auras à réécrire que la conversion chaîne base 8 vers Integer

[krachik]

- Il te faut une fonction pour traduire ta chaîne en Integer

la chaine peut être AF35

[droggo]

Hy,

la chaine peut être AF35

Oh, tu crois ? Zut alors, moi qui croyais que les chaines hexa ne contenaient que des 0 : il suffirait de compter les zéros pour avoir la valeur

J'ai bien dit qu'il faut faire une fonction traduire la chaine, non ?

[krachik]

tu a dis qu'il fallait une fontion pour traduire la chaine en entier
si on pense a la meme chose ça sera deux choses à faire
convertir les lettre en chiffre par les correspondants entier et garder les entier tel que
et traduire tout en entier