Von der Grundstufe bis zur Mittelstufe: Die Anweisung FOR

Einführung

Der hier dargestellte Inhalt ist ausschließlich für Bildungszwecke bestimmt. Die Anwendung sollte unter keinen Umständen zu einem anderen Zweck als zum Erlernen und Beherrschen der vorgestellten Konzepte verwendet werden.

Im vorigen Artikel, Von der Grundstufe zur Mittelstufe: Die Anweisung SWITCH habe ich erklärt und demonstriert, wie man den SWITCH-Operator in seiner grundlegendsten und einfachsten Form verwendet. Es ist sehr wichtig, dass Sie sich bemühen zu verstehen, wie jede der bisher behandelten Aussagen funktioniert. Nicht in einer Art und Weise, die zum Auswendiglernen anregt, sondern in einer Art und Weise, die es Ihnen ermöglicht, darüber nachzudenken, wie Sie jede Aussage und jedes Konzept, das bis zu diesem Punkt vorgestellt wurde, anwenden können.

Ich verstehe, dass einige von Ihnen dieses Material zu einfach oder zu wenig tiefgründig finden könnten. Schließlich könnten wir uns auch mit fortgeschritteneren Themen befassen. Aufgrund meiner langjährigen Programmiererfahrung habe ich jedoch festgestellt, dass komplexere und anspruchsvollere Themen sogar auf den ersten Blick leichter zu verstehen sind, wenn die grundlegenden Konzepte gut verstanden werden. Genau das möchte ich mit diesen Artikeln erreichen. Ich möchte, dass Sie, liebe Leserin, lieber Leser, verstehen, wie jedes Element auf seiner grundlegendsten und fundamentalsten Ebene funktioniert. Wenn wir uns dann mit fortgeschrittenerem Material beschäftigen, werden Sie es viel schneller und mit weniger Schwierigkeiten verstehen können.

Sehr gut. Von allen Anweisungen, die in MQL5 zur Steuerung des Ausführungsflusses einer Anwendung zur Verfügung stehen, ist nur noch eine einzige zu behandeln. Dies ist der letzte Operator in MQL5, der für diesen Zweck entwickelt wurde. Ja, ich beziehe mich auf FOR. Wie Sie aber wahrscheinlich schon bemerkt haben, ziehe ich es vor, die Themen getrennt vorzustellen. Auf diese Weise ist es einfacher, den Erklärungen zu folgen. Lassen Sie uns also ein neues Thema beginnen.

Prämissen der FOR-Erklärung

Obwohl viele Anfänger dazu neigen, sich vorzustellen, dass es eine überwältigende Anzahl von Anweisungen gibt, die gelernt werden müssen, kommen die meisten Programmiersprachen tatsächlich nur mit einigen wenigen aus. Zumindest, wenn es sich um Befehle zur Abfolgekontrolle handelt. Verwechseln Sie diese nicht mit Bibliotheksaufrufen oder reservierten Schlüsselwörtern; sie sind völlig verschieden. Die Anzahl der Anweisungen zur Abfolgekontrolle ist in der Regel recht begrenzt. Andererseits können Bibliotheksaufrufe, reservierte Schlüsselwörter sowie Hilfsfunktionen und Prozeduren selbst innerhalb einer Programmiersprache leicht in die Tausende gehen. Nehmen Sie zum Beispiel C/C++. Die Anzahl der Befehle zur Abfolgekontrolle ist gering. Die Zahl der verfügbaren Hilfsfunktionen und Prozeduren ist jedoch so groß, dass es praktisch unmöglich ist, die gesamte Sprache zu beherrschen, wenn man die Bibliotheksaufrufe noch nicht einmal mitzählt. In Wirklichkeit ist ein Programmierer auf ein bestimmtes Gebiet spezialisiert. Da sie aber über ein solides Grundverständnis der Sprache verfügen, sind sie in der Lage, jedes Problem zu lösen, solange sie genügend Zeit haben, ihr Wissen an die jeweilige Aufgabe anzupassen.

