Moin,
wenn ich ein Enum habe. Zum Beispiel:

markieren

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?

markieren

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

markieren

Delphi-Quellcode:

TEdelGas = set of TElement;

var
 EdelGase : TEdelGas;

initialization

 EdelGase := [Neon...]

Dann könntest du den in operator verwenden

So könnte man es machen:

zusammenfalten · markieren

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:

markieren

Delphi-Quellcode:

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

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

  { Der Rest wie gehabt. }

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

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

Moin,

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

markieren

Delphi-Quellcode:

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

MfG
Fabian

Mach doch eine Kleine Funktion:

markieren

Delphi-Quellcode:

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

So oder so ähnlich

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

markieren

Delphi-Quellcode:

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

Moin,
und wenn es nicht nur um Elemente geht:

zusammenfalten · markieren

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:

markieren

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

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:

zusammenfalten · markieren

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;