Enumeration, Compiler und Alternativen

[LazProgger]

Ich habe den Fall dass ich einige (viele) Strings in meinem Programm verwalten muss. Die Strings sollen änderbar sein und auf sie soll an verschiedenen Stellen des Programms zugegriffen werden können.

Meine erste Idee, für jeden String eine Variable zu deklarieren, habe ich verworfen.

Meine zweite Idee ist, alle Strings in einen Array zu packen und auf die Strings via einer Enumeration zuzugreifen, also etwa so (die Enumeration deswegen, da man sonst schlecht weiß welcher String sich hinter welchem Index verbirgt):

Code: Alles auswählen

 
e = (strA:=0, strB, strC);
 
arr[ord(strA)] := 'strA';  // arr ist ein array of string}
arr[ord(strB)] := 'strB';
arr[ord(strC)] := 'strC';
 

Nun ist die Frage: Was ist aus Compiler-Sicht besser?

Ich denke die Idee, sagen wir 500 Einzelvariablen zu deklarieren, ist nicht so toll, oder? Schließlich müsste jede Einzelvariable dann ja einzeln verwaltet werden und nur den Array zu verwalten ist besser für die Performance, oder?

Aber wie sieht es mit dem Enumeration-Verfahren aus? Wandelt der Compiler nun das ord(strA) schon zur Compile-Zeit in eine 0 um (wäre ideal)?
Oder ist die Performance schlecht bei diesem Konstrukt?

Oder gibt es noch bessere Alternativen für meinen Fall das umzusetzen?

[theo]

Oder gibt es noch bessere Alternativen für meinen Fall das umzusetzen?

Kommt drauf an, was das werden soll. Von TStringList bis Datenbank ist vieles möglich.
Leider habe ich keine Ahnung wozu das dient. Bitte erklärt das doch jeweils gleich, sonst kann man schlecht den richtigen Tipp geben.

[LazProgger]

Also es geht einfach darum dass ich eine Liste von Strings habe, auf die ich im Programm zugreifen möchte. Also zum Beispiel "Einfügen", "Löschen", "Beenden" und so weiter. Und diese Strinsg müssen irgendwo gespeichert werden (aber nicht in externen Dateien).
Da man darauf vernünftig zugreifen können muss sollte der Aufruf über einen definierbaren Namen möglich sein. Also zum Beispiel strInsert, strDelete, strClose.
Daher ist ein einfacher Array oder eine Stringlist ja nicht per se geeignet, da man ja nicht weiß welchen Index jetzt "Einfügen" oder "Löschen" hat.
Daher die Idee das entweder mit Konstanten oder der Enumeration Sache zu lösen (um einen Match zwischen Index und einer im Quelltext lesbaren Representation zu haben.

Also eigentlich kann man meine Frage reduzieren auf: Wie ist es am einfachsten und am besten für die Performance eine Abbildung von einem Integer-Wert auf einen im Quelltext lesbaren Bezeichner zu haben.

[m.fuchs]

[...]Daher die Idee das entweder mit Konstanten[...]

Da hast du auch schon deine Antwort. Wenn sich die Dinger im Verlaufe des Programms nicht ändern, nimm Konstanten.

[theo]

Ja, Konstanten würde ich auch sagen.
Für mich hast du den Zweck aber noch immer nicht erklärt.
Ich kann noch immer nicht einschätzen, welche Rolle eine maximale Performance hier spielt.

[Christian]

Wenn du Übersetzbare Strings für diene Oberfläche haben willst sind
ressourcestrings
das richtige.

[Socke]

Aber wie sieht es mit dem Enumeration-Verfahren aus? Wandelt der Compiler nun das ord(strA) schon zur Compile-Zeit in eine 0 um (wäre ideal)?
Oder ist die Performance schlecht bei diesem Konstrukt?

Ungeachtet der anderen Rückfragen, sage ich hierzu: Array [e] of String; - man kann die Enumeration direkt als Array-Schlüssel verwenden.

[mschnell]

Ungeachtet der anderen Rückfragen, sage ich hierzu: Array [e] of String; - man kann die Enumeration direkt als Array-Schlüssel verwenden.

Genau so macht man das. Vermutlich erzeugt der Compiler daraus exakt denselben Code wie mir einem ord(..) Konstrukt.

-Michael