Aus diesem Grund lernen selbst sehr erfahrene Programmierer ständig dazu. Sie lernen ständig dazu und versuchen, sich über neue Trends auf dem Laufenden zu halten. Dies ist ein großer Unterschied zu dem, was viele Menschen annehmen, wenn sie mit dem Programmieren beginnen. Viele glauben, dass das bloße Wissen um ein paar Dinge sie bereits zu Programmierern macht. In Wirklichkeit funktioniert das nicht so. Man muss ältere Techniken ständig studieren und verfeinern. Nur dann können Sie ein Niveau erreichen, auf dem Sie sagen können: ICH BIN EIN PROGRAMMIERER.

Warum also sage ich das alles? Der Grund dafür ist einfach, lieber Leser. Mit allem, was wir bisher behandelt haben, werden Sie, wenn Sie sich die Zeit nehmen, zu studieren und Ihr Verständnis für das, was bereits vorgestellt wurde, zu vertiefen, in der Lage sein, praktisch jede Programmierherausforderung zu meistern. Das liegt daran, dass die FOR-Anweisung im Wesentlichen ein Schleifenkonstrukt ist. Aber wir haben bereits Schleifen mit WHILE und DO WHILE erforscht. Warum brauchen wir also noch eine weitere Erklärung für Schleifen? Das scheint nicht viel Sinn zu machen, oder?

Nun, in Wahrheit gibt es einen triftigen Grund, warum die FOR-Anweisung neben WHILE und DO WHILE existiert. Und der Grund dafür ist einfach: Es gibt Szenarien, in denen die Verwendung von WHILE oder DO WHILE nicht ideal ist. Ich weiß, es mag etwas seltsam klingen, aber ja, es gibt Situationen, in denen es angemessener ist, FOR anstelle von WHILE oder DO WHILE zu verwenden. Viele dieser Fälle hängen damit zusammen, ob die CONTINUE-Anweisung innerhalb der Schleife verwendet wird oder nicht.

Es ist jedoch sehr wichtig zu verstehen, dass die FOR-Anweisung bei weitem der Favorit unter Programmierern ist. Warum? Denn der damit geschriebene Code ist in der Regel klarer und lesbarer als die gleiche Schleife, die mit WHILE oder DO WHILE geschrieben wurde. Und warum ist das so? Der Grund dafür ist, dass die FOR-Anweisung normalerweise (und das ist entscheidend) alle Elemente, die mit der Schleifenkontrolle zusammenhängen, in ihrer Deklaration enthält. Im Gegensatz dazu ist bei WHILE und DO WHILE die Steuerlogik in der Regel irgendwo im Schleifenkörper verstreut. Diese einfache Unterscheidung ist es, die Programmierer dazu bringt, FOR zu bevorzugen, da es viel einfacher ist, die Schleife zu korrigieren, zu ändern oder sogar zu verstehen, indem man sich die FOR-Deklaration selbst ansieht, ohne sich durch die Schleife wühlen zu müssen, um die Steuerlogik zu finden.

Aber warten Sie einen Moment. Wenn die FOR-Anweisung einfacher und effizienter für die Steuerung von Schleifen ist, warum diskutieren wir sie dann erst jetzt? Wäre es nicht sinnvoller gewesen, sie früher einzuführen? Dies ist zugegebenermaßen ein etwas umstrittener Punkt, lieber Leser. Die FOR-Anweisung ist zwar auf den ersten Blick einfacher, hat aber bestimmte Eigenschaften, die sie recht komplex machen können. Aus diesem Grund habe ich mich entschieden, WHILE und DO WHILE zuerst einzuführen und FOR als letzte Kontrollanweisung zu behandeln.

