Vous ne trouvez pas de réponse à votre problème ? Alors posez la question dans le forum. Souvenez-vous qu'il n'y a jamais de question bête, mais rester dans l'ignorance parce que l'on n'ose pas poser une question, ça c'est une erreur !

CONVERSIONS : BINAIRE - OCTALE - DECIMALE - HEXADECIMALE


Information sur la source

Catégorie :Maths Niveau : Débutant Date de création : 02/11/2002 Date de mise à jour : 02/11/2002 04:02:55 Vu / téléchargé: 6 739 / 214

Note :
8,5 / 10 - par 2 personnes
8,50 / 10

  • 1

  • 2

  • 3

  • 4

  • 5

  • 6

  • 7

  • 8

  • 9

  • 10

Commentaire sur cette source (5)
Ajouter un commentaire et/ou une note


Description

Bon c'est sur, il y a des fonctions integrées qui pourraient reduire la taille du code, mais le but etait de mettre en oeuvre les manieres de conversions apprises en cours.
C'est un de mes 1ers petits projet, mais je le poste, je n'ai pas vu d'equivalent...
il faudrait que je gere le depassement de capacité des variables integer lorsqu'on saisit un gros chiffre,je vais penser à ca.
Pour l'instant il ne gere pas encore les virgules, mais je suis en train de tenter de gerer ca (ce qui est deja une autre histoire lol)  
 

Source

  • function decibinr(decival : integer) : string;
  • var
  • i : integer;
  • j : integer;
  • h : string;
  • n : string;
  • begin
  • i := decival ;
  • while i <> 0 do
  • begin
  • j := i mod 2;
  • i := i div 2;
  • h := inttostr(j) + h ;
  • end;
  • decibinr := h;
  • end;
  • function decioct(decival : integer) : string;
  • var
  • j : integer;
  • h : string;
  • b : string ;
  • res : string;
  • n : integer;
  • begin
  • n := decival ;
  • while n >= 8 do
  • begin
  • j := n mod 8;
  • n := n div 8;
  • b := inttostr(j) + b;
  • end;
  • b := inttostr(n) + b ;
  • decioct := b;
  • end;
  • function decihexa(decival : integer) : string;
  • var
  • h : string;
  • res : string;
  • n : integer;
  • b : integer;
  • begin
  • n := decival;
  • while n >= 16 do
  • begin
  • b := n Mod 16 ;
  • n := n div 16 ;
  • CASE b of
  • 0 : h := '0';
  • 1 : h := '1';
  • 2 : h := '2';
  • 3 : h := '3';
  • 4 : h := '4';
  • 5 : h := '5';
  • 6 : h := '6';
  • 7 : h := '7';
  • 8 : h := '8';
  • 9 : h := '9';
  • 10 : h := 'A';
  • 11 : h := 'B';
  • 12 : h := 'C';
  • 13 : h := 'D';
  • 14 : h := 'E';
  • 15 : h := 'F';
  • END;
  • res := h + res;
  • end;
  • CASE n of
  • 0 : h := '0';
  • 1 : h := '1';
  • 2 : h := '2';
  • 3 : h := '3';
  • 4 : h := '4';
  • 5 : h := '5';
  • 6 : h := '6';
  • 7 : h := '7';
  • 8 : h := '8';
  • 9 : h := '9';
  • 10 : h := 'A';
  • 11 : h := 'B';
  • 12 : h := 'C';
  • 13 : h := 'D';
  • 14 : h := 'E';
  • 15 : h := 'F';
  • END;
  • res := h + res ;
  • decihexa := res;
  • end;
  • function bindeci(binval : string) : integer;
  • var
  • i : integer;
  • res : variant;
  • h : string;
  • bin : string;
  • begin
  • bin := binval ;
  • res := 0 ;
  • for i := 0 to Length(bin)-1 do
  • begin
  • h := copy(bin,length(bin)-i,1) ;
  • if i = 0 then
  • begin
  • if h = '1' then res := res + 1 ;
  • h := '0';
  • end ;
  • if h = '1' then res := res + Exp(i*Ln(2)) ;
  • end ;
  • bindeci := res;
  • end;
  • function octdeci(octval : integer) : integer;
  • var
  • i : integer;
  • j : string;
  • h : string;
  • test : integer;
  • b : integer;
  • n : integer;
  • res : integer;
  • result2 : variant;
  • result3 : integer;
  • oct : integer;
  • begin
  • oct := octval;
  • n := length(inttostr(oct)) - 1 ;
  • for i := 0 to n do
  • begin
  • j := inttostr(oct) ;
  • b := strtoint(copy(j,n-i+1,1));
  • if i = 0 then
  • begin
  • res := b ;
  • end
  • else
  • begin
  • result2 := exp(i*ln(8)) * b ;
  • result3 := result3 + result2
  • end;
  • end;
  • result2 := res + result3 ;
  • octdeci := result2;
  • end ;
  • function hexadeci(hexaval : string) : integer;
  • var
  • z : integer;
  • x : integer;
  • v : integer;
  • p : integer;
  • b : variant;
  • h : integer;
  • n : integer;
  • begin
  • x := Length(hexaval);
  • v := x;
  • p := 0;
  • n := 0;
  • b := 0;
  • while v >= 1 do
  • begin
  • z := Ord(hexaval[v]) ; {Je recupere la valeur du charactere pour pouvoir utiliser le Case * of ... j'aurais donc pu directement les convertir en hexa, mais c'est pas le but}
  • Case z of
  • 48 : h := 0 ;
  • 49 : h := 1 ;
  • 50 : h := 2 ;
  • 51 : h := 3 ;
  • 52 : h := 4 ;
  • 53 : h := 5 ;
  • 54 : h := 6 ;
  • 55 : h := 7 ;
  • 56 : h := 8 ;
  • 57 : h := 9 ;
  • 65 : h := 10;
  • 66 : h := 11;
  • 67 : h := 12;
  • 68 : h := 13;
  • 69 : h := 14;
  • 70 : h := 15;
  • End;
  • b := exp(p * ln(16)) * h;
  • p := p + 1;
  • v := v - 1;
  • n := n + b;
  • end;
  • hexadeci := n;
  • end;
