Änderung einer Deklarartion integer <-> double möglich?

[BAMatze]

Hallo und guten Morgen an alle DP´ler,

Hab mal eine allgemeine Frage. Kann ich in die Deklaration einer Property einer Komponente je nach Verwendung ändern?
Es geht um folgendes: Ich hab eine Komponente, in welche Ganzzahlen oder Gleitkommazahlen eingegeben werden können. Je nachdem welcher Typ durch den Benutzer eingestellt wird, soll die Property Value integer oder double sein. Gibt es eine Möglichkeit dies umzusetzen?
Leider hab ich zu dem Thema kein Threat gefunden, was sicherlich nicht daran liegt, dass es sie nicht gibt, sondern an den verwedeten Fachwörtern.

Vielen Dank
BAMatze

[jfheins]

Eine Property mit veränderlichem Typ gibt es nicht. Mit fallen auf anhieb 2 Lösungen ein: 1. Variant benutzen - da kann man sowohl nen Integer als auch einen Double reinstecken. 2. Zwei Properties benutzen, eine für Integer und eine für Double

[jaenicke]

Eine Klasse zur Kapselung ginge auch. Und rein theoretisch wären auch noch ein variabler Record oder Pointer denkbar, aber beim Auslesen musst du doch sowieso mit dem richtigen Typ arbeiten (außer bei Variants). Deshalb verstehe ich nicht so ganz wie du dir das vorstellst.

[BAMatze]

Naja Vorstellungen hatte ich bisher noch nicht so wirklich, deswegen hatte ich euch ja mal gefragt, was es dort gibt. Ich versuche es jetzt mal mit den Variants, so wie sich das anhört, scheinen die ja ausreichend variabel für mich zu sein, dass ich je nach den beiden Typen (double oder integer) meine Variable drauftun kann ohne Probleme dabei zu bekommen. Oder gibt es dort trotzdem etwas zu beachten, dass zu Problemen führen könnte?

[jaenicke]

Zitat von BAMatze:

Oder gibt es dort trotzdem etwas zu beachten, dass zu Problemen führen könnte?

Das wichtigste: Sie sind extrem langsam. Wenn du also viele Operationen durchführen willst, rate ich eher davon ab.

Ich glaube auch auf jeden Fall, dass es sicher eine bessere Lösung gibt.

[BAMatze]

Zitat von jaenicke:

Ich glaube auch auf jeden Fall, dass es sicher eine bessere Lösung gibt.

Also möchte eigentlich keine weiteren Operationen damit durchführen. Ich möchte eigentlich nur den Wert, der in meiner Komponente in einem TEdit steht variabel halten.
Im Programm soll dieser dann ganz normal auf den dementsprechend richtigen Typen draufgeschrieben werden ala:

Delphi-Quellcode:

  iWert := Komponente.Value
  // oder ebend
  dWert := Komponente.Value

Würde das gehen?

[mkinzler]

Dann nimm einen Variant und entsprechende Methoden

[himitsu]

Soll der Typ wärend der Laufzeit geändert werden könne,
oder reicht es, wenn man ihn zum Compilieungszeitpunkt festlegen kann?

siehe himXML ... die Klassen da lassen sich mit unterschiedliche Typendefinitionen kompilieren, aber diese sind dann zur Laufzeit unveränderbar.

[Reinhard Kern]

Zitat von BAMatze:

Also möchte eigentlich keine weiteren Operationen damit durchführen. Ich möchte eigentlich nur den Wert, der in meiner Komponente in einem TEdit steht variabel halten.
Würde das gehen?

Hallo,

grundsätzlich geht immer alles, ist bloss eine Frage des Aufwands. Ich benutze im Folgenden einen Record mit case of, keine Delphi Varianten. Wichtig: es gibt für jeden Typ einen Constructor, und der legt auch für den Rest des Lebens den Typ fest. Abgerufen werden die Werte mit Object.GetInteger, Object.GetString usw. dadurch ist Typprüfung gegeben - ich benutze absichtlich kein Overloading, ich will lieber einen Fehler sehen, wenn ich mich vertan habe. Das mit der Konstruktion auch dyn. Array und Strings möglich sind (Casting mit TRKiniSettingRecordS anstatt TRKiniSettingRecord), tut hier nichts zur Sache. Ist nur ein unvollständiges Schema, keine Copy&Paste-Vorlage!!

Gruss Reinhard

