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:
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?
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?

//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

[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 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;