Hi,

Ich habe ein kleines Problem (was könnts sonst sein )

Ich möchte in mein RUTIS nun endlich Mengentypen implementieren:
Also z.B.

markieren

Delphi-Quellcode:

type
  TReplaceFlag = (rfReplaceAll, rfIgnoreCase);
  TReplaceFlags = set of TReplaceFlag;

DAs Problem ist, das ich mir nicht sicher bin, wie Delphi das verarbeitet.

Ich habe bisher folgendes festgestellt, bin mir aber bei all dem noch nicht so sicher:

Wenn man einen Aufzählungstyp hat wie TReplaceFlag, so ist der intern gespeicherte Wert für das erste Flag - also

markieren

Delphi-Quellcode:

const
  rfReplaceAll = 0;
  rfIgnoreCase = 1;

Wenn man dagegen ein Set hat, scheint es so als ob der das folgendermaßen macht:

markieren

Delphi-Quellcode:

var
  IstEnthalten_rfReplaceAll : Boolean;
  IstEnthalten_rfReplaceAll : Boolean;
begin
  IstEnthalten_rfReplaceAll := (round(IntPower(2, fIgnoreCase+1)) and ReplaceFlags) <> 0;
  IstEnthalten_rfIgnoreCase := (round(IntPower(2, fIgnoreCase+1)) and ReplaceFlags) <> 0;

Kann mir das jmd. bestätigen oder sonst noch etwas dazu beitragen?

MFG

Bei Sets mit vorfefinierten werten, sowie bei Integersets, ist es nicht so eindeutig,

aber im Allgemeinen:

markieren

Delphi-Quellcode:

type e = (a, b, c, d);
  s = set of e;

// oder
type s = set of (a, b, c, d);

Werte sind alle durchnummeriert, von 0 beginnend
a=0, b=1, c=2 und d=3

das Set ist dann ein "Bit-Array" aller werte

Bit 0 = a
Bit 1 = b
Bit 2 = c
Bit 3 = d

ergibt also folgendes
bitmaskte = $1 shl Wert;

$0001 = a
$0002 = b
$0004 = c
$0008 = d
$0010 = ...


Hat das Set also einen wert von $0005, dann sind a und c gesetzt.
$0005 = (1 shl 0) {1} or (1 shl 2) {4} Dann sind in Delphi die Sets so groß/klein wie nötig
- bis 8 Werte = Byte, bis 16 Werte = Word usw.

Das mit dem shl hab ich mir auch schon gedacht

Hatte es vorhin nur noch nicht geschrieben, weil ichs noch nachprüfen wollte.

Also ist das damit ja relativ leicht.

Aber wie sieht es aus mit der größe das Datentypes.

Also wenn so ein Set nur max 8 Eleente enthält - ist das dann nur ein Byte groß? und wie siehts aus wenns mehr enthält??

MFG

1-8 = 1 Byte
9-16 = 2 Byte (Word)
17-32 = 4 Byte (LongWord)
33-64 = 8 Byte (UInt64)
und dann jeweils in 4 Byte-Schritten (glaub ich) bis 32 Byte = maximale 256 Werte

Mit ord() kannst du die Position ermitteln.
Es gibt auch den Befehl
if (x in set) then

Ich frage mich aber...

was wäre schneller im code?

Wenn ich jetzt intern das so mache, das ich mit dem Operator "in" arbeiten kann...

oder das manuell mache.

Also:
Result := (1 shl FlagID and Flags) <> 0; EDIT: Wobei ich glaube 2. ist besser / einfacher

EDIT 2:
Aber ich frage mich, wie ich das mit Sets mit mehr als 32 (bzw. 64) Elementen mache - also wenn ich den Operator and nicht mehr verwenden kann...

MFG

Wie sieht denn deine Speicherverwaltung aus?
Bzw, wenn du auf reale SETs zugreifen willst, dann bleibt dann eh kein anderer Weg

abfragen:

markieren

Delphi-Quellcode:

if count <= 8 then result := ($1 shl value) and PByte(@data) <> 0
else if count <= 16 then result := ($1 shl value) and PWord(@data) <> 0
else result := ($1 shl (value mod 32)) and PLongWord(@data)[value div 32] <> 0;
   //result := ($1 shl (value and 31)) and PLongWord(@data)[value shr 5] <> 0;

OK, Byteweise ginge auch, auch wenn nicht unbedingt efektiv:

markieren

Delphi-Quellcode:

result := ($1 shl (value mod 8)) and PByte(@data)[value div 8] <> 0;
//result := ($1 shl (value and 7)) and PByte(@data)[value shr 3] <> 0;

entfernen (ohne "or i") und setzen (mit "or i"):

zusammenfalten · markieren

Delphi-Quellcode:

if count <= 8 then begin
  i := 1 shl value;
  PByte(@data) := (PByte(@data) and not i) or i;
end else if count <= 16 then begin
  i := 1 shl value;
  PWord(@data) := (PWord(@data) and not i) or i;
end else begin
  i := 1 shl (value mod 32);
  i2 := value div 32;
  PLongWord(@data)[i2] := (PLongWord(@data)[i2] and not i) or i;
  //i := 1 shl (value and 31);
  //i2 := value shr 5;
  //PLongWord(@data)[i2] := (PLongWord(@data)[i2] and not i) or i;
end;

Oder man macht das in Assembler

Sei EAX=@Data und EDX=count.

markieren

Delphi-Quellcode:

bt [eax],edx // setzt CF=1 wenn das Bit count = 1 ist
bts [eax],edx // setzt CF=1 wenn das Bit count = 1 ist und setzt dann das Bit=1
btr [eax],edx // setzt CF=1 wenn das Bit count = 1 ist und setzt dann das Bit=0
btc [eax],edx // setzt CF=1 wenn das Bit count = 1 ist und "dreht es dann um"

Das schöne an diesen Befehlen ist, daß edx (also count) im Bereich −2^31 bis 2^31 − 1 sein darf.
Entsprechende Funktionen könnte man so gestalten:

zusammenfalten · markieren

Delphi-Quellcode:

FUNCTION IsBitSet(p:pointer; count:integer):Boolean;
asm
   bt [eax],edx
   setc al
end;

FUNCTION SetBit(p:pointer; count:integer):Boolean;
asm
   bts [eax],edx
   setc al
end;

FUNCTION ClearBit(p:pointer; count:integer):Boolean;
asm
   btr [eax],edx
   setc al
end;

FUNCTION ToggleBit(p:pointer; count:integer):Boolean;
asm
   btc [eax],edx
   setc al
end;

@Amateurprofi:

Danke!

Diese ASM Funktionen sind genau das was ich brauchte.

Denn mir war schleierhaft, wie ich ein einzelntes Bit innerhalb eines Wertes mit einer Größe über 64 Bit abfragen konnte.

Ich werde das ganze dann mal ausprobieren.

MFG