Variablen während Laufzeit erzeugen?

[mo_greene]

Hallo,

ist es möglich während der Laufzeit des Programmes Variablen zu erzeugen? Wenn ja wie mache ich das?

Es geht darum, dass ich in Abhängigkeit von der Länge eines Textes verschiedene Variablen erstellen möchte.

MFG, Danke :)
mo_greene

[Apollonius]

Nicht direkt. Du könntest allerdings mit dynamischen Arrays arbeiten oder die Variablen in den Objects einer TStringlist verwalten.

[mo_greene]

Es geht darum, dass ich die Zeichen eines Textest nacheinander in Variablen (oder auch nicht:)) abspeichern möchte.

Beispiel:
Text: Hallo ich wohne in Deutschland

a =HLCOEDTHN
b =AOHHIESLD
c =LIWNNUCA

Die anzahl der vohrnanden Variablen, soll durch die Länge eines Wortes bestimmt werden, welches erst zur Programmlaufzeit bestimmt wird.

Wie mache ich das am Besten?
Hat jemand eine Idee? :)

[mkinzler]

Man kann aber keine Variablen zur Laufzeit erzeugen, macht imho auch keinen Sinn.

[mo_greene]

ja, das ist ja imho schon bekannt. weiß jemand ob es dafür eine andere Möglichkeit gibt? :)

[Luckie]

Wurde doch schon gesagt: In so einem Fall sind dynamische Arrays einsetzbar oder Listen.

[OldGrumpy]

Für die gegebene Aufgabenstellung kannst Du ein

Delphi-Quellcode:

array of String

benutzen. Zur Laufzeit bestimmst Du wie viele Strings du brauchst, setzt mit SetLength diese Anzahl Strings für das Array und verteilst die Buchstaben dann der Reihe nach auf diese Strings.
Zur Ausgabe verwendest Du dann wieder eine Schleife, und fertig.

[mo_greene]

Ich habe jetzt eine Stringliste benutzt.

Aber noch eine Frage:

Wie kann ich denn ein Zeichen in ein Element einer List hinzufügen?

Also: List := List + Zeichen?

mfg

David

[quendolineDD]

Inwiefern?
Ein Stirng anhängen

Delphi-Quellcode:

StringList.Add(STRING);

String in eine bestimmte Zeile einfügen

Delphi-Quellcode:

StringListe.list.Insert(INDEX, STRING);

Ansonsten einen String an einen bestehenden String anhängen

Delphi-Quellcode:

StringListe.Strings[INDEX]:= StringListe.Strings[INDEX] + STRING

[mo_greene]

Ich bekomme eine Fehlermeldung, dass das Maximum überschritten wird :gruebel:

Delphi-Quellcode:

    repeat
    for i := 0 to length (Schluessel) do // x = Länge des Schlüssels
    begin                                // x = Anzahl der Elemente in List
      List.Strings[i]:= List.Strings[i] + Klartext[zeichen];
      inc (Zeichen);
      inc (z);
    end;
    i := 0;
    until z = length(Klartext);

Habe ich einen Fehler gemacht? :oops:

[quendolineDD]

Nehm die Schleife mal nur bis length(schluessel) -1

Delphi-Quellcode:

repeat
    for i := 0 to length (Schluessel)-1 do // x = Länge des Schlüssels
    begin                                // x = Anzahl der Elemente in List
      List.Strings[i]:= List.Strings[i] + Klartext[zeichen];
      inc (Zeichen);
      inc (z);
    end;
    i := 0;
    until z = length(Klartext);

[mo_greene]

macht leider keinen unterschied:(

[quendolineDD]

Dann mach evtl. mal die Optimierung aus, wenn du die noch an hast im Compiler Menü und dann gehe mal den Quelltext mit F7 durch und schaue, wo du eine Bereichsverletzung hast. irgendwo müssen deine Zählvariabeln die Bereiche deiner Strings übersteigen

[inherited]

Nur weil schluessel so gross ist nehme ich an dass du die Stringlist nicht vergrößert hast.
Du musst neue Zeilen per StringList.Add hinzufügen.

[mo_greene]

er bleibt, wenn ich mit F7 durchgehe bei folgender Zeile stehen

Delphi-Quellcode:

      List.Strings[i]:= List.Strings[i] + Klartext[zeichen];

Vorher hatte ich anstelle dieser Zeile folgendes stehen:

Delphi-Quellcode:

List.Insert(i, Klartext[Zeichen]);

Damit hat es geklappt, aber leider wird der String mit dem Index immer überschrieben, was ich ja nicht möchte. Dieser soll beibehalten werden und je um ein Zeichen erweitert werden :gruebel:

Zitat:

Zitat von inherited

Nur weil schluessel so gross ist nehme ich an dass du die Stringlist nicht vergrößert hast.
Du musst neue Zeilen per StringList.Add hinzufügen.

Auch wenn der Schlüssel den Wert 1 hat, funktioniert es nicht!

[inherited]

Wenn deine Stringlist kein Element hat, wird es noch nichmal bei Schluessel=0 klappen. Es ist wie ein leerer Eierkarton: wenn du versucht das Ei an Position 3 kaputt zu hauen schlägst du ins leere, weil da einfach nichts ist. Du musst halt erst Eier reinpacken (.Add)

[quendolineDD]

Auf über 255 Zeichen pro String kommst du aber nicht?
Vergiss nicht, das eine StringListe mit

Delphi-Quellcode:

List:= TStringList.Create;

erstellt werden muss.

So wie du das machst, muss die StringListe am Index i schon einen Eintrag haben, sobald dort keiner ist, überschreitest du halt das Listenmaximum

[inherited]

Was spielt das für eine Rolle?

[mo_greene]

Ja klingt logisch :) ...danke