Auch wenn wir zunächst FOR in seiner grundlegendsten und einfachsten Form betrachten, wird es für uns beide viel einfacher sein (vorausgesetzt, Sie haben die vorangegangenen Erklärungen studiert), zu verstehen, wie FOR funktioniert. Vielleicht hätte ich diese Erklärung noch weiter hinausschieben sollen, da wir noch nicht über die Vorrangregeln für Operatoren gesprochen haben, die einen erheblichen Einfluss auf die gesamte Programmierung haben. Aber auch ohne diese Regeln erforscht zu haben, können wir mit Kontrollflussanweisungen eine ganze Menge erreichen. So kann ich Inhalte erstellen, die für Leser geeignet sind, die wirklich gerade erst mit dem Programmieren beginnen und diese Artikel und die MQL5-Dokumentation als Grundlage verwenden. Das wäre das ideale Szenario. Da ich aber weiß, dass viele bereits ein gewisses Maß an Erfahrung mit dem Programmieren haben, wenn auch nicht unbedingt ein tiefes Verständnis, versuche ich, ein Gleichgewicht zu schaffen und alle auf ein gemeinsames Niveau für das zu bringen, was wir später erkunden werden.

Nun gut, es ist an der Zeit, die FOR-Anweisung in Aktion zu sehen. Aber lassen Sie uns zu einem neuen Thema übergehen, denn ich möchte, dass diese erste Begegnung für alle reibungslos und angenehm verläuft.

Die FOR-Anweisung

Die einfachste Art, einen neuen Befehl einzuführen, ist, etwas zu verwenden, das wir bereits kennen. Wir werden also Folgendes tun: Zunächst werden wir die Skripte aus dem Artikel wiederverwenden, in dem wir die WHILE-Anweisung und das DO WHILE-Paar besprochen haben. Dies wird einen reibungsloseren Übergang ermöglichen. Betrachten Sie diese erste Exposition eher als eine Übersetzung der vorherigen Codes in eine neue Form - dieses Mal nur unter Verwendung der FOR-Anweisung.

Beginnen wir mit dem einfachsten Code:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     while (info)
11.     {
12.         info = info - 1;
13.         Print(__FUNCTION__, " : ", info);
14.     }
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Code 01

Da dies das einfachste aller Beispiele ist, ist es wichtig, dass Sie das Konzept der Lebensdauer einer Variablen sowie den Unterschied zwischen globalen und lokalen Variablen verstehen, bevor wir uns ansehen, wie man diesen Code mit der FOR-Anweisung umschreibt. Diese Konzepte wurden bereits in den ersten Artikeln dieser Reihe behandelt. Wenn Sie also noch nicht mit dem Unterschied zwischen globalen und lokalen Variablen vertraut sind, empfehle ich Ihnen, diese ersten Artikel noch einmal zu lesen, um besser zu verstehen, was hier erklärt wird. Beginnen Sie mit „Von der Grundstufe bis zur Mittelstufe: Variablen (I)“.

Angenommen, Sie haben bereits das nötige Hintergrundwissen, dann lassen Sie uns jetzt Code 01 übersetzen, um die FOR-Anweisung zu verwenden. Es gibt mehrere Möglichkeiten, dies zu tun, und jeder Ansatz führt etwas in den Code ein oder ändert ihn. Wir beginnen mit einer, die dem Code 01 sehr ähnlich ist. Er ist unten aufgeführt:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     for( ; info; )
11.     {
12.         info = info - 1;
13.         Print(__FUNCTION__, " : ", info);
14.     }
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Code 02

Dieser Code 02 veranschaulicht die erste Möglichkeit, mit der FOR-Anweisung zu arbeiten. Beachten Sie, dass wir nur die Zeile 10 geändert haben. Das Ergebnis bleibt jedoch sowohl für Code 01 als auch für Code 02 das gleiche. Das Ergebnis sehen Sie auf dem folgenden Bild:

Abbildung 01

