CONVERTISSEUR BINAIRE
Renfield
Messages postés
17287
Date d'inscription
mercredi 2 janvier 2002
Statut
Modérateur
Dernière intervention
27 septembre 2021
-
2 janv. 2007 à 12:50
Debiars Messages postés 285 Date d'inscription lundi 16 juin 2003 Statut Membre Dernière intervention 11 février 2018 - 11 janv. 2007 à 16:31
Debiars Messages postés 285 Date d'inscription lundi 16 juin 2003 Statut Membre Dernière intervention 11 février 2018 - 11 janv. 2007 à 16:31
Cette discussion concerne un article du site. Pour la consulter dans son contexte d'origine, cliquez sur le lien ci-dessous.
https://codes-sources.commentcamarche.net/source/40942-convertisseur-binaire
https://codes-sources.commentcamarche.net/source/40942-convertisseur-binaire
11 janv. 2007 à 16:31
11 janv. 2007 à 10:44
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 @+
5 janv. 2007 à 09:58
Tout d'abord, j'ai supprimé les boutons qui ne servaient à rien. On peut très bien cliquer sur un TEdit. J'en ai d'ailleurs rajouté un pour porter le nombre de bits à 16, ce qui correspond à un "word".
On ne crée que la procédure OnClick de Ed0 et on fait pointer les évènements OnClick de Ed1 à 15 sur cette même proc.
Pour le reste, voir les commentaires...
var
PrincipFrm: TPrincipFrm;
tbval : array[0..15] of word;
num : word;
implementation
{$R *.dfm}
procedure TPrincipFrm.FormCreate(Sender: TObject);
var i : byte;
begin // calcul des valeurs des bits
tbval[0] := 1;
for i := 1 to 15 do
tbval[i] := tbval[i-1] * 2;
end;
//-----------------------------------------------------
function TPrincipFrm.Bit(n : byte) : TEdit; // référencer un TEdit à l'aide
begin // de son numéro
Result := FindComponent('Ed'+IntToStr(n)) as TEdit;
end;
// on n'utilise l'évenement OnClick que de Ed0 et on l'affecte aux Ed de 1 à 15
// la propriété Tag de chaque Ed est affectée du numéro de l'Ed pour pouvoir
// l'identifier.
procedure TPrincipFrm.Ed0Click(Sender: TObject);
var i : byte;
c0,c1 : byte;
begin
i := (Sender as TEdit).Tag; // identifier le TEdit cliqué
if Bit(i).Text = '0' then Bit(i).Text := '1' // inverser la valeur du bit
else Bit(i).Text := '0';
num := 0;
for i := 0 to 15 do // calculer la valeur en décimal
if Bit(i).Text = '1' then num := num + tbval[i];
DecEdit.text:=IntToStr(num); // et l'afficher
HexEdit.TexT := IntToHex(num,4); // afficher la valeur en hexadécimal
c0 := Lo(num); // extrait l'octet de poids faible
c1 := Hi(num); // extrait l'octet de poids fort
if c1 > 31 then OctEdit.Text := Chr(c1)
else OctEdit.Text := ' ';
if c0 > 31 then OctEdit.Text := OctEdit.Text+Chr(c0)
else OctEdit.Text := OctEdit.Text+' ';
end;
procedure TPrincipFrm.SpeedButton1Click(Sender: TObject);
begin
Close;
end;
procedure TPrincipFrm.Timer1Timer(Sender: TObject);
begin
DTLabel.Caption := DateTimeTostr(Now);
end;
end.
On peut p'têt fair plus concis, si...
4 janv. 2007 à 13:38
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...
4 janv. 2007 à 12:31
Alors tu vois, il n'y a pas de mal dans ce que je dis.
Moi, je suis toujours heureux d'apprendre de l'autre. Je disais ça pour t'aider à ma façon. Google est un outil sympa aussi avec un peu d'habitude.
La vie est belle!
4 janv. 2007 à 10:27
Mais je suis pas un debutant Jean_Jean
et je sais quesque je fait!!!!!!!!!!!!!
@+
4 janv. 2007 à 09:57
Toujours un plaisir de vous lire!
Quand même Abdousoft, tu aurais pu demander sur le forum avant de publier!
Il y a de bons tutaux en pdf pour apprendre la programmation!
Tu fais par exemple "télécharger cours delphi" ou algorithmique"" sur google.
bon apprentissage!
3 janv. 2007 à 16:10
Expert... et en plus sympa.
Merci
3 janv. 2007 à 14:46
Merci pour les commentaires!
@+
3 janv. 2007 à 14:41
{ 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 ...
3 janv. 2007 à 14:18
3 janv. 2007 à 10:11
Merci pour vos commentaire!!!
mais vraiment je comprend rien?
@+
3 janv. 2007 à 03:06
pour convertir n'importe quoi en chaine binaire :
procedure AllToBinStr(const Buffer; const bSize : integer; var OutBinStr : string);
var S,N : integer;
pR : PChar;
pB : ^byte;
const
DTB : array[0..1] of char = ('0','1');
begin
S := bSize shl 3;
SetLength(OutBinStr, S);
pR := PChar(OutBinStr);
pB := @Buffer;
inc(pB,bSize-1);
for N := 0 to bSize-1 do begin
pR[0] := char(((pB^ shr 7) and $01) or $30);
pR[1] := char(((pB^ shr 6) and $01) or $30);
pR[2] := char(((pB^ shr 5) and $01) or $30);
pR[3] := char(((pB^ shr 4) and $01) or $30);
pR[4] := char(((pB^ shr 3) and $01) or $30);
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);
inc(pR,8);
dec(pB);
end;
end;
a utiliser comme suis :
pour integer, byte, word, int64, array of integer, array of byte, etc
AllToBinStr(Value, SizeOf({TypeValue}), OutStr);
pour chaine de caracteres :
AllToBinStr(PChar(Value), Length(Value), OutStr);
pour convertir n'importe quoi en hexadecimal :
procedure AllToHexStr(const Buffer; const bSize : integer; var OutHexStr : string);
var S,N : integer;
pR : PChar;
pB : ^byte;
const
DIG : array[0..$F] of char = '0123456789ABCDEF';
begin
S := bSize shl 1;
SetLength(OutHexStr, S);
pR := PChar(OutHexStr);
pB := @Buffer;
inc(pB,bSize-1);
for N := 0 to bSize-1 do begin
pR[0] := DIG[pB^ shr 4];
pR[1] := DIG[pB^ and $F];
dec(pB);
inc(pR,2);
end;
end;
a utiliser comme AllToBinStr...
BinStr > entier :
function BinStrToInt(const BinStr : string) : int64;
var N,B : integer;
begin
result := 0;
B := 1;
For N := Length(BinStr) downto 1 do begin
if BinStr[N] = '1' then
inc(result,B);
B := B or B;
end;
end;
HexStr > entier :
function HexStrToDec(const HexStr : PChar; const hLen : integer) : int64;
var N : integer;
B : byte;
pB : ^byte;
begin
B := 0;
pB := @HexStr^;
inc(pB,hLen-1);
result := 0;
for N := hLen-1 downto 0 do begin
case pB^ of
$30..$39 : B := pB^-$30;
$41..$46 : B := pB^-$37;
$61..$66 : B := pB^-$57;
else
exit;
end;
result := result + (B shl (N shl 2));
Dec(pB);
end;
end;
3 janv. 2007 à 02:53
2 janv. 2007 à 19:11
Je suis d'accord avec Francky et White Hippo. Je n'avais pas regardé le code en détail et l'avait simplement exécuté.
Abdousoft va nous la refaire j'espère!
Cordialement
Jean_Jean
2 janv. 2007 à 18:40
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.
2 janv. 2007 à 13:55
Je vais etre dur : c'est codé comme un pied.
Des IF Else à l'infini qui aurait pu et du etre optimisés par un CASE.
Result:=B1+B2+B3+B4+B5+B6+B7+B8+B9+B10+B11+B12+B13+B14+B15 : Heureusement que tu en as pas 500 : Les StringList ne servent à rien ?? ;).
abdousoft : par le passé tes codes étaient corrects mais depuis quelques temps tu prends CS pour ton vide grenier.
L'intéret est en plus discutable
2 janv. 2007 à 12:50