Binärzahlen eingeben.

[BenjaminH]

Hallo,
Hexadezimalzahlen kann man in der IDE ja als$FF eingeben.
Gibt es eine Möglichkeit, um Binärzahlen direkt einzugeben, dass für 16 also im Code 10000 zu lesen ist?
Vielen Dank,
Benjamin

[Luckie]

Nein.

[Aphton]

Das würde ich auch gerne wissen.

Interessant wäre noch die Möglichkeit, Variablen < Byte (so wie in C++) definieren zu können, anstatt mit Bitoperationen rumzufuchteln.

MfG

[Neutral General]

Es gibt indirekt eine Möglichkeit:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var test: Byte;
begin
  asm
    mov [test], 01101011b
  end;
  Caption := IntToStr(test);
end;

[himitsu]

Wenn es in Pascal sein soll, dann kann man (abgesehn von der ASM-Variante) maximal noch Funktionen wie BinToInt verwenden oder Dergleichen.
Die Delphi-Syntax hat da leider nichts zu bieten

[add]

Zitat von Aphton:

Interessant wäre noch die Möglichkeit, Variablen < Byte (so wie in C++) definieren zu können, anstatt mit Bitoperationen rumzufuchteln.

Über einen kleinen Umweg geht auch soetwas ab D2006.
Und vom internen Code her dürfte es wohl auf ein ähnliches Ergebnis kommen, wie in C++.
Halt nur mit ein bischen mehr Arbeit verbunden.

Delphi-Quellcode:

Type
  TDateFields = packed Record
  Private
    _Value: LongInt;
    Function  GetWeekDay:   Byte;  Inline;
    Procedure SetWeekDay(x: Byte); Inline;
    Function  GetDay:       Byte;  Inline;
    Procedure SetDay    (x: Byte); Inline;
    Function  GetMonth:     Byte;  Inline;
    Procedure SetMonth  (x: Byte); Inline;
    Function  GetYear:      Byte;  Inline;
    Procedure SetYear   (x: Byte); Inline;
  Public
    Property Value:    LongInt Read _Value     Write _Value;
    Property WeekDay:  Byte    Read GetWeekDay Write SetWeekDay;
    Property Day:      Byte    Read GetDay     Write SetDay;
    Property Month:    Byte    Read GetMonth   Write SetMonth;
    Property Year:     Byte    Read GetYear    Write SetYear;
  End;

Function TDateFields.GetWeekDay: Byte;
  Begin
    Result := _Value {shr 0} and $07;
  End;

Procedure TDateFields.SetWeekDay(x: Byte);
  Begin
    _Value := (_Value and not $07) or ((x and $07) {shr 0});
  End;

Function TDateFields.GetDay: Byte;
  Begin
    Result := _Value shr 3 and $31;
  End;

Procedure TDateFields.SetDay(x: Byte);
  Begin
    _Value := (_Value and not $31) or ((x and $31) shr 3);
  End;

Function TDateFields.GetMonth: Byte;
  Begin
    Result := _Value shr 9 and $15;
  End;

Procedure TDateFields.SetMonth(x: Byte);
  Begin
    _Value := (_Value and not $15) or ((x and $15) shr 9);
  End;

Function TDateFields.GetYear: Byte;
  Begin
    Result := _Value shr 14 {and $255};
  End;

Procedure TDateFields.SetYear(x: Byte);
  Begin
    _Value := (_Value and not $255) or ((x {and $255}) shr 14);
  End;

Aber eigentlich wäre soetwas doch eine gute erweiterung für Delphi?
So als neue Syntax für die Property

Property Day: Byte Read _Value : 3 : 5 Write _Value : 3 : 5; oder irgendwie so (Variable : ab welchem Bit : für vieviele Bits)

[Aphton]

Gibts ne Möglichkeit, Embarcadero oder halt den Zuständigen das vorzuschlagen?

Delphi-Quellcode:

  TBitFields = record
    case Boolean of
      False: ( x0, x1, x2, x3, x4, x5, x6, x7: Byte:1; ); // all diese Elemente besetzen nur 1 Bit
      True:  ( x: Byte );
    end;

[alzaimar]

Zitat von Aphton:

Gibts ne Möglichkeit, Embarcadero oder halt den Zuständigen das vorzuschlagen?

Delphi-Quellcode:

  TBitFields = record
    case Boolean of
      False: ( x0, x1, x2, x3, x4, x5, x6, x7: Byte:1; ); // all diese Elemente besetzen nur 1 Bit
      True:  ( x: Byte );
    end;

Früher ging das mit

Delphi-Quellcode:

  TBitFields = packed record
    case Boolean of
      False: ( x0, x1, x2, x3, x4, x5, x6, x7: Boolean); 
      True:  ( x: Byte );
    end;

heute nicht mehr. Der Grund ist einfach der, das die gepackte Darstellung kaum noch gebraucht wird, performancetechnisch einfach grauenhaft ist und das genaue Packverfahren, sowie die Reihenfolge im Speicher nicht immer klar definiert ist. Auf Bitebene sollte das zwar klar sein, aber schon bei Bytes verhält sich eine Intel-CPU anders als eine Motorola: Der gleiche Code würde auf einer anderen CPU zu anderen Ergebnissen führen, weil die Bytes vertauscht sind: Der Code ist nicht mehr deterministisch und damit unbrauchbar.

Besser (und vom Verständnis her sinnvoller) ist es doch, das Kodieren in einzelne Bits explizit selbst zu übernehmen. So schwer ist das doch nicht, und wurde hier schon exemplarisch erklärt.

Zudem sollte eine Kodierung nicht Bestandteil der Deklaration sein. Passt irgendwie nicht.

[himitsu]

Zitat von alzaimar:

Früher ging das mit

Delphi-Quellcode:

  TBitFields = packed record
    case Boolean of
      False: ( x0, x1, x2, x3, x4, x5, x6, x7: Boolean); 
      True:  ( x: Byte );
    end;

sicher?
Boolean = 1 Byte (nicht 1 Bit)


Mindestens seit D4 hab ich da andere Erfahrungen.

[Neutral General]

Also ich bin mir ziemlich sicher, dass das noch nie funktioniert hat.