CONVERTISSEUR BINAIRE

Commentaire de Jean_Jean le 02/01/2007 13:14:23

Bj Abdousoft,

Ton code est utile et réussi.
RenField, Math de delphi comprend des fonctions de conversions, mais pas celle-ci.

Par contre, Maths de jlmcom est une source de plusieurs fonctions utiles dans ce sens me semble t-il:
http://www.delphifr.com/codes/PETITE-LIBRAIRIE-MATHS-VERSION_25181.aspx

Bonne Prog 2007

Commentaire de WhiteHippo le 02/01/2007 18:40:07

Bonsoir

Je ne vois pas non plus l'intérêt d'un tel code, du moins écrit ainsi...

Avec un peu de réflexion, et si on a quelques connaissances, on arrive facilement à écrire une fonction de conversion vers n'importe laquelle des bases ( base 2 = binaire, base 8 = octal, base 10 = décimal, base 16 = héxadécimal, etc... )

function CardinalToBase( Valeur : Cardinal ; base : Byte ) : string ;
const
  CHIFFRES : array [0..15] of char = '0123456789ABCDEF';
var
  i, Reste : Cardinal ;
begin
  if ( base < 2 ) or ( base > 16 ) then base := 10 ;
  Result := '' ;
  while ( Valeur <> 0 ) do
  begin
    Reste  := Valeur mod base ;
    Valeur := Valeur div base ;
    Result := CHIFFRES[ Reste ] + Result ;
  end;
end;

Et la fonction de conversion du binaire, me direz vous :

function BinToCardinal ( ChaineBinaire : string ) : Cardinal ;
var
  i, L, poids : Cardinal ;
begin
  L := Length (ChaineBinaire) ;
  if ( L>32 ) then Exit ;
  Poids := 1 ;
  Result := 0 ;
  for i := L downto 1 do
  begin
    Result := Result + ( Ord(ChaineBinaire[i]) - Ord('0') ) * Poids ;
    Poids := Poids * 2 ;
  end ;
end ;

Il ne reste plus qu'à appeler le tout :

  Base8  := CardinalToBase( BinToCardinal ( '11000011010100000' ),  8 ) ; // Base8 = '303240'
  Base10 := CardinalToBase( BinToCardinal ( '11000011010100000' ), 10 ) ; // Base10 = '100000'
  Base16 := CardinalToBase( BinToCardinal ( '11000011010100000' ), 16 ) ; // Base16 = '186A0'

  Base2  := CardinalToBase( BinToCardinal ( '11000011010100000' ),  2 ) ; // idem ;)
  Base5  := CardinalToBase( BinToCardinal ( '11000011010100000' ),  5 ) ; // Base5 = '11200000'

N.B. On aurait également pu écrire une fonction BaseToCardinal, traité les nombres signés, etc...

Cordialement.  

Commentaire de N_M_B le 03/01/2007 02:53:11

et voila comment on se fait remonter les bretelles sur CS lol

Commentaire de abdousoft le 03/01/2007 10:11:27

Salut
Merci pour vos commentaire!!!
mais vraiment je comprend rien?
@+

Commentaire de f0xi le 03/01/2007 14:41:03 administrateur CS

procedure AllToBinStr(const Buffer; const bSize : integer; var OutBinStr : string);

