Variable suchen und finden

[Hazardos]

Für mein Projekt benötige zwar nicht zwingender Weise eine Funktion um Variablen zu suchen, es würde mir aber eine Menge schreibarbeit abnehmen.

vereinfachtes Beispiel:
(für die gewünschte funktion setze ich einfach mal 'FindVariable' ein)

Delphi-Quellcode:

var i : integer;
begin
for i:=1 to 10 do
  tEdit(FindComponent ('Edit'+IntToStr(i))).text := FindVariable ('VariableNo'+IntToStr(i));
end;

Ich hoffe, ihr könnt mir bei meinem Problem helfen...

[Christian Seehase]

Moin Hazardos,

könnte ein bisschen schwierig werden, da die Variablennamen zur Laufzeit i.d.R. nicht mehr existieren.
Was hast Du denn genau vor?
Tut's nicht auch ein array?

[Hazardos]

es geht um eine Schleife...
ich könnte jetzt auch alles hier reinschreiben, nur würde das unübersichtlich werden....

Ich kanns ja nochmal beschreiben:
Ich möchte variablen während der Laufzeit einen Wert aus einem Feld zuweisen, also etwa so

Delphi-Quellcode:

VariableNo1 := Edit1.text;
VariableNo2 := Edit2.text;
VariableNo3 := Edit3.text;

so... ich möchte mir nur die Schreibarbeit ersparen...
ich könntes in ein Array umändern, aber da hätte ich noch mehr Schreibarbeit.

[Christian Seehase]

Moin Hazardos,

Zitat:

Zitat von Hazardos

...aber da hätte ich noch mehr Schreibarbeit.

Erstmal vielleicht aber dafür wird der Code anschliessend übersichtlicher (vielleicht zumindest)

Als Index könntest Du die laufende Nummer des Edit Feldes nehmen, oder Du verwendest die Tag Eigenschaft, des Edits um den Index zu speichern. Wäre sicherer, falls Du mal die Namen ändern solltest.

[RomanK]

Hoi,
so wie ich das sehe ist dein Beispiel ideal für den Einsatz von Arrays:

Delphi-Quellcode:

var 
i : integer;
deinarray: Array[1..10] of String;
begin
for i:=1 to 10 do
deinarray[i]:= tEdit(FindComponent ('Edit'+IntToStr(i))).text;  
end;

eventuelle deinarray als Global Variable.

[Hazardos]

Nagut....
Eure Lösungen sind alle schön und gut, ich hätte es genauso gemacht. Leider habe ich nicht daran gedacht, als ich das Programm begonnen habe zu schreiben, da ich noch sehr neu auf diesem Gebiet bin. Im Falle einer Umänderung der Variable zu einem Array müsste ich das Komplette Programm neu schreiben und das ist mir definitiv zuviel, da es doch recht komplex ist.

(Nebenbei, ich habe nicht unendlich viele Variablen deklariert, sondern eine selbst entworfen. Diese hat 25 untergeordnete Einträge und diese nochmal in 12 Stringeinträge aufgeteilt. Ich denke jetzt wisst Ihr, warum ich möglichst eine Schleife verwenden möchte.)

Also hat keiner Ahnung, wie man direkt Variablen 'suchen' kann???

[Christian Seehase]

Moin Hazardos,

Zitat:

Zitat von Hazardos

Also hat keiner Ahnung, wie man direkt Variablen 'suchen' kann???

Da diese Information nicht in der Datei steht, kannst Du auch nicht zur Laufzeit danach suchen.

[d3g]

Vielleicht hilft delphi RTTI. Ich kenn mich aber nur am Rande damit aus - vielleicht hilft's also auch gar nicht - und es verlangsamt die Ausführung ziemlich.

[himitsu]

:?: Sind deine Variablen, die du hier meinst, alle an einer Stelle im Code?
Wenn ja, dann schreib doch mal deine Variablendeklaration hier rein.
Werd' sie mir mal anschaun und prüfen ob ich 'ne Möglichkeit für dich hab.

:gruebel: Müsste es aber bei mir suchen, daher schau ich erst mal ob es überhaupt ginge.

[Hazardos]

meine Variablendeklaration lautet wie folgt....

