Programmsteuerung 3: Die "for"-Schleife
Die for-Schleife ist eine Zählschleife die hoch- oder runterzählt. Oder in einer Liste Elemente
"durchgeht". Eine Art von "Liste" haben wir schon kennengelernt: Das Array. Hier konzentrieren wir uns erstmal
auf die Zählschleife.
Standardmäßig sieht die for-Schleife wie folgt aus:
|
for [lokale Zählvariable:Integer]:=[Zahlenwert] to | downto [Zahlenwert] do begin // Anweisungen, die ausgeführt werden sollen end; |
Die lokale Zählvariable kann nicht in der For-Schleife verändert werden.
Wenn von einer kleineren Zahl aus hochgezählt werden soll, dann benutzt man den Operator "to" ansonsten
"downto".
Beispiele
Hierbei soll die Reihe der Quadratzahlen in ein "TMemo"-Element, ein mehrzeiliges Textfeld, eingetragen werden.
|
Procedure BtnBsp1Click(Sender:TObject); var i:Integer; begin for i:=1 to 10 do Memo1.Lines.Add(IntToStr(i*i)); end; |
Auch hier können wir wieder begin und End weglassen, wenn wir nur eine Anweisung
haben: Der Quelltext wird lesbarer.
Die for-Schleife wird vor allem benutzt, wenn man mit Arrays (oder was wir vielleicht später kennenlernen:
mit Listen) arbeitet. Hier also ein Beispiel, wie man ein dynamisches Array of Integer mit 0 initialisiert.
|
//... var // Hier werden sog. "globale" Variablen deklariert Form1: TForm1; myArray : Array of Integer; // myArray ist hierdurch überall nutzbar // wie es in der Procedure "initMyArray" // im zweiten Beispiel genutzt wird. implementation //... procedure initMyArray( myLength : Integer); var i : Integer; // Laufvar i muss eine "lokale" Variable sein! begin SetLength( myArray, myLength); for i := 0 to High( myArray) do myArray[i] := 0; end; |
Was es genau mit SetLength auf sich hat, und was High() genau macht, wird im folgenden etwas größeren Mitmach-
Beispiel beschrieben.
Ein "Mitmach-Beispiel":
Dieses Beispiel wiederholt und vertieft, was in
Step 07 - Arrays bereits besprochen wurde. Damit der folgende
Quelltext verständlich wird, erkläre ich euch erst einmal die Komponente "ListBox", welche wir in der
Gruppe "Standard" finden, sowie die Funktion "High".
Eine "ListBox" ist im Prinzip eine Liste, bei der die Werte über die Eigenschaft ListBox.Items geändert
bzw. gespeichert werden können. Zudem kann man auf diese Werte wie bei einem Array zugreifen:
Dies ist über ListBox.Items.Strings[Index]
möglich.
Die Eigenschaft ListBox.Items.Count sagt, wie viele Werte die Listbox hat.
Die Funktion "High" gibt den Index des letzten Elementes des Arrays zurück:
Wenn also Count (Menge der Elemente) = 10 ist, dann ist der Index des letzten Elementes (also z.B. High(meinArray)) = 9.
Jetzt solltet ihr den folgenden Quelltext verstehen, falls ihr doch noch Fragen habt, dann schreibt gerne.
Der nun folgende Teil muss in die FormCreate-Procedure. Um diese Methode zu erstellen kann kurz einfach doppelt
auf das Formular geklickt werden. Oder: Im Objektinspektor bei Form1 kann unter Ereignisse die Methode gefunden
und mit Doppelklick auf das leere Feld erstellt werden.
|
var i, k : Integer; begin // Hier kommt der Source aus Beispiel 2 in Einsatz: initMyArray(10); for k := 0 to High(myArray) do // Dem Array werden Werte von 0-10 zugewiesen: myArray[ k] := k; for I := 0 to High(myArray) do //Werte aus dem Array werden in der begin if ListBox1.Items.Count > i then // Der Index i existiert in der Listbox: ListBox1.Items.Strings[i] := IntToStr( myArray[ i]) else // Der Index i existiert noch nicht! ListBox1.Items.Add( IntToStr( myArray[ i])); end; end; |
Kleine Warnung: Diese Zuweisung auf Strings[ i] der Liste ist nicht immer möglich! Delphi ist "so schlau"
und erstellt die Elemente in dieser Liste. Tatsächlich müssten wir aber erst mit ListBox1.Items.Add('')
Elemente hinzufügen!
Dieser Teil in die OnClick Procedure eines Buttons:
|
var i, unten, oben : Integer; begin unten := 0; oben := High(myArray); for i := unten to oben do begin myArray[oben-i] := StrToInt(ListBox1.Items.Strings[i]); // Die Werte der "Laufvariable" werden als Meldung angezeigt: ShowMessage( IntToStr( i)); end; //Werte aus dem Array werden erneut in die Listbox geschrieben: for i := 0 to High( myArray) do begin ListBox1.Items.Strings[i] := IntToStr( myArray[ i]) end; |
Wer an dieser Stelle mal einen "Count-Down" sehen möchte, wechselt in der For-Schleife einfach
unten mit oben und schreibt downto anstatt to.
Was machen die beiden for-Schleife hier eigentlich?
Und noch ein weiteres "Mitmach-Beispiel":
Wir wissen, dass eine Zeichenkette (String) aus Buchstaben besteht. Ein String ist also im Prinzip ein
Array of Char, mit dem einzigen Unterschied, dass es sich hierbei nicht um ein Null-Indexiertes Array handelt!
Das liegt ein bisschen an - ich nenn das jetzt mal - "Evolution" von "Zeichenketten".
Wenn wir einen kleinen Codier-Algorithmus entwerfen möchten, so könnte dies ein Teil unseres Algorithms sein:
|
codeStr:=''; for i:=0 to High(myStr) do begin codeStr := codeStr + chr( (ord( myStr[i]) + 50) mod 256); end; // der String ist hiernach sehr wahrscheinlich nicht mehr korrekt anzeigbar! // Warum? |
Die Funktionen Ord() und Chr():
Strings sind auch nur Einsen und Nullen... Chr und Ord sind Umwandlungsfunktionen, die genutzt werden
um einfache Buchstaben in ihre Codierte Form mit Ord umzuwandeln und wieder zurück. Die Darstellung
der mittels Chr umgewandelten Zeichen kann u.U. nicht mehr gewährleistet werden, da es sich bei manchen
Zeichen um Steuerzeichen handelt, die noch aus den früheren DOS-Zeiten übrig geblieben sind.
Für Uns als Anfänger eignen sich diese Funktionen jetzt allerdings sehr gut, um mit unserem bis jetzt
errungenen Wissen bereits eine Verschlüsselung vorzubereiten :)
Ok, unter
GitHub findet ihr das Beispiel 4 voll ausprogrammiert.
Schaut es euch an: Lässt sich mit ShowMessage() das Ergebnis ausgeben?
Viel Spaß ;)
Viel Spaß ;)