Wenn Sie sich den Code 02 ansehen, sind Sie vielleicht ein wenig verwirrt. Das liegt daran, dass die in Zeile 10 gezeigte FOR-Anweisung wahrscheinlich ganz anders aussieht, als Sie es von den meisten Beispielen gewohnt sind. Und genau deshalb ist es wichtig, dass Sie, liebe Leserin und lieber Leser, das in den vorangegangenen Artikeln vermittelte Wissen wirklich aufnehmen. FOR ist kein gewöhnlicher Operator. Sie besteht aus drei Teilen, von denen jeder einen bestimmten Zweck hat, den man gut verstehen muss. Bevor wir zu den Einzelheiten übergehen, wollen wir eine zweite Alternative für die Umschreibung desselben Code 01 untersuchen. Diese Alternative finden Sie gleich unten:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     for( ; info; info = info - 1)
11.         Print(__FUNCTION__, " : ", info);
12. 
13.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
14. }
15. //+------------------------------------------------------------------+

Code 03

Nun, liebe Leserinnen und Leser, bedenken Sie Folgendes. Was Sie in Code 03 sehen, ist nicht dasselbe wie vorher. Dies liegt daran, dass der Wert der Variablen „info“ nicht in der Weise geändert wird, wie Sie es vielleicht erwarten. Ja, sie wird verändert, aber das Ergebnis wird ein anderes sein. Wenn Sie also Code 03 ausführen, erhalten Sie das unten dargestellte Ergebnis:

Abbildung 02

Aber warum ist das Ergebnis anders ausgefallen? Das mag ein wenig seltsam erscheinen. Sollten wir in diesem Fall nicht den Operator FOR verwenden können, um die Schleife zu erstellen? Nun, lieber Leser, gehen wir Schritt für Schritt vor. Zunächst ist es möglich, die FOR-Schleife zu verwenden, um diese Iteration so zu erstellen, dass sie dem in Abbildung 01 gezeigten Ergebnis entspricht. Allerdings (und das ist der Punkt, an dem die Dinge für viele verwirrend werden können) ist es wichtig, die Rolle der Variablen „info“ zu verstehen. Denn alles hängt von ihr ab, nicht unbedingt von der FOR-Schleife selbst. Und warum sage ich das? Denn je nach Fall kann es sein, dass wir die eine oder andere Methode verwenden müssen, damit die FOR-Anweisung in Code 03 das gleiche Ergebnis wie in Code 02 liefert. Aus diesem Grund sollten Sie nicht versuchen, die Verwendung der Aussage auswendig zu lernen. Stattdessen sollten Sie sich darauf konzentrieren zu verstehen, wie es funktioniert. Dies ist der Punkt, an dem die Dinge oft verwirrend werden.

Und hier geben viele Leute auf, wenn sie lernen wollen, wie man die FOR-Anweisung richtig verwendet. Aber ich werde mein Bestes tun, um es auf möglichst einfache Weise zu erklären. Nehmen wir an, dass die Variable „info“ tatsächlich in Zeile sechs deklariert werden muss. Der Grund ist im Moment nicht wichtig; wir wollen nur, dass er zu diesem Zeitpunkt festgelegt wird. Zweitens wollen wir, dass „info“ durch die Schleife verändert wird, sodass ihr Endwert derjenige ist, der die Schleife beendet. Zum jetzigen Zeitpunkt gibt es ein kleines Problem, um das wir uns aber noch nicht kümmern werden. Bleiben wir vorerst bei unseren Annahmen. Wenn Sie den Wert der Variablen „info“ in Code 01 nach dem Durchlaufen der Schleife überprüfen, werden Sie feststellen, dass ihr Wert Null ist. Das Gleiche geschieht im Code 02. Bei Code 03 ist der Wert jedoch eins. Aber wie Sie in Abbildung 02 sehen können, ist der erste angezeigte Wert zehn und nicht neun, wie Sie vielleicht erwartet hätten.

