0b0111 in Delphi-Sprache

[StTüff]

Hallo zusammen!

Ich habe eine Frage, die bestimmt schon oft gestellt wurde. Ich
habe aber leider bei meiner Suche nichts gefunden.

Vielleicht erbarmt sich einer einem blöden C-Menschen und sagt mir,
wie ich eine binäre Konstante in Delphi angebe.

Beispiel:

"0b011" in C wird in Delphi so "?" geschrieben.

Bei Hex-Darstellung ist das einfach.
Beispiel: $0F2.

Gibt es da nichts für die binäre Darstellung? Muss ich alles in
Hex-Schreibweise angeben?

Vielleicht kann mir einer die Augen öffnen.

Vielen Dank!

StTüff

[Daniel B]

Ascii wär noch mit #xxx möglich

[StTüff]

Das mit ASCII kenn ich schon. Trotzdem besten Dank.
Naja, ich kanns natürlich auch als HEX angeben.
Binär wär's halt übersichtlicher.

Gruß,

StTüff

[Chewie]

Leider geht das in Pascal nicht so direkt. Du musst auf dezimal oder hexadezimal ausweichen.

[X-Dragon]

Zitat:

Zitat von StTüff

Das mit ASCII kenn ich schon. Trotzdem besten Dank.
Naja, ich kanns natürlich auch als HEX angeben.
Binär wär's halt übersichtlicher.

Gruß,

StTüff

Kannst ja einfach mal deine Hex-Werte umwandeln und schauen in welchem Format er das ausgibt "HexToBin".

[StTüff]

OK! Vielen Dank!

Das hatte ich schon vermutet, ich wollte mich nur noch mal
versichern.

Bis bals,

StTüff

[Robert Marquardt]

Wer binaer nach hex nicht fluessig im Kopf umrechnen kann der muss noch viel lernen.

[Robert Marquardt]

Sei froh. C kann oktal (037 z. B. ist 0x1F) und 08 und 09 sind gueltige Oktalangaben!

[StTüff]

@Robert Marquart

Es geht nicht um das Umrechnen. Dazu bin ich lange genug Softwareentwickler,
um das zu können. Es geht aber darum, wie gut der Code lesbar ist. Bei einem
Status, bei dem Bits an bestimmten Positionen gestzt werden, ist ein $2A einfach
unübersichtlicher als ein 101010. Ich kann das aber auch mit Konstanten lösen.

Danke noch mal an alle für die Beiträge.

StTüff

[Die Muhkuh]

Mein Gott, jetzt muss ich mal etwas Peinliches fragen :oops:

Wie bekomm ich den die Hex raus? Ich mein sowas wie strtohex gibt's ja net!

[Daniel B]

HexToBin - BinToHex

[Delphianer]

@Spider,

versuchs mal mit Format.

Viele Grüße

[Die Muhkuh]

T H X!

[Die Muhkuh]

Naja geht irngedwie nicht aber ist ja auch egal

[Daniel B]

Zitat:

Zitat von Spider

Naja geht irngedwie nicht aber ist ja auch egal

*am boden lieg und tränen lach* :lol:

[Die Muhkuh]

Zitat:

Zitat von Daniel B

Zitat:

Zitat von Spider

Naja geht irngedwie nicht aber ist ja auch egal

*am boden lieg und tränen lach* :lol:

Woher soll ich das auch wissen? Hab mich noch nie damit beschäftigt! Kannst mir ja erklären!

[Daniel B]

Du fauler ************************************ :lol:
Du machst jetzt gefälligst die OH auf und suchst nach HexToBin und umgekehrt!!

[Christian Seehase]

Moin Daniel,

ich weiss nicht wirklich, worüber Du Dich so amüsierst.
Die beiden Funktionen gibt es nicht ;-)

Wir hatten hier schon mal etwas in der Richtung, also könnte die Suche im Forum nach BinToHex bzw. HexToBin was bringen.

[Daniel B]

Moin Christian,

Zitat:

Zitat von Christian Seehase

Die beiden Funktionen gibt es nicht ;-)

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

[Daniel B]

Um genau zu sein:

Zitat:

Die Prozedur konvertiert einen binären Wert in seine hexadezimale Entsprechung.

Unit

Classes

Kategorie

Typumwandlung

Delphi-Syntax:

procedure BinToHex(Buffer, Text: PChar; BufSize: Integer);

C++ Syntax:

extern PACKAGE void __fastcall BinToHex(char *Buffer, char *Text, int BufSize);

Beschreibung

Mit BinToHex können Sie den in einem Puffer enthaltenen Binärwert in einen String konvertieren, der den Hexadezimalwert darstellt.

Buffer ist der Byte-Puffer, der den Binärwert enthält.

Text gibt einen nullterminierten String zurück, der den in Buffer übergebenen Wert als Hexadezimalzahl darstellt.

BufSize legt die Größe von Buffer fest. Text muss auf eine Zeichenfolge zeigen, die mindestens 2*BufSize-Byte groß ist, da jedes Hexadezimalzeichen zwei Bytes darstellt.

Zitat:

Die Funktion konvertiert einen String mit Hexadezimalzeichen in den entsprechenden Binärwert.

Unit

Classes

Kategorie

Typumwandlung

Delphi-Syntax:

function HexToBin(Text, Buffer: PChar; BufSize: Integer): Integer

C++ Syntax:

extern PACKAGE int __fastcall HexToBin(char *Text, char *Buffer, int BufSize);

Beschreibung

Mit HexToBin können Sie den Hexadezimal-String Text in den entsprechenden Binärwert umwandeln.

Text ist die String-Darstellung eines Hexadezimalwertes.

Buffer gibt den Wert in der binären Darstellung zurück.

BufSize legt die Größe von Buffer fest. Text muss auf Hexadezimalzeichen mit mindestens 2*BufSize zeigen, das jedes Hexadezimalzeichen ein Byte repräsentiert.

HexToBin gibt die Anzahl der Zeichen in Buffer zurück, die nicht verwendet wurden, das Text keine gültigen Hexadezimalzeichen enthalten hat ('0'..'f')..

Hinweis: Die Hexadezimalzahl muss Zeichen in Kleinschreibung enthalten, da HexToBind keine Zeichen in Großschreibung erkennt.

[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;