Grundlegendes zu und Verwenden von Schleifen in der Delphi-Programmierung

Die Schleife ist ein gemeinsames Element in allen Programmiersprachen. Delphi hat drei Kontrollstrukturen die wiederholt Codeblöcke ausführen: für, wiederholen... bis und während... tun.

Angenommen, wir müssen eine Operation eine feste Anzahl von Malen wiederholen.

// 1,2,3,4,5 Meldungsfelder anzeigen
var j: ganze Zahl;
Start
zum j: = 1 zu 5 tun
Start
ShowMessage ('Box:' + IntToStr (j));
Ende;
Ende;

Der Wert einer Steuervariablen (j), die eigentlich nur ein Zähler ist, bestimmt, wie oft eine for-Anweisung ausgeführt wird. Das Schlüsselwort für das Einrichten eines Zählers. Im vorhergehenden Beispiel wird der Startwert für den Zähler auf 1 gesetzt. Der Endwert wird auf 5 gesetzt.
Wenn die for-Anweisung ausgeführt wird, wird die Zählervariable auf den Startwert gesetzt. Delphi als prüft, ob der Wert für den Zähler kleiner als der Endwert ist. Wenn der Wert größer ist, wird nichts unternommen (die Programmausführung springt zur Codezeile unmittelbar nach dem for-Schleifencodeblock). Wenn der Startwert kleiner als der Endwert ist, wird der Hauptteil der Schleife ausgeführt (hier: das Meldungsfeld wird angezeigt). Schließlich addiert Delphi 1 zum Zähler und startet den Vorgang erneut.

Manchmal ist es notwendig, rückwärts zu zählen. Das bis zu Das Schlüsselwort gibt an, dass der Wert eines Zählers bei jeder Ausführung der Schleife um eins dekrementiert werden soll (es ist nicht möglich, ein anderes Inkrement / Dekrement als eins anzugeben). Ein Beispiel für eine for-Schleife, die rückwärts zählt.

var j: ganze Zahl;
Start
zum j: = 5 bis zu 1 tun
Start
ShowMessage ('T minus' + IntToStr (j) + 'Sekunden');
Ende;
ShowMessage ('Für ausgeführte Sequenz!');
Ende;

Hinweis: Es ist wichtig, dass Sie den Wert der Steuervariablen in der Mitte der Schleife niemals ändern. Dies führt zu Fehlern.

Das Schreiben einer for-Schleife in eine andere for-Schleife (Verschachtelungsschleifen) ist sehr nützlich, wenn Sie Daten in eine Tabelle oder ein Raster füllen / anzeigen möchten.

var k, j: ganze Zahl;
Start
// Diese Doppelschleife wird 4x4 = 16 Mal ausgeführt
zum k: = 1 zu 4 tun
zum j: = 4 bis zu 1 tun
ShowMessage ('Box:' + IntToStr (k) + ',' + IntToStr (j));
Ende;

Die Regel zum Verschachteln für die nächsten Schleifen ist einfach: Die innere Schleife (j Zähler) muss abgeschlossen sein, bevor die nächste Anweisung für die äußere Schleife angetroffen wird (k Zähler). Wir können dreifach oder vierfach verschachtelte Schleifen oder sogar mehr haben.

Hinweis: Wie Sie sehen, sind die Schlüsselwörter begin und end im Allgemeinen nicht unbedingt erforderlich. Wenn Anfang und Ende nicht verwendet werden, wird die Anweisung unmittelbar nach der for-Anweisung als Hauptteil der Schleife betrachtet.

Wenn Sie über Delphi 2005 oder eine neuere Version verfügen, können Sie die "neue" Iteration im Stil für Elemente in der Sammlung über Container verwenden. Das folgende Beispiel zeigt Iteration über Zeichenfolgenausdrücke: Überprüfen Sie für jedes Zeichen in der Zeichenfolge, ob das Zeichen entweder 'a' oder 'e' oder 'i' ist.

const
s = 'Über Delphi-Programmierung';
var
c: char;
Start
zum c im s tun
Start
wenn c im ['a', 'e', ​​'i'] dann
Start
// etwas tun
Ende;
Ende;
Ende;

Manchmal wissen wir nicht genau, wie oft eine Schleife durchlaufen soll. Was ist, wenn wir eine Operation wiederholen möchten, bis wir ein bestimmtes Ziel erreicht haben?

Der wichtigste Unterschied zwischen der while-do-Schleife und der repeat-till-Schleife besteht darin, dass der Code der Aussage wiederholen wird immer mindestens einmal ausgeführt.

Das allgemeine Muster beim Schreiben einer Wiederholungsschleife (und einer while-Schleife) in Delphi lautet wie folgt:

wiederholen
Start
Aussagen;
Ende;
bis um Bedingung = wahr

während Bedingung = wahr tun
Start
Aussagen;
Ende;

Hier ist der Code zum Anzeigen von 5 aufeinanderfolgenden Meldungsfeldern mit Wiederholung bis:

var
j: ganze Zahl;
Start
j: = 0;
wiederholen
Start
j: = j + 1;
ShowMessage ('Box:' + IntToStr (j));
Ende;
bis um j> 5;
Ende;

Wie Sie sehen können, wertet die Wiederholungsanweisung eine Bedingung am Ende der Schleife aus (daher wird die Wiederholungsschleife mit Sicherheit mindestens einmal ausgeführt).

Die while-Anweisung wertet dagegen eine Bedingung am Anfang der Schleife aus. Da der Test oben durchgeführt wird, müssen wir normalerweise sicherstellen, dass die Bedingung sinnvoll ist, bevor die Schleife verarbeitet wird, wenn dies nicht der Fall ist Compiler kann beschließen, die Schleife aus dem Code zu entfernen.

var j: ganze Zahl;
Start
j: = 0;
während j <5 tun
Start
j: = j + 1;
ShowMessage ('Box:' + IntToStr (j));
Ende;
Ende;

Mit den Prozeduren Break und Continue können Sie den Fluss sich wiederholender Anweisungen steuern: The Break Die Prozedur bewirkt, dass der Kontrollfluss eine for-, while- oder repeat-Anweisung beendet und mit der nächsten fortfährt Erklärung der Schleife folgen Erklärung. Weiter ermöglicht es dem Steuerungsfluss, mit der nächsten Iteration der Wiederholungsoperation fortzufahren.