Sie könnten also denken: Was passiert, wenn wir den in Zeile sechs angegebenen Wert von zehn auf neun ändern? Was würde dann passieren? Nun, liebe Leserin, lieber Leser, ich überlasse es Ihnen, das auf eigene Faust zu erforschen. Aber es gibt etwas Wichtiges zu beachten: Wenn Sie den Wert in Zeile sechs ändern, kann sich das auf eine Berechnung oder Bedingung auswirken, die von der Variablen „info“ abhängt. Deshalb ist es keine gute Idee, Dinge im Code zu ändern, ohne vorher zu verstehen, was wirklich vor sich geht. Hier geht es nicht darum, wahllos irgendeinen Teil des Codes zu verändern, sondern darum, sich speziell auf das zu konzentrieren, was in Zeile 10 geschieht.

Na gut. Wir könnten einfach den Code 02 beibehalten und damit fertig werden, da er funktioniert. Sie können auch zu Code 01 zurückkehren, was ebenfalls funktioniert. Aber gibt es vielleicht eine andere Möglichkeit, die FOR-Schleife zur Lösung unseres Problems zu verwenden? In der Tat gibt es einen Weg. Es ist jedoch etwas fortgeschrittener als das, was ich an dieser Stelle der Serie behandeln möchte. Ich kann Ihnen jedoch einen anderen Ansatz zeigen. Dies wird das Ergebnis zumindest näher an das heranbringen, was wir erwarten, d. h. näher an das, was in Abbildung 01 dargestellt ist.

Unter Berücksichtigung aller bisher besprochenen Annahmen können wir also eine Version des Codes schreiben, die der unten gezeigten ähnelt.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
09. 
10.     for(info = info - 1; info; info = info - 1)
11.         Print(__FUNCTION__, " : ", info);
12. 
13.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
14. }
15. //+------------------------------------------------------------------+

Code 04

Dieser Code 04 fällt noch in den Bereich dessen, was ich als grundlegendes Material betrachte. Auch wenn wir beginnen, uns mit anderen Konzepten zu befassen, ist dies immer noch eine grundlegende Art, die FOR-Schleife zu verwenden. Damit soll sichergestellt werden, dass das Flussdiagramm, das wir uns gleich ansehen werden, sinnvoll ist. Wenn Sie diesen Code ausführen, erhalten Sie das folgende Ergebnis:

Abbildung 03

Moment, das verstehe ich nicht. Jetzt beginnt die Zählung bei neun, genau wie in Abbildung 01. Die Zählung bleibt jedoch bei eins stehen, genau wie in Abbildung 02. Warum? Könnte es sein, dass der Wert der Variablen „info“ nach dem Durchlauf der Schleife anders ist als der Wert in den anderen Codes, insbesondere in Code 01? Nein, lieber Leser. Der Wert der Variablen „info“ ist nach dem Durchlaufen der Schleife in all diesen Codes gleich Null und bleibt es auch. Hier geht es um etwas anderes. Was wir drucken, ist nicht der tatsächliche Endwert der Variablen „info“. Stattdessen wird der Wert während einer bestimmten Iteration der FOR-Schleife gedruckt. Das mag etwas verwirrend klingen, aber genau das ist der Fall. Um dies wirklich zu verstehen, müssen wir uns eine etwas andere Version des Codes ansehen. Doch bevor wir das tun, sollten wir uns den Ausführungsablauf innerhalb der FOR-Anweisung genauer ansehen. Wenden wir uns also einem neuen Thema zu.

Ablauf der Ausführung

Auf den ersten Blick mag der Ausführungsablauf der FOR-Schleife etwas verwirrender erscheinen als die anderen Schleifen, die wir untersucht haben. Wenn man dies jedoch einmal verstanden hat, wird es viel einfacher zu verstehen, warum wir im vorherigen Thema so unterschiedliche Ergebnisse gesehen haben. Das Flussdiagramm sehen Sie unten:

Abbildung 04

Hier habe ich verschiedene Farben für die Pfeile verwendet, um die Funktionsweise der FOR-Schleife im Detail zu erklären. Sie werden vielleicht überrascht sein, eine IF-Anweisung im Flussdiagramm zu sehen. Aber die Einbeziehung des IF hier macht es viel einfacher zu erklären, was vor sich geht.