Delphi-Quellcode:

   TRKiniSettingVariant = (sv_Undef,sv_String,sv_Bool,sv_Integer,
                           sv_Real,sv_Color,sv_Pen,sv_WinPos,sv_Font,sv_Binary);
{...}
   PRKiniSettingRecord = ^TRKiniSettingRecord;
   TRKiniSettingRecord = packed record
     SetupControl : TControl;
     dirty : boolean;
     removed : boolean;
       case TRKiniSettingVariant of
         sv_Undef   : (vUndef : int64);      { 8 bytes }
         sv_Bool    : (vBool : boolean);     { svWinpos }
         sv_Integer : (vInteger : longint);
         sv_Real    : (vReal : double);
         sv_Color   : (vColor : TColor);
         sv_Pen     : (vPen : longint);
       { sv_WinPos  :  see above }
       { sv_Binary,sv_String,sv_Font  :  see below }
     end;
    { record size : 20 b }

   PRKiniSettingRecordB = ^TRKiniSettingRecordB;
   TRKiniSettingRecordB = packed record
     SetupControl : TControl;
     dirty : boolean;
     removed : boolean;
     vBinary : TRKIniBinaryArray; 
     BDummy : DWord;
     end;

   PRKiniSettingRecordS = ^TRKiniSettingRecordS;
   TRKiniSettingRecordS = packed record
     SetupControl : TControl;
     dirty : boolean;
     removed : boolean;
     vString : TRKIniDynString;
     BDummy : DWord;
     end;
{...}
   TRKiniSettingValue = class
     sType : TRKiniSettingVariant;
     gType : TRKIniSettingsGrouping;
     digits : Smallint;
     Uplink : TRKIniSettingTable;
     ForwardLink : TRKiniSettingValue;
     pGroupItems : PRKiniSettingRecord;  { 0 : Default. 1..n : Items }
     IniGroup,IniItem : TRKiniSettingName;
     FirstRecord,FieldLength,ExtraRecords : word;
     procedure  SetupGrouping (imax : Smallint);
     procedure   Create_General (imax : Smallint; IG,II : TRKiniSettingName;
                const Def; pCC : PAoTC; maxCC : Smallint; OwnerTable : TRKIniSettingTable);
     constructor Create_String (imax : Smallint; IG,II : TRKiniSettingName;
             Def : ShortString; EC : array of TEdit; OwnerTable : TRKIniSettingTable);
     constructor Create_Bool   (imax : Smallint; IG,II : TRKiniSettingName;
                    Def : Boolean; BC : array of TButtonControl; OwnerTable : TRKIniSettingTable);
     constructor Create_Integer (imax : Smallint; IG,II : TRKiniSettingName;
                    Def : longint; EC : array of TEdit; OwnerTable : TRKIniSettingTable);
{...}
     function  GetString (ix : Smallint) : ShortString;
     function  GetBool (ix : Smallint) : boolean;
     function  GetInteger (ix : Smallint) : longint;
     function  GetReal (ix : Smallint) : Double;
     function  GetColor (ix : Smallint) : TColor;
     function  GetPenWidth (ix : Smallint) : Smallint;
{...}
{ speziell für ein Projekt: }
  TBPMLogSettings = class (TRKIniSettingTable)
    public
    Station_Node        : TRKiniSettingValue; { group }
    Station_Description : TRKiniSettingValue; { group }
{...}
constructor TBPMLogSettings.CreateTable (IC : TRKIniClass);
var CSection : ShortString;

begin
inherited Create (IC);

with BLMainForm do
  begin
  CSection := 'Station';
  Station_Node       := TRKiniSettingValue.Create_Integer (-maxStationNo,CSection,
        'Node',0, [] ,self);
  Station_Description  := TRKiniSettingValue.Create_String (-maxStationNo,CSection,
        'Description','', [] ,self);
{...}

[himitsu]

vergiß aber nicht, daß bei Reinhard Kerns Lösung der Record selber freigegeben werden muß, wenn da etwas größeres drin enthalten ist, welches via Pointer referenziert ist und auch bei Objekten.

Delphi-Quellcode:

TIndex = Record
  ValueType:   (vtIntValue, vtStringValue);
  IntValue:    Integer;
  StringValue: String;
  Class Operator Implicit(      Value: Integer): TIndex;
  Class Operator Implicit(Const Value: String):  TIndex;
  Class Operator Implicit(Const Value: TIndex):  Integer;
  Class Operator Implicit(Const Value: TIndex):  String;
End;

dieser Record ist z.B. 12 Byte groß,
regelt die Speicherfreigabe selber und man braucht keine Zuweisungsfunktionen aufrufen

Delphi-Quellcode:

Var X: TIndex;
  i: Integer;
  S: String;

X := i;
X := S;
S := X;
i := X;

praktisch wie Variant, nur etwas Schlanker.