Anzahl der Elemente eines Aufzählungstyps ermitteln

[Ares]

Das Ganze müsste irgendwie so aussehen:

Delphi-Quellcode:

function EnumLength(Enum: Ordinaltyp): Integer;
var i: Ordinaltyp;
begin
  result := 0;
  try
    for i:=Low(Enum) to High(Enum) do
      inc(result);
  except

  end;
end;


ODER

function EnumLength(Enum: Ordinaltyp): Integer;
begin
  result:= High(Enum) + 1;
end;

In beiden Fällen muss ich wissen, was ich an Stelle von Ordinaltyp angeben muss.

[MrKnogge]

Wie bereits geschrieben, integer oder besser TMyEnum

[Bernhard Geyer]

Könnte man u.U. über die Unit TypeInfo und der RTTI etwas herausfinden?
Die Funktion GetEnumName hört sich doch gut an oder man geht über TypeInfo: PTypeInfo und dort über @T^.NameList. Aber aufgrund der fehlenden Doku in diesem Bereich (auch bei D6) ist es nicht so einfach zu verstehen was man dort alles machen könnte.

[himitsu]

@Ares wie kommst du jetzt auf eine Klasse (TClass)?

i muß den selben Typ wie der Enumerator haben, also TMyEnum (oder wie er bei dir heißt.)

Try-Except ist hierbei unnötig, wo sollte auch eine Exception auftreten?

und jetzt rate mal wie oft die For-Schleife durchlaufen wird ... genau "High-Low+1"-mal ... und da nur ein Inc drinsteht, wleches die Durchläufe zählt, kann man sich die Durchläufe doch auch gleich ausrechen

Delphi-Quellcode:

type
  TMyEnum = (meEins, meZwei, meDrei);
  TMyEnumEx = (mxEins=1, mxZwei=2, mxSechs=6);

const
  MyEnumEx: Set of TMyEnumEx = [mxEins, mxZwei, mxSechs];

procedure TForm1.Button1Click(Sender: TObject);
var
  i: TMyEnum;
  i2: TMyEnumEx;
  Zaehler1, Zaehler2, Zaehler3, Zaehler4, Zaehler5: Integer;
  S: String;
begin
  Zaehler1 := 0;
  for i := Low(TMyEnum) to High(TMyEnum) do
    Inc(Zaehler1);

  Zaehler2 := Ord(High(TMyEnum)) - Ord(Low(TMyEnum)) + 1;

  Zaehler3 := 0;
  for i2 := Low(TMyEnumEx) to High(TMyEnumEx) do
    Inc(Zaehler3);

  Zaehler4 := Ord(High(TMyEnumEx)) - Ord(Low(TMyEnumEx)) + 1;

  Zaehler5 := 0;
  for i2 := Low(TMyEnumEx) to High(TMyEnumEx) do
    if i2 in MyEnumEx then
      Inc(Zaehler5);

  S := Format('TMyEnum - For: %d'#13#10
    + 'TMyEnum - Math: %d'#13#10
    + 'TMyEnumEx - For: %d'#13#10
    + 'TMyEnumEx - Math: %d'#13#10
    + 'TMyEnumEx - Const: %d',
    [Zaehler1, Zaehler2, Zaehler3, Zaehler4, Zaehler5]);
  Application.MessageBox(PChar(S), '');
end;

[Ares]

Zitat von MrKnogge:

Wie bereits geschrieben, integer.

Sorry, aber das verstehe ich nicht. Oder vielleicht reden wir an einander vorbei?

Folgendes würde ich gerne realisieren:

Delphi-Quellcode:

type
  TMyEnum = (meEins, meZwei, meDrei);
  ...
 
  int := EnumLength(TMyEnum);
  // --> EnumLength liefert 3 zurück

Hierfür muss ich der Funktion EnumLength jeden beliebigen Aufzählungstyp übergeben können. Wenn ich die Funktion mit i: integer Verwende erhalte ich die Meldung "Inkompatible Typen", weil i vom Typ Integer und Enum vom Typ TClass ist. Hierbei ist noch zu beachten, dass TClass natürlich auch falsch ist. Enum müsste vom Typ TAufzählungstyp sein. Nur weiß ich eben nicht wie ich dies angeben kann.

[himitsu]

eine allgemeine Funktion ist nicht mögilich, denn:

- Enumeratoren verfügen über keine Typeninformationen
- High/Low wird vom Compiler durch Konstanten erstetzt ... dieses sind keine Funktionen

also selbst wenn es möglich wäre alle Enum-Typen an eine Funktion zu übergeben, dann wären innerhalb der Funktion keine Informationen für High/Low verfügbar.
Heißt EnumLength kann immer nur für einen Typ erstellt werden!

allerdings liefert hier EnumLength die Werte für den Typ Integer und nicht für TMyEnum
Also: dieses funktioniert nicht.

Delphi-Quellcode:

function EnumLength(Enum: Integer): Integer;
var i: Integer;
begin
  result := 0;
  for i := Low(Integer) to High(Integer) do
    inc(result);
end; 


Var X: TMyEnum;
  Y: TMyEnum2;
EnumLength(Integer(X));
EnumLength(Integer(Y));

Zusammengefasst:
direkte Lösungen wurden alle schon aufgezählt (Zusammenfassung siehe Beitrag #14)

allgemeine Funktionen sind nicht möglich.

[Apollonius]

Zitat:

Enumeratoren verfügen über keine Typeninformationen

Lass dich bloß nicht bei solchen Aussagen erwischen. GetEnumName und GetEnumValue aus der Unit TypInfo nehmen Parameter vom Typ PTypeInfo entgegen, die genau diese Typeninformationen des Aufzählungstypen sind.

[himitsu]

TypeInfo(TMyEnumEx)

Zitat von DelphiCompiler:

Typ 'TMyEnumEx' besitzt keine Typinformationen

ergo:

Delphi-Quellcode:

Var P: PTypeInfo;

P := TypeInfo(TMyEnumEx);  // geht nicht !!!

Name  := GetEnumName(P);
Value := GetEnumValue(P);

[Progman]

Ich glaube, einen direkten Typ für sowas gibts gar nicht, aber

Delphi-Quellcode:

var int: Integer;
  ...
int := High(DeinEnumTyp) + 1;

erfüllt doch den gleichen Zweck.