Also gut, gehen wir Schritt für Schritt vor. Der erste Teil ist das reservierte Wort „for“, das den Beginn des Schleifenkörpers markiert. Gleich danach kommt Expression 01. Das kann vieles sein. Beachten Sie jedoch, dass sie nur einmal ausgeführt wird, nämlich beim Start der Schleife. Normalerweise verwenden wir Expression 01, um Variablen innerhalb der Schleife zu initialisieren. Wir können ihn aber auch verwenden, um einen globalen Wert anzupassen, wie wir es in Code 04 getan haben. Es ist erwähnenswert, dass der Ausdruck 01 auch leer bleiben kann, wie wir es bei den Codes 02 und 03 gesehen haben. In solchen Fällen überspringt der Compiler sie einfach und tut nichts: keine Initialisierung, keine Deklarationen. Für die Deklaration von Variablen gibt es einige spezielle Regeln, aber für den Moment werden wir die Dinge einfach halten. Wir werden also entweder globale Variablen verwenden oder den Ausdruck leer lassen.

Sobald Ausdruck 01 ausgeführt wurde, gehen wir zum nächsten Schritt über, der im Flussdiagramm als IF dargestellt ist. An dieser Stelle wird der Ausdruck 02 überprüft. Streng genommen wäre es genauer, dies als WHILE und nicht als IF darzustellen. Da WHILE jedoch selbst eine Schleifenanweisung ist, könnte es verwirrend sein, sie in einem Diagramm darzustellen, das FOR erklärt. Wenn Ausdruck 02 den Wert false hat, wird die Schleife abgebrochen. Wenn der Wert wahr ist, wird der Codeblock innerhalb der Schleife ausgeführt. Bei den Codes 03 und 04 wäre dies die Zeile 11, bei Code 02 der Block von Zeile 11 bis 14. Nachdem der Schleifenkörper ausgeführt wurde, gehen wir zu Ausdruck 03 über. Dieser Teil ist in vielen Situationen sehr interessant, wie wir gleich sehen werden. Je nachdem, wie die Schleife strukturiert ist und welchem Ziel sie dient, können wir viele leicht unterschiedliche Versionen dieser Struktur erstellen. Was Expression 03 besonders wertvoll macht, ist die Tatsache, dass er die FOR-Schleife sicherer macht als die anderen Schleifentypen, wenn er verwendet wird. So laufen Sie nicht Gefahr, zu vergessen, die in Expression 02 überprüfte Variable zu aktualisieren.

Um ehrlich zu sein, ist dieses Flussdiagramm in der Praxis viel einfacher zu verstehen, als es in dieser Abbildung erscheint. Aber wenn Sie genau hinsehen, werden Sie feststellen, dass ich einige grüne Pfeile verwendet habe. Diese grünen Pfeile zeigen an, wie die Schleife verläuft. Die roten Pfeile hingegen zeigen, wie die Schleife endet.

Wenn Sie also genau hinschauen und sich einen Moment Zeit nehmen, um zu analysieren, werden Sie feststellen, dass es tatsächlich Sinn macht, dass die Variable „info“ nach dem Durchlaufen der Schleife den Wert Null hat. Aber es macht auch Sinn, dass der Wert, den wir im Terminal sehen (wenn wir Code 03 betrachten), immer info + 1. In allen anderen Versionen des Codes ist das gedruckte Ergebnis ganz anders, als wir es zunächst erwartet hätten.