aber leider funktioniert es immernoch nicht...

Delphi-Quellcode:

      
List.Add('');
List.Strings[i]:= List.Strings[i] + Klartext[zeichen];

Kann ich nicht ein leeres Element einfügen?

Ich komme nicht auf über 255 und die Liste wird auch erstellt :)

[OldGrumpy]

Bitte nochmal den Quelltext am Stück posten, danke :)

[mo_greene]

Delphi-Quellcode:

procedure TKryptobox.Verschluesseln;
(* -------------------------------------------------------------------- *)
var
  i, //Zählvariable für for-Schleife
  z, //Variable, die bis zum Ende des Klartextes zählt (repeat...until)
  KTWert,
  GTWert,
  Schluessellaenge, Zeichen  : integer;
  List : TStringlist;
begin
  List := TStringlist.Create;  //Stringlist wird erstellt
  Geheimtext := '' ;
  Vorbehandeln(Klartext);
  Zeichen := 1;
  z := 1;
(*--------------------------------------------------------------------------*)
  try
    repeat
    for i := 0 to length (Schluessel) do // x = Länge des Schlüssels
    begin                                // x = Anzahl der Elemente in List
      List.Add('');                      
      List.Strings[i]:= List.Strings[i] + Klartext[zeichen];
      //List.Insert(i, Klartext[Zeichen]);
      inc (Zeichen);
      inc (z);
    end;
    i := 0;
    until z = length(Klartext);
  except
    ShowMessage('Fehler');
  end;
List.SaveToFile('C:\Krypto.txt'); //Zum Testen des Inhalts in List :)
(*--------------------------------------------------------------------------*)
end;

[inherited]

kurze frage: Was genau möchtest du erreichen. Willst du das bei jedem Durchlauf an die Zeilen etwas angehängt wird oder das bei jedem Durchlauf die liste geleert wird und neu beschrieben?

[mo_greene]

Zitat:

Zitat von inherited

kurze frage: Was genau möchtest du erreichen. Willst du das bei jedem Durchlauf an die Zeilen etwas angehängt wird oder das bei jedem Durchlauf die liste geleert wird und neu beschrieben?

das etwas angehängt wird ... :stupid:

List := alter Inhalt + neuer Inhalt

[inherited]

Und ist Schluessel vorher und nachher gleichgroß, also beim ersten und beim 2. durchlauf, bei dem etwas angehängt werden soll?

[OldGrumpy]

Der Knackpunkt ist die Abbruchbedingung für die repeat..until-Schleife (und die fehlende Abbruchbedingung für die innere Schleife). So wie Du das implementiert hast, muss die Länge des Klartextes ein Vielfaches der Schlüssellänge sein, sonst rumst es beim letzten Schleifendurchlauf. Denn die innere Schleife läuft immer so oft durch wie der Schlüssel lang ist.

[mo_greene]

Die Länge des Schlüssels ist immer gleich und es soll jeweils 1 zeichen angefügt werden...

Zitat:

Zitat von OldGrumpy

Der Knackpunkt ist die Abbruchbedingung für die repeat..until-Schleife. So wie Du das implementiert hast, muss die Länge des Klartextes ein Vielfaches der Schlüssellänge sein, sonst rumst es beim letzten Schleifendurchlauf. Denn die innere Schleife läuft immer so oft durch wie der Schlüssel lang ist.

Das heißt ich müsste innerhalb der Schleife noch überprüfen lassen, ob der Klartext zuenede ist und dann soll die Schleife beendet werden?

[mo_greene]

Es funktioniert :mrgreen: :mrgreen: Vielen Dank!!!