{ Buffer est une variable non typée, on peu donc y placer n'importe qu'elle donnée, chiffre, texte, structure ect...
bSize est la taille en octet de Buffer, elle s'obtient grace a SizeOf() ou Length(), OutBinStr est la chaine de sortie du resultat de la convertion.

var S,N : integer;
    pR  : PChar;
    pB  : ^byte;
{ S permet de calculer la taille finale de OutBinStr (bSize*8)
  N sert a la boucle for,
  pR est un pointeur sur Char pour OutBinStr (equivalent a un array of char a peu prés)
  pB est un pointeur sur Byte (octet) pour Buffer
}
begin
  { on calcul la taille finale de OutBinStr
    shl 3 = *8 }
  S := bSize shl 3;
  { on definit la taille de OutBinStr }
  SetLength(OutBinStr, S);
  { on pointe pR sur OutBinStr }
  pR := PChar(OutBinStr);
  { on pointe pB sur Buffer }
  pB := @Buffer;
  { on se positionne a la fin du buffer car on lit de droite a gauche }
  inc(pB,bSize-1);
  
  { on entre dans la boucle 0..bSize-1 }
  for N := 0 to bSize-1 do begin
      { ici on recupere chaque bit de l'octet en cours (pB^) }
      pR[0] := char(((pB^ shr 7) and $01) or $30); {10000000 bit 8}
      pR[1] := char(((pB^ shr 6) and $01) or $30); {01000000 bit 7}
      pR[2] := char(((pB^ shr 5) and $01) or $30); {00100000 bit 6}
      pR[3] := char(((pB^ shr 4) and $01) or $30); {00010000 bit 5}
      pR[4] := char(((pB^ shr 3) and $01) or $30); { etc }
      pR[5] := char(((pB^ shr 2) and $01) or $30);
      pR[6] := char(((pB^ shr 1) and $01) or $30);
      pR[7] := char((pB^ and $01) or $30);
      { shr decale les bits vers la droite, and $01 applique un masque sur le bit si il est egale a 1 on retrouve 1 si est a zero on retrouve 0, or $30 ajoute 48 a la valeur 0 ou 1 pour retrouver le caractere ascii 0 ou 1 ($30 et $31), enfin Char(...) convertir ce chiffre en caractere }
      { on decale le pointeur pR de 8 octet vers la droite }
      inc(pR,8);
      { on decale le pointeur pB de 1 octet vers la gauche }
      dec(pB);
  end;
end;




procedure AllToHexStr(const Buffer; const bSize : integer; var OutHexStr : string);
{ voir AllToBinStr pour l'explication de l'entete de procedure }

var S,N : integer;
    pR : PChar;
    pB : ^byte;
{ idem }

const
    DIG : array[0..$F] of char = '0123456789ABCDEF';
{ DIG permet de recuperer directement le caractere selon la valeur du mots de 4 bits (0..F) qu'on lui transmet }

begin
  { ici le rapport de S est de *2 (shl 1) pour la taille finale de OutHexStr }
  S := bSize shl 1;

  { pas besoin d'expliquer la suite }
  SetLength(OutHexStr, S);
  pR := PChar(OutHexStr);
  pB := @Buffer;
  inc(pB,bSize-1);

  for N := 0 to bSize-1 do begin
      { pB^ shr 4 permet de recuperer les 4 bits de poids fort de l'octet : F0 }
      pR[0] := DIG[pB^ shr 4];
      { pB^ and $F permet de recuperer les 4 bits de poids faible de l'octet : 0F }
      pR[1] := DIG[pB^ and $F];

      { decalage des pointeur }    
      inc(pR,2);
      dec(pB);
  end;
end;

pour comprendre un peu :

1 octet = 1 char = 1 byte = 2 caracteres hexa = 8 caracteres binaire


function BinStrToInt(const BinStr : string) : int64;
{ BinStr est une chaine representant un mots binaire d'une taille maximale de 64 bits !}

var N,B : integer;
begin
  { initialisation }
  result := 0;
  B := 1; { le premier est a 1 }
  For N := Length(BinStr) downto 1 do begin
      { si le caractere a la position N est egal a 1 }
      if BinStr[N] = '1' then
         { alors on additionne Result avec la valeur courrante de B }
         result := result + B;
      { a chaque passage on additionne B avec lui meme }
      B := B or B;
      { B = 1 }
      { B = 1 + 1 = 2  }
      { B = 2 + 2 = 4  }
      { B = 4 + 4 = 8  }
      { B = 8 + 8 = 16 }
      { B = 16+16 = 32 }
      { etc }
      { on pourrait egalement faire B = B shl 1 a chaque passage mais or est plus rapide que shl }
  end;
end;


voila ...

Commentaire de Caribensila le 03/01/2007 16:10:56

S'il n'existait pas, il faudrait l'inventer, ce fOxi! :))
Expert... et en plus sympa.

Merci

Commentaire de abdousoft le 04/01/2007 10:27:04

salut

Mais je suis pas un debutant Jean_Jean  
et je sais quesque je fait!!!!!!!!!!!!!


@+

Commentaire de f0xi le 04/01/2007 13:38:12 administrateur CS

ouai tu as debutant et debutant ... comme le dit jean_jean, on est tous plus ou moins debutant mais avec un certains niveau technique derriere.

on peu trés bien faire des programmes aboutis, lourd, techniquement pauvre, mais qui marche ... mais ça fait pas de nous un "pur pro" de delphi.

meme moi je me considere pas comme un pro ou un expert mais plus comme un amateur avertis avec un bon niveau technique.
aprés, y'a toujours pleins de truc qu'on ne sait pas faire et sur lequels on rame car ... on y comprend que dalle.

aprés c'est comme tout, y'a une difference entre la technique et l'experience tout comme la theorie et la pratique.

mais comme disaient mes profs de math, le resultat importe peu, c'est comment on arrive a ce resultat qui est important.

meme si le resultat est bon, quand on applique une methode pourrie le resultat est pourrie egalement. c'est comme en cuisine, si tu fait des crepe en dosant n'importe comment en mettant les oeuf avec la coquille et en vidant la bouteille de grand-margnier dedans, le tout dans un gros mixer ... y'a des chance pour que tes crepes soit foireuses et que les gens qui les mangent finissent aux urgences...

Commentaire de abdousoft le 11/01/2007 10:44:01

Salut
mr Debiars , je te dit que j'ai debuter avec ce simple programme, parceque je suis en cours d'apprendre le ASM c'est tout, et pour moi j'ai fait un grand travail.
Merci pour tes commentaires. c'est tres gentille a la prt de vous et de l'ami Foxi.

c'est vrai nous somme tous des debutnts.
Merci @+