Cool. Ich glaube, ich beginne, diese FOR-Schleife zu verstehen. Es scheint wirklich etwas Einfaches zu sein, mit dem man arbeiten kann, obwohl es manchmal etwas verwirrend sein kann. Aber unter uns: Wir haben bereits erwähnt, dass das IF im Flussdiagramm eigentlich ein WHILE sein sollte. Wie können wir das erreichen? Lassen Sie es mich erklären. Dieser Punkt ist - zumindest aus meiner Sicht - relativ einfach zu verstehen, auch ohne sich mit fortgeschrittenen Details der FOR-Schleife zu befassen. Ja, es gibt kompliziertere Aspekte, insbesondere für Anfänger. Aber wenn Sie verstehen wollen, warum ich gesagt habe, dass das IF im Flussdiagramm eigentlich ein WHILE sein sollte, vergleichen Sie einfach Code 01 und Code 02. Da die Ausdrücke 01 und 03 leer sind, ist das Einzige, was dort wirklich funktioniert, die Schleifenbedingung, die im Grunde genommen der Funktionsweise einer WHILE-Schleife entspricht. Deshalb habe ich erwähnt, dass dieses IF im Flussdiagramm eigentlich ein WHILE darstellen sollte.

Ich weiß nicht, ob Sie das bemerkt haben, liebe Leserin, lieber Leser, aber ich tue mein Bestes, um noch nicht zu tief in fortgeschrittene FOR-Loop-Themen einzutauchen. Ich möchte nämlich nicht, dass dieser erste Kontakt mit der FOR-Schleife zu etwas Entmutigendem wird. Ich möchte jedoch nicht, dass Sie denken, die FOR-Schleife sei unnötig oder könne jederzeit durch WHILE oder DO WHILE ersetzt werden. Um das zu beweisen, zeige ich Ihnen eine Situation, in der Sie sie nicht einfach auswechseln können. Aber darauf gehen wir im nächsten Abschnitt ein.

Die leere FOR-Schleife

Was wir gleich sehen werden, sollte eher als Kuriosität betrachtet werden und nicht als etwas, das man in der Praxis anwenden sollte. Ehrlich gesagt, wird das, was ich Ihnen hier zeige, in echtem Code nur selten verwendet. Ich bin jetzt seit vielen Jahren Programmierer und kann an einer Hand abzählen, wie oft ich diese Technik angewendet habe. Dennoch könnten Sie eines Tages über eine sehr ungewöhnliche FOR-Schleife stolpern - eine, die seltsam aussieht, aber dennoch funktioniert. Und weil wir wahrscheinlich eine ganze Weile nicht mehr darüber sprechen werden und Sie vielleicht früher als erwartet darauf stoßen, muss ich es Ihnen jetzt zeigen. Sonst könnte ich es vergessen. Um zu erklären, wovon ich spreche, beginnen wir mit einem sehr einfachen Codeschnipsel. Und wir werden besonders vorsichtig sein, um keine Probleme zu bekommen. Als wir die WHILE-Schleife besprachen, haben wir einen Code wie den folgenden verwendet:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     do
09.     {
10.         if (((info / 5) * 5) == info) Print("Press ESC to finish counting...");
11.         info = info - 1;
12.         Sleep(200);
13.         Print(__FUNCTION__, " : ", info);
14.     }while (!TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE));
15. 
16.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
17. }
18. //+------------------------------------------------------------------+

Code 05

Der Zweck dieses Codes war es, eine Art Endlosschleife mit einem klar definierten Ausgang zu schaffen: der ESC-Taste. Großartig. Es ist jedoch auch möglich, eine völlig leere FOR-Schleife für den gleichen Zweck zu verwenden - um eine Endlosschleife zu erzeugen. Um dies zu veranschaulichen, verwenden wir den unten stehenden Code:

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char info = 10;
07. 
08.     for (; ; )
09.     {
10.         if (((info / 5) * 5) == info) Print("Press ESC to finish counting...");
11.         info = info - 1;
12.         Sleep(200);
13.         Print(__FUNCTION__, " : ", info);
14.         if (TerminalInfoInteger(TERMINAL_KEYSTATE_ESCAPE)) break;
15.     }
16. 
17.     Print(__FUNCTION__, " ", __LINE__, " It will be executed anyway...");
18. }
19. //+------------------------------------------------------------------+

Code 06