Habe nur noch ein kleines Anliegen:

Es fehlt das letzte Zeichen des Textes...habe ich einen Denkfehler gemacht?

Delphi-Quellcode:

    repeat
    for i := 0 to length (Schluessel) do // x = Länge des Schlüssels
    begin
      List.Add('');                                // x = Anzahl der Elemente in List
      List.Strings[i]:= List.Strings[i] + Klartext[zeichen];
      //List.Insert(i, Klartext[Zeichen]);
      inc (Zeichen);
      inc (z);
      if z = length (Klartext) then
        break;
    end;
    i := 0;
    until z = length(Klartext);

[DeddyH]

So besser (habe mir das Ganze aber nicht genauer angesehen)?:

Delphi-Quellcode:

repeat
    for i := 0 to length (Schluessel) do // x = Länge des Schlüssels
    begin
      List.Add('');                                // x = Anzahl der Elemente in List
      List.Strings[i]:= List.Strings[i] + Klartext[zeichen];
      //List.Insert(i, Klartext[Zeichen]);
      inc (Zeichen);
      inc (z);
      if z > length (Klartext) then
        break;
    end;
    i := 0;
    until z > length(Klartext);

[thkerkmann]

Zitat:

Zitat von mo_greene

Es funktioniert :mrgreen: :mrgreen: Vielen Dank!!!

Habe nur noch ein kleines Anliegen:

Es fehlt das letzte Zeichen des Textes...habe ich einen Denkfehler gemacht?

Delphi-Quellcode:

    repeat
    for i := 0 to length (Schluessel) do // x = Länge des Schlüssels
    begin
      List.Add('');                                // x = Anzahl der Elemente in List
      List.Strings[i]:= List.Strings[i] + Klartext[zeichen];
      //List.Insert(i, Klartext[Zeichen]);
      inc (Zeichen);
      inc (z);
      if z = length (Klartext) then
        break;
    end;
    i := 0;
    until z = length(Klartext);

Du hast jetzt aber eine Liste, die viel länger ist als gewollt.
Da du ja nicht nur in der ersten Runde in deine Liste Zeilen einhängst, sondern in jeder, bleiben jede Menge leere Listenzeilen übrig. Ich würde die Liste vor der repeat Schleife mal mit leeren Strings füllen, und dann weitermachen.

also

Delphi-Quellcode:

for i:=0 to length(Schluessel) do
  List.Add('');
repeat
  for i:=0 to length(Schluessel) do
  begin
    List.Strings[i] ... 
    ...
  end
  i := 0; // kannste dir schenken ist unnötig
until z > length(Klartext);

Gruss

[OldGrumpy]

Aber wieso in den Schleifen von null bis Length(Schlüssel)? Das passt doch nicht zusammen :)

[mo_greene]

Zitat:

Zitat von thkerkmann

Du hast jetzt aber eine Liste, die viel länger ist als gewollt.
Da du ja nicht nur in der ersten Runde in deine Liste Zeilen einhängst, sondern in jeder, bleiben jede Menge leere Listenzeilen übrig. Ich würde die Liste vor der repeat Schleife mal mit leeren Strings füllen, und dann weitermachen.

also

Delphi-Quellcode:

for i:=0 to length(Schluessel) do
  List.Add('');
repeat
  for i:=0 to length(Schluessel) do
  begin
    List.Strings[i] ... 
    ...
  end
  i := 0; // kannste dir schenken ist unnötig
until z > length(Klartext);

Gruss

Da tritt aber wieder der Fehler auf, dass das Listenmaximum überschritten wurde! :-D

[quendolineDD]

Du müsstest doch bis length(Schluessel)-1 die Schleife laufen lassen?!

[mo_greene]

warum? :gruebel: :)

[mkinzler]

Weil der Index bei 0 anfängt; also bei 5 Elementen von 0 bis 4(5-1)

[jottkaerr]

Hallo,

wie ist Schluessel definiert? Ist es ein String, dann muss die for-Schleife
mit 1 beginnen:

Delphi-Quellcode:

for i := 1 to Length(Schluessel) do

Ist es ein dynamisches Array, dann muss die Schleife bei 0 beginnen und mit
Length() - 1 enden:

Delphi-Quellcode:

for i := 0 to Length(Schluessel) - 1 do

Ich bevorzuge allerdings bei for-Schleifen, die über ein komplettes Array
laufen, die Ermittlung der Grenzen mit Low() und High():

Delphi-Quellcode:

for i := Low(Schluessel) to High(Schluessel) do

So ist man unabhängig davon, ob es sich um ein dynamisches Array oder ein
statisches Array mit von 0 verschiedener unterer Grenze handelt.

jkr