0b0111 in Delphi-Sprache

[Christian Seehase]

Moin Daniel,

Zitat:

Zitat von Daniel B

Einigen wir uns darauf das es die in Delphi 7 und sehr warscheinlich auch in Delphi 6 und nicht in Delphi 5 gibt?

Können wir machen.

Spider hat, wie in seinem Profil angegeben D5...

Jetzt kommst Du wieder :mrgreen:

[himitsu]

Hi StTüff,
hiermit kannst'e dir 'ne Unit mit einigen binären Konstanten erstellen:

Einfach die entstehende Unit in dein Projekt einbinden und schon hast du Konstanten in der Form Bxxxx, Bxxxxxxxx, Bxxxx_xxxx u.v.m. (x = 0 oder 1)


Add: Ich wollte nur noch sagen, das diese Units nicht komplett ins Projekt übernommen werden.
Ob man nun direkt $0F schreibt oder B00001111 aus der Unit nimmt, macht keine Unterschied in der Größe der EXE, da der Compiler statt B00001111 den entsprechenden Wert schreibt.

Update: BinConstX.dpr

[scp]

Eine Alternative:

Delphi-Quellcode:

function ByteToBinWord(AByte : Byte) : LongWord;
begin
  result := AByte and $01;

  result := result + (((AByte shr 1) and $01) *       10);
  result := result + (((AByte shr 2) and $01) *      100);
  result := result + (((AByte shr 3) and $01) *     1000);
  result := result + (((AByte shr 4) and $01) *    10000);
  result := result + (((AByte shr 5) and $01) *   100000);
  result := result + (((AByte shr 6) and $01) *  1000000);
  result := result + (((AByte shr 7) and $01) * 10000000);
end;

function BinWordToByte(ABinWord : LongWord) : Byte;
begin
  result := 0;
  result := result + ((ABinWord div 10000000) shl 7); ABinWord := ABinWord mod 10000000;
  result := result + ((ABinWord div  1000000) shl 6); ABinWord := ABinWord mod  1000000;
  result := result + ((ABinWord div   100000) shl 5); ABinWord := ABinWord mod   100000;
  result := result + ((ABinWord div    10000) shl 4); ABinWord := ABinWord mod    10000;
  result := result + ((ABinWord div     1000) shl 3); ABinWord := ABinWord mod     1000;
  result := result + ((ABinWord div      100) shl 2); ABinWord := ABinWord mod      100;
  result := result + ((ABinWord div       10) shl 1); ABinWord := ABinWord mod       10;
  result := result + ABinWord;
end;

function ByteToBinStr(AByte : Byte) : String;
begin
  result := IntToStr(ByteToBinWord(AByte));
  while (length(Result) < 8) do
    result := '0' + result;
end;

function BinStrToByte(ABinStr : String) : Byte;
begin
  result := BinWordToByte(StrToIntDef(ABinStr, 0));
end;

So kann man 8 Nullen und Einsen in einen LongWord packen und wieder als Byte oder String zurückholen.

[Daniel B]

Zeifx nochmal. :mrgreen:
Kauft Euch mal ein anständiges Delphi. :lol:

Das ist immer das gleiche mit dem D5, da fehlt ja die hälfte, wie kann man nru noch damit arbeiten!? D6 sollte mal langsam schon drin sein. ;)

Aber was solls, Du hattest was D5 angeht recht und somit gibst Du einen aus. :tongue:

[himitsu]

@Daniel B er will das ja im QuellCode zur besseren lesbarkeit nutzen.

BinToHex hilft hier ja nichts, er müsste ja sonst sowas wie BinToHex('1001010010', Hex) und dann noch HexToInt(Hex, Int) machen. Damit wird der QuellCode ja nicht gerade besser lesbarer. :mrgreen:

Delphi-Quellcode:

(* Von Vorhin: *)
I := Bxxxx;               {jeweils mit fester Bit-Anzahl}
I := Bxxxxxxxx;           {4/8/16/32 Bit's}
I := Bxxxxxxxxxxxxxxxx;
I := Bxxxxxxxx_xxxxxxxx;
...
{ist der schnellte Weg - das Programm wird nicht langsamer, da keine zusätzlichen Routinen zur dekodierung eingebunden werden}

(* Mit Code 1 (siehe unten): *)
I := B(xxx);                    {1 - 10 Bit's}

(* Mit Code 2 (siehe unten): *)
I := B('xxx');                  {1 - 32 Bit's}

Delphi-Quellcode:

(* Code 1 *)
Function B(I: LongWord): Word;
  Var A: Word;

  Begin
    Result := $00;
    A := $01;
    While I > 0 do Begin
      If I mod 10 > 0 Then Result := Result or A;
      I := I div 10;
      A := A shl 1;
    End;
  End;

(* Code 2 *)
Function B(I: String): LongWord;
  Begin
    Result := $0000;
    While I > '' do Begin
      Result := Result shl 1;
      If I[1] <> '0' Then Result := Result or $0001;
      Delete(I, 1, 1);
    End;
  End;

Diese Routinen sind so geschrieben, das sie auch bei Fehleingaben (keine Binärwerte) ohne Exception durchlaufen. Sie reagieren auf Bit = '0' > 0 und Bit <> '0' > 1. Im Code 2 kommt es zum Überlauf (falscher Wert wird zurückgegen), wenn mehr als 32 Bit übergeben werden.

Es besteht noch die Möglichkeit "Code 2" so zu erweitern, das man auch Trennzeichen zur noch besseren lesbarkeit im Binärwert verwenden kann.
z.B.:

Delphi-Quellcode:

I := B('xxxx xx xx');

Delphi-Quellcode:

(* Code 2 - erweitert *)
Function B(I: String): LongWord;
  Begin
    Result := $0000;
    While I > '' do Begin
      If I[1] <> ' '{Trennzeichen} Then Begin
        Result := Result shl 1;
        If I[1] <> '0' Then Result := Result or $0001;
      End;
      Delete(I, 1, 1);
    End;
  End;

Und wenn jetzt noch diese Routinen überladen werden, können beide Parallel genutzt werden.

Delphi-Quellcode:

(* Code 1 *)
Function B(I: LongWord): Word; overload;
  Var A: Word;

  Begin
    Result := $00;
    A := $01;
    While I > 0 do Begin
      If I mod 10 > 0 Then Result := Result or A;
      I := I div 10;
      A := A shl 1;
    End;
  End;

(* Code 2 - erweitert *)
Function B(I: String): LongWord; overload;
  Begin
    Result := $0000;
    While I > '' do Begin
      If I[1] <> ' '{Trennzeichen} Then Begin
        Result := Result shl 1;
        If I[1] <> '0' Then Result := Result or $0001;
      End;
      Delete(I, 1, 1);
    End;
  End;