Passen Sie jetzt gut auf, denn ich werde das nicht wiederholen. Wenn Sie sich die vorangegangenen Beispiele in diesem Artikel ansehen, werden Sie feststellen, dass sie alle eine Bedingung im so genannten Ausdruck 02 enthalten. Dadurch konnte die FOR-Schleife schließlich abgebrochen werden. Es gibt jedoch Situationen, in denen die FOR-Schleife nicht abgebrochen werden darf, zumindest nicht aufgrund einer Bedingung im Schleifenkopf selbst. In diesem Fall können Sie den Ausdruck 02 leer lassen. Wenn dies geschieht, wird die Schleife nicht beendet, zumindest nicht aufgrund einer in der Schleifenstruktur angegebenen Bedingung. Wenn eine Bedingung vorhanden ist, wird sie in die Schleifenroutine eingefügt. Wie in Code 06 gezeigt, wird die Bedingung zum Verlassen der Schleife in Zeile 14 definiert. Im Gegensatz zu dem, was viele annehmen (dass eine FOR-Schleife eine Form von Ausdruck enthalten muss), ist dies nicht der Fall. Eine FOR-Schleife kann genau so geschrieben werden, wie in Code 06 in Zeile acht gezeigt. Wenn Sie dies tun, interpretiert der Compiler dies als eine Endlosschleife. Und jeder erfahrene Programmierer wird dies auch verstehen.

Deshalb habe ich, als wir über Schleifen mit der WHILE-Anweisung sprachen, erwähnt, dass Schleifen mit Vorsicht zu genießen sind. Wenn Sie nicht aufpassen, können Sie ein ernsthaftes Problem in Ihrem Code bekommen. Seien Sie also immer achtsam, wenn Sie Schleifen erstellen.

Um zu beweisen, dass Code 06 funktioniert und nicht in eine unkontrollierte Endlosschleife gerät, ist das Ergebnis der Ausführung in der folgenden Animation zu sehen:

Animation 01

Dennoch (und das sage ich der Klarheit halber) erwähne ich dies, damit Sie nicht in Panik geraten oder sich fragen, was los ist, wenn Sie auf ein Stück Code mit einer leeren FOR-Schleife stoßen. Denn jetzt sollten Sie verstehen, was passieren wird und wie die Schleife schließlich beendet wird - wenn sie überhaupt beendet wird.

Abschließende Überlegungen

In diesem Artikel haben wir die Grundlagen der FOR-Schleife behandelt. Alles, was Sie hier gesehen haben, muss gründlich verstanden werden. Im Gegensatz zu anderen Befehlen weist die FOR-Schleife einige Besonderheiten auf, die sie schnell recht komplex machen können. Lassen Sie also nicht zu, dass sich solche Dinge ansammeln. Beginnen Sie zu lernen und zu üben, was Sie hier gelernt haben. Gehen Sie dazu die Beispiele aus früheren Artikeln noch einmal durch und versuchen Sie, sie anzupassen, indem Sie die vorhandenen Schleifen durch FOR-Schleifen ersetzen, wo immer dies möglich ist.

Da dies die letzte grundlegende Kontrollstruktur war, die wir zu behandeln hatten, wird alles, was von nun an folgt, auf den grundlegenden Konzepten aufbauen, die wir bis jetzt erforscht haben. Dennoch sind wir noch nicht bereit, zu den mittleren Themen überzugehen, denn es gibt noch einige grundlegende Konzepte zu besprechen, die genauso wichtig sind wie das, was Sie bisher gelernt haben. Ich fühle mich jetzt jedoch wohler, wenn ich etwas fortgeschrittenere Programmiertechniken einführe. Dies wird es uns ermöglichen, die übrigen grundlegenden Themen effektiver zu präsentieren, ohne die gleichen Einschränkungen wie zuvor.

Studieren Sie also das gesamte Material, das wir behandelt haben, gründlich. Wir sehen uns im nächsten Artikel wieder. Ich wünsche Ihnen alles Gute für Ihr Studium!