Delphi-Quellcode:

  subdaten = record
    Name : String;
    Exe : String;
    iscategory : Boolean;
    Programm1 : String;
    Programm2 : String;
    Programm3 : String;
    Programm4 : String;
    Programm5 : String;
    Programm6 : String;
    Programm7 : String;
    Programm8 : String;
    Programm9 : String;
    Programm10: String;
    Name1 : String;
    Name2 : String;
    Name3 : String;
    Name4 : String;
    Name5 : String;
    Name6 : String;
    Name7 : String;
    Name8 : String;
    Name9 : String;
    Name10: String;
  end;
  datensatz = record
    Prog1 : subdaten;
    Prog2 : subdaten;
    Prog3 : subdaten;
    Prog4 : subdaten;
    Prog5 : subdaten;
    Prog6 : subdaten;
    Prog7 : subdaten;
    Prog8 : subdaten;
    Prog9 : subdaten;
    Prog10 : subdaten;
    Prog11 : subdaten;
    Prog12 : subdaten;
    Prog13 : subdaten;
    Prog14 : subdaten;
    Prog15 : subdaten;
    Prog16 : subdaten;
    Prog17 : subdaten;
    Prog18 : subdaten;
    Prog19 : subdaten;
    Prog20 : subdaten;
    Prog21 : subdaten;
    Prog22 : subdaten;
    Prog23 : subdaten;
    Prog24 : subdaten;
    Prog25 : subdaten;

var daten : datensatz;

falls jemand genau wissen möchte, wofür ich das brauche, der gehe auf Hazardos.de.vu

PS: Ihr müsst mir nicht sagen, dass ich ein array hätte benutzen können, das weis ich jetzt selber auch. Nun ist es aber zu spät.. :cry: damals wusste ich das noch nicht.

[himitsu]

:!: Diese Methode funktioniert nur wenn die Strings die in deinem Programm nie länger als 255 Zeichen sind.
Da es mit String (AnsiString) nicht funktioniert, wurden diese durch ShortString ersetzt.

Delphi-Quellcode:

  Type subdaten = record
      Case Boolean of
        False: (
          Name: ShortString;
          Exe: ShortString;
          iscategory: Boolean;
          Programm1: ShortString;
          Programm2: ShortString;
          Programm3: ShortString;
          Programm4: ShortString;
          Programm5: ShortString;
          Programm6: ShortString;
          Programm7: ShortString;
          Programm8: ShortString;
          Programm9: ShortString;
          Programm10: ShortString;
          Name1: ShortString;
          Name2: ShortString;
          Name3: ShortString;
          Name4: ShortString;
          Name5: ShortString;
          Name6: ShortString;
          Name7: ShortString;
          Name8: ShortString;
          Name9: ShortString;
          Name10: ShortString);
        True: (
          Name_: ShortString;
          Exe_: ShortString;
          iscategory_: Boolean;
          Programm__: Array[1..10] of ShortString;
          Name__: Array[1..10] of ShortString);
      End;
    datensatz = record
      Case Boolean of
        False: (
          Prog1: subdaten;
          Prog2: subdaten;
          Prog3: subdaten;
          Prog4: subdaten;
          Prog5: subdaten;
          Prog6: subdaten;
          Prog7: subdaten;
          Prog8: subdaten;
          Prog9: subdaten;
          Prog10: subdaten;
          Prog11: subdaten;
          Prog12: subdaten;
          Prog13: subdaten;
          Prog14: subdaten;
          Prog15: subdaten;
          Prog16: subdaten;
          Prog17: subdaten;
          Prog18: subdaten;
          Prog19: subdaten;
          Prog20: subdaten;
          Prog21: subdaten;
          Prog22: subdaten;
          Prog23: subdaten;
          Prog24: subdaten;
          Prog25: subdaten);
        True: (Prog__: Array[1..25] of subdaten);
      End;

  Var daten: datensatz;

  ...

  { liest Text von Label1 ein und schreibt ihn auf Label2}
  daten.Prog14.Programm2 := Label1.Caption;
  Label2.Caption := daten.Prog__[14].Programm__[2];

Deine Variablen-Deklaration wurde einfach mit dieser überlagert. Da die Reihenfolge und Anzahl der Sub-Deklaration identisch sind, liegen somit die selben Variablen übereinander (nutzen den selben Speicherbereich).
Somit ist der "alte" Zugriff und der Zugriff über Array's gleichzeitig möglich.
Ein Beispiel für den Zugriff auf diese Deklaration ist schon im obrigen Code enthalten.

