Convertisseur 36 formats - decimal - octal - ... : version tools

Soyez le premier à donner votre avis sur cette source.

Vue 13 433 fois - Téléchargée 734 fois

Description

Récemment un delphiste a fait un programme similaire & j'ai voulu poursuivre le projet. Pour cela j'ai fortement simplifié l'ancien projet & j'ai mis une possibilité de convertir dans 36 formats ( 2 --> 36 )
Ex : 65 en Decimal donnera '1T' en base 36 ou 41 en HexaDecimal.
Voilà je pense qu'il est complet sauf qu'il ne dispose pas de gestion d'erreurs ( saisie, ... ).

Source / Exemple :


Projet in the zip

Unité UlpBase : unité pour la convertion
-----------------

unit UlpBase;

interface

uses Sysutils,
     UlpString;

const MinBase = 2;
const MaxBase = 36;

Const Binaire = 2;
Const Octal = 8;
Const Decimal = 10;
Const HexaDecimal = 16;

type
    ClpBase = Class
    private
          function GetPoidsFort(lwNbr:LongWord; bBase:Byte):Byte;
          function GetMultiple(bBase, bExpo:Byte):LongWord;
          function GetChiffre(chrLettre:Char):Byte;
          function SetChiffre(bLettre:Byte):string;
    public
          // Other --> 10
          function BaseDix(strNbr:string; bBase:Byte):string;
          // 10 --> Other
          function BaseOther(lwNbr:LongWord; bBase:Byte):string;
          // Other --> Other
          function BasesConvert(strNbr:string; bBaseOld, bBaseNew:Byte):string;
    end;

implementation

/////////////////////////////////////
//            PRIVATE              //
/////////////////////////////////////

function ClpBase.GetPoidsFort(lwNbr:LongWord; bBase:Byte):Byte;
var bPF:Byte;
begin
     bPF := 1;
     While( lwNbr > bBase) do
     begin
          lwNbr := (lwNbr div bBase);
          Inc(bPF);
     end;
     Result := bPF;
end;

function ClpBase.GetMultiple(bBase, bExpo:Byte):LongWord;
var lwRes:LongWord;
begin
     lwRes := 1;
     While(bExpo > 0)do
     begin
          lwRes := (lwRes * bBase);
          Dec(bExpo);
     end;
     Result := lwRes;
end;

function ClpBase.GetChiffre(chrLettre:Char):Byte;
var bRes:Byte;
begin
     case ( Ord(chrLettre) - 48) of
     0..9:bRes := Ord(chrLettre) - 48;
     else
         bRes := Ord(chrLettre) + 10 - 65;
     end;
     Result := bRes;
end;

function ClpBase.SetChiffre(bLettre:Byte):string;
var strRes:string;
begin
     case bLettre of
     0..9:strRes := IntToStr(bLettre);
     else
         strRes := Chr(65 + bLettre - 10);
     end;
     Result := strRes;
end;

/////////////////////////////////////
//            PUBLIC               //
/////////////////////////////////////

function ClpBase.BaseDix(strNbr:string; bBase:Byte):string;
var bPF, bPos:Byte;
    strRes:string;
begin
     strRes := '0';
     bPF := UlpString.LenStr(StrNbr);
     bPos := 0;
     While(bPF > bPos)do
     begin
          Inc(bPos);
          strRes := IntToStr(StrToInt(strRes) + ( GetChiffre(strNbr[bPF - bPos + 1]) * GetMultiple(bBase, (bPos - 1)) ));
     end;
     Result := strRes;
end;

function ClpBase.BaseOther(lwNbr:LongWord; bBase:Byte):string;
var bPF, bIndex:Byte;
    strRes:string;
    Passe:Boolean;
begin
     strRes := '';
     Passe := False;
     bPF := GetPoidsFort(lwNbr, bBase);
     while (bPF > 0) do
     begin
          Passe := True;
          bIndex := (lwNbr div GetMultiple(bBase, bPF));
          lwNbr := lwNbr - ( bIndex * GetMultiple(bBase, bPF));
          strRes := strRes + SetChiffre(bIndex);
          Dec(bPF);
     end;
     if Passe then
        strRes := strRes + SetChiffre(lwNbr);
     if strRes[1] = '0' then
        strRes := UlpString.DecalLeft(strRes, 1);
     Result := strRes;
end;

function ClpBase.BasesConvert(strNbr:string; bBaseOld, bBaseNew:Byte):string;
var strRes:string;
    lwRes:LongWord;
begin
     strRes := BaseDix(strNbr, bBaseOld);
     lwRes := StrToInt(strRes);
     strRes := BaseOther(lwRes, bBaseNew);
     Result := strRes;
end;

end.

Conclusion :


Je vous prépare le doc sur la façon dont le programme fonctionne d'ici peu.

PS: dans le projet, il y a deux points :
UConvertisseur gère l'interface de la fenêtre
UlpBase gère la conversion d'une base à l'autre. C'est le plus important.
Vous y trouverez les trois fonctions principales :
// Other --> 10
function BaseDix(strNbr:string; bBase:Byte):string;
// 10 --> Other
function BaseOther(lwNbr:LongWord; bBase:Byte):string;
// Other --> Other
function BasesConvert(strNbr:string; bBaseOld, bBaseNew:Byte):string;

Le seul bug apparant, est la conversion de nombre relativement grand dûe à l'utilisation de StrToInt & IntToStr.

Toute critique ou/et suggestion est toujours la bienvenue.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
4
Date d'inscription
lundi 30 décembre 2002
Statut
Membre
Dernière intervention
10 septembre 2007

Bonjour.

Votre petit programme est très intéressant ...

Pourriez vous ajouter la possiblité pour le code Gray ( ou binaire réfléchi ) ?.

Merci.

Et encore félicitations pour votre travail et votre contribution sur delphifr.
Messages postés
962
Date d'inscription
mercredi 3 avril 2002
Statut
Membre
Dernière intervention
12 septembre 2006
1
Deux petites remarques générales pour commencer :
- n'utilise pas le type byte tant que ce n'est pas strictement utile. Ils occupe de toute façon 4 octects en mémoire du à l'alignement. De plus le calcul est plus long avec 8bits qu'avec 32Bits ( le format natif des processeurs est le 32Bits )
- Utilise directement Result comme variable temporaire, c'est plus clair que d'utiliser une autre variable ( comme strRes par exempl )

Heureusement que tu as dit que tu avais simplifier la procédure... J'avais mis en commentaire sur le source que tu cites, une conversion plus simple. La voici adpatée à ton source :
function ClpBase.BaseDix(strNbr:string; bBase:Integer):string;
var Valeur,I:Integer;
begin
Valeur:=0;
For i:=1 To Length(strNbr) Do Valeur:=Valeur*bBase+ GetChiffre(strNbr[i]);
Result := IntToStr(Valeur);
end;

function ClpBase.BaseOther(lwNbr:LongWord; bBase:Byte):string;
var bIndex:Byte;
begin
Result := '';
Repeat
Result:=SetChiffre(lwNbr Mod bBase)+Result;
lwNbr:=lwNbr Div bBase;
Until lwNbr=0;
end;

Nono.

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.