Schneller Zugriff auf Bits

[Dust Signs]

Hi :)!

In C kann man sehr "schön" über "Array"-Klammern [] auf die einzelnen Bits eines Integers zugreifen. Mich würde interessieren, ob es sowas änhliches auch in Delphi gibt...

Dust Signs

[SirThornberry]

Nein, du musst dir selbst eine funktion schreiben um herauszufinden ob ein bit gesetzt ist (bzw. die suche nutzen, da gibts genug beispiele). In C wird intern vermutlich auch nix anderes gemacht

[maynard]

mhmm ... Operatoren überladen, feine Sache... leider nicht in Delphi bzw. Delphi Language

[Robert_G]

mit einem set (also einer Menge/Bitfeld) sollte es gehen:

Delphi-Quellcode:

type TAlleBitsEinenIntegers = set of 0..32;
   PAlleBitsEinesIntegers = ^TAlleBitsEinenIntegers;

var
   AlleBitsEinenIntegers: TAlleBitsEinenIntegers;
   EinInteger, i: Integer;
   Output: String[32];
begin
   EinInteger := 4294967295;
   AlleBitsEinenIntegers := PAlleBitsEinesIntegers(@EinInteger)^;
   FillChar(Output, 32, '0');

   for i := 32 downto 1 do
      if pred(i) in AlleBitsEinenIntegers then
         Output[32 - i] := '1';

   Writeln(Output);
   Sleep(2000);
end.

Ist vielelicht etwas umständlich, aber ich arbiete eigentlich nie mit Pointern oder primitiven Typen. ;)

Output

1111111111111111111111111111111

Edit: Habe aus der vertikalen Darstellung ein Füllen eines String[32] gemacht.

[JasonDX]

Auf die einzelnen Bits eines Integer würde ich mit Shiften zugreifen

Delphi-Quellcode:

a[i]
//wird dann
(a and (1 shl i))

//Bit Setzen
a := (a or (1 shl i));

//Bit Toggeln
a := (a xor (1 shl i));

Edit: Korrigiert *gg*

[Robert Marquardt]

Zitat:

Zitat von Dust Signs

In C kann man sehr "schön" über "Array"-Klammern [] auf die einzelnen Bits eines Integers zugreifen.

Das ist mir neu. Das geht hoechstens in C++.
Was man in C machen kann ist ein struct (record) mit Bitfeldern als Elementen.

[Oxmyx]

In Delphi kann man weder den []-Operator überladen, noch kann man Bitfelder erstellen. Also bleibt dir nur eine Funktion übrig, die das erledigt.

[Dust Signs]

Zitat:

Zitat von Oxmyx

In Delphi kann man weder den []-Operator überladen, noch kann man Bitfelder erstellen. Also bleibt dir nur eine Funktion übrig, die das erledigt.

Mit Funktion is das aber extrem langsam. Ich denk da an Dinge wie digitale Suche bzw. Digitales Sortieren

Dust Signs

[Robert Marquardt]

Na dann eben Inlining betreiben.

Delphi-Quellcode:

const
  BitMask: array [0..31] of Cardinal =
   ($00000001, $00000002, $00000004, $00000008,
    // den Rest mach selber
    );

begin
  // Bit testen
  if (Value and BitMask[Index]) <> 0 then
  // Bit Setzen
  Value := Value or BitMask[Index];
  // Bit ruecksetzen
  Value := Value and not BitMask[Index];

[negaH]

Delphi-Quellcode:

type
  IBitSet = Interface
    ... bla bla
  end;

  TBitSet = class(TInterfacedObject)
  ... bla bla
  public
    property Bit[Index: Integer]: Boolean read GetBit write SetBit; default; 
  end;

function BitSet(Value): IBitSet;
begin
  Result := TBitSet.Create(Value);
end;

var
  B: IBitSet;
begin
  B := BitSet(12345);

// Anwendung durch indizierte Property und als Default Property und als Interface mit refCounting und 
// autom. Garbage Collection

  if B[2] then B[3] := True;

end;

Es geht also doch :)

Gruß Hagen

[Binärbaum]

Als Funktion für dieses Problem könnte man folgendes verwenden:

Delphi-Quellcode:

type
 TBitOp = (boCheck, boSet, boToggle);
 
 ... 
 
function BitTest(var x: LongInt; num_of_bit: Byte; op: TBitOp = boCheck): Boolean;
begin
 Result:= True;
 case op of
  boCheck: Result:= ((x and (1 shl num_of_bit)) <>0);
  boSet: x:= (x or (1 shl num_of_bit));
  boToggle: x:= (x xor (1 shl num_of_bit));  
 end;
end;

Also x ist der Integer, der überprüft oder verändert werden soll.
Über den Parameter op: TBitOp steuert man, was getan werden soll: Überprüfen ob ein Bit gesetzt ist(boCheck, Standardeinstellung; ergibt True, wenn gesetzt), Bit setzen (boSet) oder ein Bit negieren (boToggle).
Die Operationen boSet und boToggle geben immer True zurück, da der Rückgabewert in diesem Fall ja nicht von Bedeutung ist.
Der Parameter num_of_bit gibt an, um welches bit es sich handelt. Achtung: Zählung beginnt bei null und geht demzufolge bis 31.