Wie testet man ob Enum in Teilgruppe davon?

[xZise]

Moin,
wenn ich ein Enum habe. Zum Beispiel:

Delphi-Quellcode:

type
  TElement = (Wasserstoff, Helium, Sauerstoff, Neon, Kohlenstoff);

Jetzt möchte ich gucken, ob ein Element ein Edelgas ist (#1 und #3). Normalerweise würde ich das so schreiben:

Delphi-Quellcode:

if (Element = Helium) or (Element = Neon) then

Aber kann man vielleicht eine Untergruppe erstellen?

Delphi-Quellcode:

type
  TEdelgas = (Helium, Neon)

Und dann einfach gucken, ob das Element in den Edelgasen ist?

Delphi-Quellcode:

if (Element in TEdelgas) then

Ich weiß aktuell geht das nicht, weil TEdelgas.Neon nicht das gleiche wie TElement.Neon ist. Außerdem glaube ich funktioniert so der in-Operator nicht. Aber ich hoffe ihr versteht was ich meine.

MfG
Fabian

[daywalker9]

Delphi-Quellcode:

TEdelGas = set of TElement;

var
 EdelGase : TEdelGas;

initialization

 EdelGase := [Neon...]

Dann könntest du den in operator verwenden

[s.h.a.r.k]

So könnte man es machen:

Delphi-Quellcode:

type
  TElement = (Wasserstoff, Helium, Sauerstoff, Neon, Kohlenstoff);
  TEdelgas = Set of TElement;

var
  Edelgas : TEdelgas;
  element : TElement;
begin
  Edelgas = [Wasserstofft, Helium, Neon];
  element := Neon;

  if (element in Edelgas) then
    ShowMessage('Juhu.');
end;

//edit
Wo war die rote Box? :gruebel:

//edit(2)
Das hier ist vielleicht interessanter für dich:

Delphi-Quellcode:

type
  TElement = (Wasserstoff = 10, Neon = 15, Sauerstoff = 17);

const
  Blub = [TElement.Wasserstoff, TElement.Neon];
  { bzw. }
  Blub = [Wasserstoff, Neon];

  { Der Rest wie gehabt. }

[xZise]

Moin,
danke Shark das zweite Edit war genau das was ich gesucht habe. Leider kann man das allerdings dann nicht in einem case verwenden :(

MfG
Fabian

[s.h.a.r.k]

Wie darf man das verstehen? Meinst du als Type-Definition? Verstehe nicht, was das mit einem case zu tun hat.

[xZise]

Moin,

ich meine, dass ich mit einem case testen möchte ob ein Element ein Edelgas ist:

Delphi-Quellcode:

case Element of
  EDELGASE : Showmessage('Es ist ein Edelgas');
  else Showmessage('Es ist kein Edelgas');
end;

MfG
Fabian

[jfheins]

Mach doch eine Kleine Funktion:

Delphi-Quellcode:

function ElementType(elem: TElem): TElemType
begin
Result := TElemType((getordnungszahl(elem)+6) mod 8);
end;

So oder so ähnlich :stupid:

[s.h.a.r.k]

Das geht ja auch nicht :) Neon z.B. ist ja ein Element aus Edelgas -> in

Delphi-Quellcode:

if (Element in EDELGAS) then
  Showmessage('Es ist ein Edelgas');
else
  Showmessage('Es ist kein Edelgas');

[xZise]

Moin,
und wenn es nicht nur um Elemente geht:

Delphi-Quellcode:

type
  TFixelType = (ftWall, ftBall, ftFinish,
                ftRedBrush, ftGreenBrush, ftYellowBrush,  ftBlueBrush,
                ftAcid,
                ftRedSwitch, ftGreenSwitch, ftYellowSwitch, ftBlueSwitch,
                ftRedDoor, ftGreenDoor, ftYellowDoor, ftBlueDoor,
                ftBumper, ftPad,
                ftRedAccelerator, ftGreenAccelerator, ftYellowAccelerator, ftBlueAccelerator,
                ftRedBeamstart, ftGreenBeamstart, ftYellowBeamstart, ftBlueBeamstart,
                ftRedBeamtarget, ftGreenBeamtarget, ftYellowBeamtarget, ftBlueBeamtarget,
                ftBlocker,
                ftText);

const
  DOOR_TYPES = [ftRedDoor, ftGreenDoor, ftYellowDoor, ftBlueDoor];
  BRUSHES_TYPES = [ftRedBrush, ftGreenBrush, ftYellowBrush, ftBlueBrush];

Klar, dort könnte ich auch eine verschachtelte if-Abfrage machen, aber case ist da meiner Meinung nach schöner:

Delphi-Quellcode:

case TFixelType(AMainRec.Bytes[2] - 1) of
  ftWall : ASprteBuf := TVirtualWall.Create;
  ftRedBrush, ftGreenBrush, ftYellowBrush, ftBlueBrush : ASprteBuf := TVirtualBrush.Create;
//  DOOR_TYPES : ASprteBuf := TVirtualDoor.Create;
  ftRedDoor, ftGreenDoor, ftYellowDoor, ftBlueDoor : ASprteBuf := TVirtualDoor.Create;
  else ASprteBuf := TVirtualFixel.Create;
end;

MfG
Fabian

[s.h.a.r.k]

Schöner wäre es wahrlich, aber dies bzgl fällt mir echt nichts ein :gruebel: Ich würde aber auf eine Hilfsmethode/-typ umsteigen und das wie folgt lösen:

Delphi-Quellcode:

type
  TFixelType = (ftWall, ftBall, ftFinish,
                ftRedBrush, ftGreenBrush, ftYellowBrush,  ftBlueBrush,
                ftAcid,
                ftRedSwitch, ftGreenSwitch, ftYellowSwitch, ftBlueSwitch,
                ftRedDoor, ftGreenDoor, ftYellowDoor, ftBlueDoor,
                ftBumper, ftPad,
                ftRedAccelerator, ftGreenAccelerator, ftYellowAccelerator, ftBlueAccelerator,
                ftRedBeamstart, ftGreenBeamstart, ftYellowBeamstart, ftBlueBeamstart,
                ftRedBeamtarget, ftGreenBeamtarget, ftYellowBeamtarget, ftBlueBeamtarget,
                ftBlocker,
                ftText);

const
  DOOR_TYPES = [ftRedDoor, ftGreenDoor, ftYellowDoor, ftBlueDoor];
  BRUSHES_TYPES = [ftRedBrush, ftGreenBrush, ftYellowBrush, ftBlueBrush];

type
  TMyEnumType = (etNone, etDoorTypes, etBrushesTypes);



function MyEnumTypeOfFixelElement(const AFixelType: TFixelType): TMyEnumType;
begin
  if (AFixelType in TYPES) then
    Result := etDoorTypes
  else if (AFixelType in BRUSHES_TYPES) then
    Result := etBrushesTypes
  else
    Result := etNone;
end;


AElement := { was auch immer };
case MyEnumTypeOfFixelElement(AElement) of
  etDoorTypes : ;
  etBrushesTypes : ;
  else begin
  end;
end;