darf man das?

[Leuselator]

Was haltet ihr von folgendem Code?

Delphi-Quellcode:

type
TMoeglicheProbleme = (mpKleinesProblem,mpMittleresProblem,mpGrossesProblem);
TProblemSammlung = set of TMoeglicheProbleme;

var
MeineProbleme :TProblemSammlung;
MeinProblemCast : Longword;
begin
  MeineProbleme := [mpKleinesProblem,mpMittleresProblem];
 
  MeinProblemCast := Longword(pointer(@Meinproblem)^); // scheint zu funktionieren...

  MeinProblemCast := 4;

  MeineProbleme := TProblemSammlung(Pointer(@MeinProblemCast)^); // das auch
 
end;

ernsthafte Einwände?
Gruß

[Luckie]

Bitte gib deinem Beitrag einen aussagekräftigen Titel. Der jetzige Titel lässt nicht erkennen, um was für ein Problem oder Frage es sich handelt. Um den Titel zu ändern, editiere einfach deinen ersten Beitrag. Damit erleichterst du das Auffinden deines Beitrages mit der Suche und ersparst anderen Mitglieder ein unnötiges Öffnen deines Beitrages.

[Medium]

Was ich davon halte: Gornix Gerade Enums und Sets sind dazu gedacht die Lesbarkeit des Codes zu verbessern, und du schaffst es damit diese sogar noch zu verschlechtern. Daher: Völlig entgegen dem Sinne des Erfinders, und entgegen jeglicher Standards. Immer Käse.

Warum das gut gehen kann: Sets sind intern Bit-Felder, ganz ähnlich den diversen aus 2er-Potenzen zusammengebauten Flags in z.B. der WinAPI. Jedem Element ist nun eine Bitposition zugeordnet, ist dieses Bit 1 ist das korrespondierende Element in der Menge (im Set), sonst nicht. Daher kannst du prinzipiell auch einfach von hinten durch die Brust einen Wert an die Speicherstelle kritzeln, und reinterpretiert ist das dann eine Untermenge des Sets. ABER: Welches Element des Enums an welches Bit gekoppelt wird obliegt allein dem Compiler. Der wird sich wahrscheinlich definiert verhalten, jedoch muss das nicht für alle anderen Versionen das selbe Verhalten sein. Zudem kann man Enums auch Werte per Hand verpassen, wo dann auch erstmal fraglich ist wie diese in einem Set gehandhabt werden. Auch bin ich mir grad unsicher, ob Sets immer einem Longword entsprechen.

Fazit: Auch wenn es zunächst einmal geht, tu dir selbst und allen die den Source jemals mal lesen müssen den gefallen und mach solche Vergewaltigungn nicht. Aus technischer Sicht weil es eben unsicher sein kann, aber viel viel mehr weil es dem Sinn der Sache völlig entgegen spricht. Ich denke was du da geposted hast wird nur ein Beispiel sein, ich kann mir gut vorstellen, dass sich für den eigentlichen Zweck deutlich passendere Strukturen finden ließen.

[R2009]

Hi,
wer soll dir das verbieten? Du darfst alles was dir Spass macht.
Sowas macht man natürlich nicht weil der Code einfach unlesbar und unkontrollierbar wird.
Aber: wie immer gibts vielleicht doch eine Anwendungsmöglichkeit:
Ich such seit Monaten eine Möglichkeit mit wenig Aufwand Bytes zu manipulieren.

Wenn ich mir folgendes vorstelle:
TBitset=(Bit0,Bit1,Bit2,Bit3,Bit4,Bit5,Bit6,Bit7) set of TBitset; Man müsste sich mal überlegen ob sowas dann wirklich die Bits0 und 2 eines Bytes setzt.

MeinByte := [Bit0,Bit2]; Werd ich auf jeden Fall ausprobieren.

Grüsse
Rainer

[Stevie]

Zitat von R2009:

