Aufzählungstypen "addieren"

[David Martens]

Ich hab mich gefragt ob das geht?

Delphi-Quellcode:

type
  TSortDir = (sdAscending, sdDescending);

...
var
  FSortDir : TSortDir;
begin
  FSortDir := FSortDir + sdAscending;

So geht es nicht!!! Kann man das überhaupt so ähnlich machen oder muß man "if" oder "case" nehmen?

David

[implementation]

Delphi-Quellcode:

type
  TSortDir = (sdAscending { = 0 }, sdDescending { = 1 });
var
  FSortDir : TSortDir;
begin
  ...
  FSortDir := TSortDir(Ord(FSortDir)+Ord(sdAscending));
  ...
end;

[edit]
Aber wenn FSortDir vorher schon sdAscending ist, kommt natürlich TSortDir(2) raus, also weder sdAscending noch sdDescending.
Ist das beabsichtigt?

[himitsu]

Njain ... wieso sollte sowas auch gehn sollen? :roll:

aber wenn du dir diese Enums in ihre Ordinalwerte umwandelst, dann sind es Integer und damit ginge es.

Delphi-Quellcode:

FSortDir := TSortDir(Ord(FSortDir) + Ord(sdAscending));

.

Pass aber auf, daß du nicht den "Wertebereich" deines Enums verläßt ... wer weiß, wie dein Programm dann reagiert, wenn es ungekannte Werte vorfindet.

[edit]
mißt, da war wer 'ne Millisekunde schneller :shock:

[shmia]

Dazu nimmt man doch ein Set, oder nicht?

Delphi-Quellcode:

type
  TSortDir = (sdAscending, sdDescending);
  TSortDirSet = set of TSortDir;
...
var
  FSortOptions : TSortDirSet;
begin
  FSortOptions := [];
  FSortOptions := FSortOptions + sdAscending;
  FSortOptions := FSortOptions + sdDescending;

[Namenloser]

Fragt sich nur, ob ein Set in Bezug auf den Beispieldatentyp Sinn macht, solange wir nicht von Quantencomputern reden.

[implementation]

Es fragt sich erst einmal, was er mit der Addition bezwecken will.:gruebel:
Himitsu und ich gingen jetzt erst einmal davon aus, dass er sie arithmetisch addieren möchte.

Also Frage an den TE:
Was soll bei der Addition herauskommen? Was möchtest du haben?
Beide Werte zusammen? Oder addiert?

[David Martens]

War gerade Essen, daher jetzt erst eine Antwort.

Ich hab mich mal wieder nicht klar genug ausgedrückt.

Ich will eigentlich nur zwischen den beiden Zuständen wechseln ohne eine If-Anweisung zu benutzen. Ich dachte das müsste doch zu machen sein.

Also so sdAscending + x => sdDescending und sdDescending + x => sdAscending

Ich hatte mich an meine Mathevorlesung erinnert wo wir eine "zweielementigen" Raum aufgespannt haben mit Inhalt 0 und 1 (quasi Binärraum) und die Addition so definiert, das 0 + 0 = 0, 0 + 1 (oder 1 + 0) = 1 und 1 + 1 = 0 ist.

David

P.S.: Danke für die Antworten und schön das ich damit eine Diskussion über Quantencomputer ausgelöst habe.

[Namenloser]

Zitat:

Zitat von David Martens (Beitrag 1037653)

Ich hatte mich an meine Mathevorlesung erinnert wo wir eine "zweielementigen" Raum aufgespannt haben mit Inhalt 0 und 1 (quasi Binärraum) und die Addition so definiert, das 0 + 0 = 0, 0 + 1 (oder 1 + 0) = 1 und 1 + 1 = 0 ist.

Das funktioniert bei Delphiprogrammen nur bedingt, weil der Compiler die Größen der Datentypen im Zuge der Optimierung immer auf ganze Registerbreiten rundet (kleinste Breite ist 1 Byte). Und selbst wenn er das nicht täte, gäbe es immer noch die Beschränkung auf 2^n.

Was du machen willst geht also nicht wirklich elegant, wenn dann nur mit Tricks wie Typecasts wie himitsu gezeigt hat, aber das kann auch mal in die Hose gehen, z.B. bei sowas:

Delphi-Quellcode:

type 
  TMyEnum = (meFoo=1, meBar=2, meFoobar=42);

Wenn du meBar mit Hilfe eines Typecasts inkrementierst kommt da ein Wert (3) heraus, der nicht vorgesehen ist.

Du könntest bestenfalls noch ein Hilfs-Array benutzen, etwa so:

Delphi-Quellcode:

const
  HelperArray = array[0..2] of TMyEnum = (meFoo, meBar, meFoobar);
  Index: integer;
...
begin
  Index := (Index+1) mod length(HelperArray);
  myvalue := HelperArray[index];
end;

Das erfordert aber wiederum, dass du den Index irgendwo gesondert abspeichern musst.

Was besseres fällt mir jedenfalls im Moment nicht ein.
[edit]
Oder man macht sowas:

Delphi-Quellcode:

type 
  TMyEnum = (meFoo=1, meBar=2, meFoobar=42);
const
  EnumSuccessors: array[TMyEnum] of TMyEnum =
    (meBar, meFoobar, meFoo);
begin
  MyValue := EnumSuccessors[MyValue];
end;

Kann vielleicht in bestimmten Fällen auch hilfreich sein.
[/edit]

[Christian Seehase]

Zitat:

Zitat von David Martens (Beitrag 1037653)

Ich hatte mich an meine Mathevorlesung erinnert wo wir eine "zweielementigen" Raum aufgespannt haben mit Inhalt 0 und 1 (quasi Binärraum) und die Addition so definiert, das 0 + 0 = 0, 0 + 1 (oder 1 + 0) = 1 und 1 + 1 = 0 ist.

und die zugehörige Funktion nennt sich Exklusiv-Oder (XOR).

[himitsu]

also

Delphi-Quellcode:

FSortDir = TSortDir(Ord(FSortDir) xor 1)

.
Aber dieses funktioniert auch nur bei deinen 2 Werten, sobald ein dritter oder mehr Werte dazukommen war's das.

+1 im Ring, also 1 Weiterzählen und nach dem Ende am Anfang fortahren ginge so:

Delphi-Quellcode:

FSortDir = TSortDir((Ord(FSortDir) + 1) mod (Ord(High(TSortDir)) + 1))

.
Wobei dieses ebenso nur funktioniert, wenn es eine Fortlaufende Reihe gibt, welche bei 0 beginnt (in der Deklaration darf keinem Wert explizit via = eine andere Nummer zugeordnet sein).