Hallo zusammen,

gibt es eine Möglichkeit generische Typen in Ordinalwerte zu casten und umgekehrt? Leider verweigert Delphi mir selbst einen harten Cast der Form T(IntVal) oder Integer(TVal) Testklasse ist wie folgt:

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyRec<T> = record
  strict private
    FValue: UInt32;
  public
    function GetValue: T;
    procedure SetValue(const Value: T);
  end;

function TMyRec<T>.GetValue: T;
begin
  // Ungültiger Cast
  Result := T(FValue);
end;

procedure TMyRec<T>.SetValue(const Value: T);
begin
  // Ungültiger Cast
  FValue := UInt32(Value);
end;

Warum ich FValue nicht direkt als T deklariere? Es geht darum, dass ich verschieden große (Ordinal)Typen auf eine feste Größe von 4 Byte bringen muss, aber nach außen hin trotzdem gerne mit den korrekten Typen arbeiten würde. Das ganze wollte ich mir in dieser generischen Form und entsprechenden Class Operatoren vereinfachen.

Klar ist auch, dass so ein Cast "gefährlich" ist solange Delphi keine Constraints bezüglich Ordinaltypen unterstützt (und man auch nicht wie in C++ zur Compiletime die Größe eines generischen Datentyps asserten kann), aber die Klassen werden eh nur intern von mir verwendet.

Viele Grüße
Zacherl

Vielleicht könnte man das mit einem Variant-Record (C++ Union) besser lösen.

Zitat von BUG:

Vielleicht könnte man das mit einem Variant-Record (C++ Union) besser lösen.

Da müsste ich für Enumtypen dann leider trotzdem einen Cast vornehmen, wenn ich nicht sämtliche verwendete Enums auch in den Record mit aufnehmen will

FValue := Ord(Value); ging auch nicht?


Die Größe von Value (T) ist "noch" nicht bekannt, also ist soein Cast unmöglich, da der blöde Compiler das schon während des Parsens versucht aufzulösen und nicht erst bei der Verwendung (entgültigen Implementierung).

Man kann sowas nur durch böse Casts umgehen, muß dann aber selber peinlichst genau auf die Datengröße achten.
FValue := PUInt32(@Value)^;

Und so etwas geht nicht? (Sry, kein Delphi am Start ...)

zusammenfalten · markieren

Delphi-Quellcode:

type
  TMyRec<T> = record
  strict private
    case byte of
      0: (FMem: UInt32);
      1: (FOrd: T);
  public
    function GetValue: T;
    procedure SetValue(const Value: T);
  end;

function TMyRec<T>.GetValue: T;
begin
  Result := FOrd;
end;

procedure TMyRec<T>.SetValue(const Value: T);
begin
  FOrd := Value;
end;

Danke euch beiden, werde das später mal ausprobieren Böse Casts sind ok, da ich die Klassen nur intern verwende und da ja genau weiß, wie groß meine Typen sind. Zur Sicherheit kommt noch ein Assert in die Getter/Setter.

Edit:

@BUG:
Typparameter T benötigt evtl. Finalisierung - im varianten Record nicht zulässig.

@himitsu:
Funktioniert perfekt!

Ich habe das anders gelöst, in meinem Fall mit einem String-Konverter. Es gibt einfach eine Liste mit Konvertern, und je nach Typ T wird daraus der passende ausgewählt und dann die Konverterfunktion für diesen Typ aufgerufen.
So kann man das typsicher generisch umsetzen und braucht keine unsicheren Casts.

Bei Bedarf kann ich das auch noch genauer zeigen.