case Integer of

[Shark99]

Könnte mir bitte jemand den Sinn (was bedeutet case Integer of) des folgenden Codes erklären (ist aus Messages.pas):

Delphi-Quellcode:

  TMessage = packed record
    Msg: Cardinal;
    case Integer of
      0: (
        WParam: Longint;
        LParam: Longint;
        Result: Longint);
      1: (
        WParamLo: Word;
        WParamHi: Word;
        LParamLo: Word;
        LParamHi: Word;
        ResultLo: Word;
        ResultHi: Word);
  end;

[XHelp]

Variante Teile nennt sich sowas glaube ich.
Du kannst am Ende des Records bestimmte Varianten festlegen, diese werden an die gleiche Speicherstelle geschrieben, existieren also "entweder/order". (du kannst aber auch mehr als 2 Varianten machen, dennoch wird nur eine genommen)
In deinem Fall heißt es: Deine Nachricht kann entweder "WParam: Longint, LParam: Longint, Result: Longint" gespeichert halten, oder eben die anderen 6.
0 und 1 spielen hier keine Rolle, aber wenn du

Delphi-Quellcode:

  TMessage = packed record
    Msg: Cardinal;
    case parameterArt: Integer of // <<- hier die Bezeichnung
      0: (
        WParam: Longint;
...
      1: (
        WParamLo: Word;
...
  end;

machst, dann bekommst du durch

Delphi-Quellcode:

eineNachricht.parameterArt

die entsprechende Variante zurück (hier also 0 oder 1) und kannst dementsprechend entscheiden wie du es behandelst
(soweit ich es richtig in erinnerung habe)

[himitsu]

hier mal ein bissl was zum Lesen:
http://docwiki.embarcadero.com/RADSt...n_Record-Typen
http://www.fh-jena.de/contrib/fb/gw/.../pas_recv.html


Der Typ zur Kennzeichnung des Varianten Teils ist egal, das könnte auch ein Enumerator sein.

Delphi-Quellcode:

TMyVarRec = packed record
  normal: irgendwas;
  case Boolean of 
    True: (...);
    False: (...);
  //end  // Achtung: dieses End gibt es blöder Weise nicht
end; 

TMyEnum = (eFirst, eNext);
TMyVarRec = packed record
  normal: irgendwas;
  case TMyEnum of 
    eFirst: (...);
    eNext: (...);
  //end  // Achtung: dieses End gibt es blöder Weise nicht
end;

Falls es wichtig ist, sich zu merken, welchen Teil man verwendet hat, dann kann man dieses mit angeben:

Delphi-Quellcode:

TMyVarRec = packed record
  normal: irgendwas;
  case Kennung: Integer of 
    0: (...);
    1: (...);
end;

Und von der Speicherverwaltung her, sieht es nun quasi so aus:

Delphi-Quellcode:

TMyVarRec = packed record
  normal: irgendwas;
  Kennung: Integer;
  case Integer of 
    0: (...);
    1: (...);
end;

Die varianten Teile liegen alle im Speicher am selben Ort, so daß der Record

Delphi-Quellcode:

TMyVarRec = packed record
  normal: irgendwas;
  case Integer of 
    0: (TheWord: Word);
    1: (TheLowByte, TheHighByte: Byte);
end;

eigentlich 2 übereinandergelegte Records darstellt:

Delphi-Quellcode:

TMyVarRec = packed record
  normal: irgendwas;
  TheWord: Word;
end;

Delphi-Quellcode:

TMyVarRec = packed record
  normal: irgendwas;
  TheLowByte: Byte;
  TheHighByte: Byte;
end;

Man kann dieses also einmal für eine Typenkonvertierung nutzen,
indem man z.B. MyVar.TheWord etwas zuweist und dann über MyVar.TheLowByte und MyVar.TheHighByte dieses als anderen Typen wieder ausließt.

Oder man kann einen Records auch für unterschiedliche Dinge benutzen, ohne daß man immer für alles Platz reservieren müßte, wo man doch nur für Eines den Platz benötigt.

Delphi-Quellcode:

TFahrzeugTypen = (ftBoot, ftAuto, ftFahrad);
TFahrzeug = packed record
  Name: String;
  Hersteller: String
  case Typ: TFahrzeugTypen of 
    ftBoot: (
      Wassertiefe: Integer;
      GeschwindigkeitInKnoten: Real);
    ftAuto: (
      AnzahlDerAchsen: Integer;
      GeschwindigkeitInKilometerProStunde: Integer);
    ftFahrad: (
      ...);
end;

Ich hoff' das klärt die ganze Sache soweit auf.

[himitsu]

[edit]

[mkinzler]

Nennt man in C Unions