function decibinr(decival : integer) : string;
var
i : integer;
j : integer;
h : string;
n : string;

begin
i := decival     ;
while i <> 0 do
begin
j := i mod 2;
i := i div 2;
h := inttostr(j) + h   ;

end;
decibinr := h;
end;

function decioct(decival : integer) : string;
var
j : integer;
h : string;
b : string ;
res : string;
n : integer;
begin
n := decival  ;
while n >= 8 do
begin
j := n mod 8;
n := n div 8;
b := inttostr(j) + b;
end;
b := inttostr(n) + b  ;
decioct := b;
end;

function decihexa(decival : integer) : string;
var
h : string;
res : string;
n : integer;
b : integer;

begin
n := decival;
while n >= 16 do
begin
b := n Mod 16 ;
n := n div 16   ;
CASE b of
        0 : h := '0';
        1 : h := '1';
        2 : h := '2';
        3 : h := '3';
        4 : h := '4';
        5 : h := '5';
        6 : h := '6';
        7 : h := '7';
        8 : h := '8';
        9 : h := '9';
        10 : h := 'A';
        11 : h := 'B';
        12 : h := 'C';
        13 : h := 'D';
        14 : h := 'E';
        15 : h := 'F';
END;
res := h + res;
end;
CASE n of
        0 : h := '0';
        1 : h := '1';
        2 : h := '2';
        3 : h := '3';
        4 : h := '4';
        5 : h := '5';
        6 : h := '6';
        7 : h := '7';
        8 : h := '8';
        9 : h := '9';
        10 : h := 'A';
        11 : h := 'B';
        12 : h := 'C';
        13 : h := 'D';
        14 : h := 'E';
        15 : h := 'F';