Delphi-Quellcode:

  Type subdaten = record
        Name_: ShortString;
        Exe_: ShortString;
        iscategory_: Boolean;
        Programm__: Array[1..10] of ShortString;
        Name__: Array[1..10] of ShortString;
      End;
    datensatz = record
        Prog__: Array[1..25] of subdaten;
      End;

:!: "_" wurde zur Unterscheidung der alten zur neuen Deklaration eingefügt.


:gruebel: Kleine Erleuterung:
Das kann man gut zur Typen-Umwandlung/-Zerlegung verwenden.
Ich nutze sowas zum Beispiel um eine reelle Variable byteweise in eine Datei zu schreiben und auszulesen.

Delphi-Quellcode:

Var Farbe: Record
  Case Boolean of
    False: (Color: TColor);
    True:  (Alpha, Blau, Gruen, Rot: Byte);
  End;

Farbe.Alpha := ...;
Farbe.Blau  := ...;
Farbe.Gruen := ...;
Farbe.Rot   := ...;
... := Farbe.Color;

************************************************** ***

Besser kommst'e aber wenn du doch dein Prog umschreibst.
Brauchst doch nur mit Suchen & Ersetzen drüber rauschen und dann noch die Deklaration auszutauchen.

Delphi-Quellcode:

  Var daten: Array[1..25] of record
      Name: String;
      Exe: String;
      iscategory: Boolean;
      Programm: Array[1..10] of String;
      ProgName: Array[1..10] of String;
    End;

{für's ersetzen}
datenXX    => daten[XX]
ProgrammXX => Programm[XX]
NameXX     => ProgName[XX]

[Christian Seehase]

Moin Hazardos,

Zitat:

Zitat von Hazardos

Nun ist es aber zu spät..

nicht unbedingt ;-)
Leider funktionieren HugeStrings nicht in varianten Teilen von Records, aber wenn man sich einfach noch ein paar Typen deklariert, so dass am Ende ein Typ herauskommt, der genauso gross ist, wie der ursprüngliche (Typ String ist eigentlich nur ein Pointer, also 4 Byte), kann man sich durch ein wenig Speicher kopieren aus diesem Problem retten.

Delphi-Quellcode:

TcsProg = array [1..10] of string;
TcsName = array [1..10] of string;

TcsSubRec = record
  Name       : String;
  Exe        : String;
  iscategory : Boolean;
  asProg     : TcsProg;
  asName     : TcsName;
end;

TcsRecord = record
  Prog : array [1..25] of TcsSubRec;
end;

var daten : datensatz;
implementation

{$R *.DFM}

procedure TForm1.Button1Click(Sender: TObject);

var
  rWork  : TcsRecord; // Das neue Format mit Arrays
  pArray : Pointer;
  pLines : Pointer;

begin
  Daten.Prog1.Name := 'Name';
  Daten.Prog1.Exe  := 'EXE';
  Daten.Prog1.Programm1 := 'Prog1';
  Daten.Prog1.Name1 := 'Name1';
  Daten.Prog25.Programm10 := '25Prog250';
  Daten.Prog25.Name10 := '25Name10';

  // Umgehen des Problems mit den varianten Teilen im Record
  pArray := @rWork; // Adresse der Variablen im neuen Format
  pLines := @Daten; // Adresse der Variablen im alten Format
  
  // Da der Aufbau von beiden Datentypen intern der gleiche ist
  // kann jetzt einfach der eine in den anderen kopiert werden
  CopyMemory(pArray,pLines,SizeOf(rWork));

  // Und der Zugriff auf auf das Array klappt
  ShowMessage(rWork.Prog[25].asName[10]);

  // geht auch umgekehrt
  rWork.Prog[13].asName[5] := 'HALLO';
  // nur muss man hier den Pointer für Quelle und Ziel vertauschen
  CopyMemory(pLines,pArray,SizeOf(rWork));

  // aber auch so herum geht's
  ShowMessage(Daten.Prog13.Name5);
end;

Am Besten wäre es vielleicht sich für dieses hin und her kopieren eine Funktion zu basteln.
Wenn Du die Daten speichern willst, wird's allerdings interessant, dann muss man sich noch was einfallen lassen.

[Hazardos]

Danke für eure Vorschläge....
ich werde mich gleich mal dranmachen und das Programm nochmal umschreiben, so wie ihr es vorgeschlagen habt....

mfg Hazardos