Hi,
wer soll dir das verbieten? Du darfst alles was dir Spass macht.
Sowas macht man natürlich nicht weil der Code einfach unlesbar und unkontrollierbar wird.
Aber: wie immer gibts vielleicht doch eine Anwendungsmöglichkeit:
Ich such seit Monaten eine Möglichkeit mit wenig Aufwand Bytes zu manipulieren.

Wenn ich mir folgendes vorstelle:
TBitset=(Bit0,Bit1,Bit2,Bit3,Bit4,Bit5,Bit6,Bit7) set of TBitset; Man müsste sich mal überlegen ob sowas dann wirklich die Bits0 und 2 eines Bytes setzt.

MeinByte := [Bit0,Bit2]; Werd ich auf jeden Fall ausprobieren.

Grüsse
Rainer

Korrekt wäre folgendes:

Delphi-Quellcode:

type
  TBit = (Bit0,Bit1,Bit2,Bit3,Bit4,Bit5,Bit6,Bit7);
  TBitSet = set of TBit;

var
  i: Word;
  x: TBitSet;
begin
  x := [];
  i := Word(x); // i = 0

  x := [Bit0];
  i := Word(x); // i = 1

  x := [Bit1]; 
  i := Word(x); // i = 2

  x := [Bit0, Bit1];
  i := Word(x); // i = 3

  x := [Bit7];
  i := Word(x); // i = 128
end;

Je nach Anzahl Elemente in deinem Enum (Bits) kannst du nur verschiedene Casts deines Sets machen.
Hast du beispielsweise 16 Bits, kannst du nicht in Byte casten, sondern in Word.
Über den Umweg des TE kannst du auch in größere Wertetypen casten, allerdings greifst du dann auf nicht initialisierten Speicher zu - daher Finger weg von sowas.

[alzaimar]

Zitat von R2009:

Man müsste sich mal überlegen ob sowas dann wirklich die Bits0 und 2 eines Bytes setzt.

Heute vielleicht, aber was ist mit der nächsten Compilergeneration?

Wieso nicht die üblichen OR bzw. AND - Operationen auf Bytes?
Bits0And2 := $01 OR $04; Deine Überlegungen und die des Threaderstellers, aus vermeindlichen Performancegründen (oder warum auch immer), die Lesbarkeit von Programmcode auf 0 zu setzen mag im eigenen Kämmerlein keine Auswirkungen haben (außer die der potentiellen Inkompatibilität), aber sobald man den Code veröffentlicht, ist Schluss mit lustig.

[R2009]

Hi alzaimar,

ist doch klar aber man wird doch nachdenken und spekulieren dürfen?

Grüsse
Rainer

[alzaimar]

Zitat von R2009:

ist doch klar aber man wird doch nachdenken und spekulieren dürfen?

Um 06:31 ?

[R2009]

na und
bin halt Frühaufsteher!
War 10 jahre Systemadministrator und musste um 6:00 Morgens hier sein.
Jetzt bin ich zu alt um das noch zuändern.

Grüsse
Rainer

[himitsu]

Einwand:

dein Set ist 1 Byte groß (jedenfalls deiner Deklararion nach)
dein Cast dagegen 4 Byte



also wie Stevie scjon erwähnte
wenn die Größe stimmt, dann läßt es sich auch casten
ansonsten sind deine "wilden" Zwangs-Cast's Scheiße.

Delphi-Quellcode:

type
  a = set of (aa, bb, cc);
  b = LongWord;
  {$MINENUMSIZE 4}
  c = set of (dd, ee, ff);
  {$MINENUMSIZE 1}  // zurücksetzen

  d = (gg, hh, ii);
  e = LongWord;
  {$MINENUMSIZE 4}
  f = (jj, kk, ll);
begin
ShowMessage(Format('%d %d %d    %d %d %d', [SizeOf(a), SizeOf(b), SizeOf(c),
  SizeOf(d), SizeOf(e), SizeOf(f)]));

Code:

1 4 4    1 4 1