END;
 res := h + res ;
 decihexa := res;
 end;

 function bindeci(binval : string) : integer;
 var
i : integer;
res :  variant;
h : string;
bin : string;
begin
bin := binval  ;
 res := 0   ;
for i := 0 to Length(bin)-1 do
begin
h := copy(bin,length(bin)-i,1) ;
if i = 0 then
begin
if h = '1' then res := res + 1  ;
h := '0';
end ;

if h = '1' then res := res + Exp(i*Ln(2))  ;
end ;
 bindeci := res;
end;

function octdeci(octval : integer) : integer;
var
i : integer;
j : string;
h : string;
test : integer;
b : integer;
n : integer;
res : integer;
result2 : variant;
result3 : integer;
oct : integer;

begin
oct := octval;
n := length(inttostr(oct)) - 1 ;
for i := 0 to n do
begin
j := inttostr(oct)  ;
b := strtoint(copy(j,n-i+1,1));
if i = 0 then
begin
res := b  ;
end
else
begin
result2 := exp(i*ln(8)) * b  ;
result3 := result3 + result2
 end;
 end;
 result2 := res + result3 ;
 octdeci := result2;
end ;

function hexadeci(hexaval : string) : integer;
var
z : integer;
x : integer;
v : integer;
p : integer;
b : variant;
h : integer;
n : integer;
begin
x := Length(hexaval);
v := x;
p := 0;
n := 0;
b := 0;
while v >= 1 do
begin
z := Ord(hexaval[v])  ;  {Je recupere la valeur du charactere pour pouvoir utiliser le Case * of ... j'aurais donc pu directement les convertir en hexa, mais c'est pas le but}

 Case z of
 48 : h := 0 ;
 49 : h := 1 ;
 50 : h := 2 ;
 51 : h := 3 ;
 52 : h := 4 ;
 53 : h := 5 ;
 54 : h := 6 ;
 55 : h := 7 ;
 56 : h := 8 ;
 57 : h := 9 ;
 65 : h := 10;
 66 : h := 11;
 67 : h := 12;
 68 : h := 13;
 69 : h := 14;
 70 : h := 15;
End;
b := exp(p * ln(16)) * h;
p := p + 1;
v := v - 1;
n := n + b;
end;
hexadeci := n;
end;  

Conclusion

Je met un zip qui montre comment utiliser les fonctions, et comment empecher la saisie de characteres qui entraineraient une erreur dans les Edit .
Ne ralez pas parcqu'il y a des fichiers inutiles dans le zip, je ne sais pas lesquels ne sont pas necessaires...  
 

Fichier Zip

Pour les "Membres Club", vous pouvez télécharger directement un fichier contenu dans le zip sans télécharger le zip en entier !

Télécharger le zip

Commentaires et avis

signaler à un administrateur
Commentaire de Nono40 le 02/11/2002 13:32:13

Si tes conversions de base 10 à autres sont simples, tes conversions de autres à base 10 sont bien compliquées : utiliser des variants et des exp() juste pour des conversions...
En fait comme tu commence par le poids faible des nombre alors qu'il faut commencer par le poids fort. Ainsi à chaque chiffre l'opération est la même :
Result:=Result*Base+Valeur(ChiffreSuivant);

Voici ce que ça donne pour la base 2 :
function bindeci(binval : string) : integer;
var i : integer;
begin
  result:=0;
  for i := 1 to Length(binval) do Result:=Result*2+Ord(BinVal[i])-Ord('0');
end;

Et vu que pour toutes les bases le calcul est le même, il est préférable de ne faire qu'une seule procédure : ( elle fonctionne pour les bases 2 à 36 )
function basedeci(binval : string;Base:Integer) : integer;
var i : integer;
begin
  result:=0;
  for i := 1 to Length(binval) do
  Case BinVal[i] Of
    '0'..'9':Result:=Result*base+Ord(BinVal[i])-Ord('0');
    'A'..'Z':Result:=Result*base+Ord(BinVal[i])-Ord('A')+10;
  End;
