Globale Konstanten zur Laufzeit ermitteln

[ZOD]

Guten Morgen!


Frage:
Gibt es eine Möglichkeit, zur LAUFZEIT Konstantenbezeichner und deren Werte zu ermitteln?
Ich verwende Delphi 7 für dieses Projekt.

Hintergrund:
ich habe eine Unit, in der globale Konstanten zur Programmsteuerung deklariert werden.
Die Konstantenbezeichner haben ein festes Präfix im Namen.

Natürlich kann ich die dort definierten Konstanten manuell in eine Liste eintragen und
bei Bedarf zur Laufzeit die zugehörigen Werte anzeigen lassen.

Ich würde dies jedoch gerne mittels Programmcode erledigen, also zur Laufzeit
im Speicher nach möglichen Konstanten suchen und deren Werte ausgeben.
Hat jemand eine Idee dazu?
Danke für Tipps.

[himitsu]

Nein.

Aucn nicht mit der neuen RTTI.

Grund: Namen/Positionen von Konstanten(Variablen sind irrelevant und werden nicht mit einkompilert.
Außerdem werden viele Konstanten direkt vor Ort eingebaut, also da wo sie überall verwendet werden. Es gibt also nichtmal eine Stelle wo man Konstanten suchen könnte.

[ZOD]

Ok, danke - habe ich schon so befürchtet.

[himitsu]

Du könntest maximal das als published Variablen Felder in eine Klasse legen. Dort kommt selbst die alte RTTI ran.

Siehe die Variablen mit den Namen der Komponenten auf der Form, welche vom DFM-Loader mit dem Instanz-Zeiger gefüllt werden.
Oder siehe TReader/TWriter, welche dieser Published-Felder auslesen/befüllen können.

[mensch72]

Wenn man Aufzählungstypen als benannte Konstanten einsetzt, sieht ist das mit(MyTypeConst.mtcInfo) oder ohne(mtcInfo) "NameSpace" gut lesbar, typsicher und man kann per GetEnumName(TypeInfo(EnumType),interger(EnumValue) ) zur Laufzeit immer den benannten Wert zurückbekommen.

Ist zwar etwas mehr Aufwand wie ein simples "const XXXX", erfüllt aber so die Frage-/Aufgabenstellung :)

Delphi-Quellcode:

  MyTypeConst = (
    mtcNotSet      = $00,  
    mtcDummy       = $01,  
    mtcInfo        = $02,  
    mtcData        = $03  
    );


function MyTypeConstToStr(const iMyTypeConst : Integer) : String; overload;
begin
  result := GetEnumName(TypeInfo(MyTypeConst) , iMyTypeConst);
end;

function MyTypeConstToStr(const aMyTypeConst : MyTypeConst) : String; overload;
begin
  result := GetEnumName(TypeInfo(MyTypeConst) , integer(aMyTypeConst));
end;

- mit GetEnumValue( funktioniert es andersrum... man bekommt den Wert zum "Namen"
- wenn nur der Type bekannt, gibt es "alle" möglichen Namen per von 0 hochzählender Schleife bis Fehler mit GetEnumName(

[Uwe Raabe]

Zitat:

Zitat von himitsu (Beitrag 1256612)

Du könntest maximal das als published Variablen Felder in eine Klasse legen. Dort kommt selbst die alte RTTI ran.

Dann sind es aber keine Konstanten mehr und für bestimmte Zwecke (z.B. statische Array-Grenzen, statische Berechnung anderer Konstanten) unbrauchbar. Der Trick ist also nur bedingt einsetzbar.

[himitsu]

Nja, es ist ein Weg, einen Speicherort mir einem Namen zu identifizieren. :angel:
PS: Typisierte Konstanten sind in Delphi oftmals eh nur schreibgeschützte Variablen. (ich hatte mal ausversehn den globalen Leerstring '' zerschossen und wenn jetzt irgendwo jemand via PChar auf einen leeren String zugriff, dan gab der meinen neuen Wert raus. :stupid:)

Über die neue RTTI, könnte man das (standardmäßig) auch mit Private-Feldern machen.



@mensch72: Bei Enums ohne "Wertangaben" (

Delphi-Quellcode:

type TMyEnum = (a, b, c);

) funktiniert das.
Aber hast du es mal bei Enums mit auch nur einer einzigen Wertangabe, oder mehreren probiert? ((

Delphi-Quellcode:

type TMyEnum = (a, b=123, c);

) / (

Delphi-Quellcode:

type TMyEnum = (a=2, b=4, c=8);

))
Und das geht natürlich nur für Werte von 0 bis 255 und wenn keine der "Konstanten" den selben Wert haben.

[Dejan Vu]

Generell gesehen ist das imho einfach keine gute Idee, denn es ist unflexibel bzw. abhängig von einer bestimmten Nomenklatur ('Prefix im Namen') und eine implizite Funktionalität. Der Programmierer erwartet das doch nicht, das eine Variable mit einem bestimmten Namen in einem Dialog angezeigt wird.

Viel besser ist es, eine Klasse zu schreiben, bei der man seine Konstanten (Wert+ Namen) registriert. In einem Dialog (oder Ausdruck) kann das dann sehr einfach angezeigt werden, denn die Klasse definiert einen Iterator oder gleich eine Key-Value-Liste.