end;

Dans DeciHexa tu met deux fois le case ... Of, une seule fois suffit si turemplace
while n &gt;= 16 do par while n&lt;&gt;0 do ( comme tu as fait pour la base 2 )

Pense aussi à utiliser Result plutôt qu'une variable intermédiaire, ne recopie pas non plus les paramètres dans des variables locales : c'est moins lisible et parfaitement inutile pour la vitesse.

Nono.

signaler à un administrateur
Commentaire de hvb le 02/11/2002 14:22:40

merci tout d'abord à toi d'avoir pris le temps de checker ma source (c'est pratique pour un debutant).
Je pense voir a peu près mes erreurs grace à ton commentaire, (apres un petit temps de reflexion tout de meme ^^ ) .
Tout d'abord je comprends pkoi commencer par le bit de poid fort et non de poid faible, cela m'evitera de checker si c'est le bit le plus faible a chaque fois... ce qui entrainera donc aussi la suppression du case inutile.
Malgré tout ca, il va falloir que je relise plusieurs fois ta ligne "for i := 1 to Length(binval) do Result:=Result*2+Ord(BinVal[i])-Ord('0');" , je ne comprends pas la soustraction du Ord('0') ...
bref je vais de toute facon essayer de tout refaire pour gerer les virgules.
Merci à toi. :)

signaler à un administrateur
Commentaire de Nono40 le 02/11/2002 19:27:37

Le Ord(BinVal[i])-Ord('0') est pour obtenir la valeur de 0 à 9 à partir des caractères ascii '0' à '9'. Comme tu as mis dans ton source la code ascii de '0' est 48 et celui de '9' est 57, on aurai pu écrire Ord(BinVal[i])-48. Mais ceci implique de connaitre la valeur 48. En plaçant Ord('0') le résultat est le même mais il n'y a pas besoin de connaitre la valeur Ascii de '0'.

Pour les virgules, tout dépend du format utilisé pour le stockage. L'un des format connu est le IEEE754 : ( format Single de Delphi )
http://www.blois.univ-tours.fr/~marcel/archi/node53.html
http://lojiax.free.fr/systeme/cours.htm

Nono.

signaler à un administrateur
Commentaire de Jeankiki le 08/11/2002 13:38:59

Tu peux aller voir le composant ci-dessous à l'adresse ci-dessous.
http://www.delphifr.com/article.aspx?Val=1930

signaler à un administrateur
Commentaire de sasah le 06/08/2008 11:55:41

salut! il y a presque tout là mais porrais-tu me donner le code source de la conversion binaire-hexa, j'ai essayé de combiner les fonctions bindeci et decihexa plusieurs fois mais ça n'a pas marché.
Merci!

Ajouter un commentaire



Nos sponsors

Sondage...

CalendriCode

Juillet 2009
LMMJVSD
  12345
6789101112
13141516171819
20212223242526
2728293031  

Consulter la suite du CalendriCode

Comparez les prix Nouvelle version

Photothèque Nouveau !



Développement réalisé par Nicolas SOREL (Nix) avec l'aide de : Cyril DURAND et Emmanuel (EBArtSoft), Merci à Vincent pour ses précieux conseils
CodeS-SourceS.com© Toute reproduction même partielle est interdite sauf accord écrit du Webmaster
CodeS-SourceS.com© est une marque déposée tous droits réservés
Temps d'éxécution de la page : 0,281 sec

Google Coop CodeS-SourceS Google Coop CodeS-SourceS


Certaines images présentes sur le site (notament certains avatars) sont issues des collections IconShock, donc si vous souhaitez utiliser ces icons vous devez les acheter, ne les copiez pas et ne utilisez pas dans vos sites et applications sans les avoir commandé.