Es gibt viele Aufgaben, in denen Befehle wiederholt werden sollen, bis ein bestimmtes Ergebnis erzielt worden ist. Eine solche Wiederholung nennt man in Programmen eine Schleife. Jede Form des Zählens wird im Programm in einer Schleife realisiert. In Computerspielen dürfen Sie so lange ballern, bis Ihr letztes Raumschiff abgeschossen wurde. Eine Schleife hat den Wiederholungscharakter, enthält aber auch immer eine Bedingung, unter der die Schleife verlassen wird, oder positiv formuliert: Die Schleife wird so lange durchlaufen, wie die Schleifenbedingung gilt.

Die beiden bisher gezeigten Schleifen benötigten drei Elemente:

• Eine Initialisierung vor Beginn der Schleife
• Eine Bedingung, unter der die Schleife durchlaufen wird
• Eine Aktion, die die Bedingung verändern kann

Fehlt eines dieser Elemente oder ist es nicht korrekt, dann ist das Risiko einer Endlosschleife groß. Die for-Schleife enthält alle drei Elemente in ihrem Kopf. So sind sie an einer Stelle zusammengefasst und können leichter unter Kontrolle gehalten werden.

Eine sehr typische Anwendung für Schleifen ist das Zählen; und gerade hier zeigt sich besonders die Übersichtlichkeit der for-Schleife. Das folgende Beispiel zählt von 0 bis 9.

for (i=0; i<10; i++)
{
    cout << i << endl;
}

In der Klammer, die dem Schlüsselwort for folgt, findet sich als Erstes eine Startanweisung, die die Variable i auf 0 setzt. Bei den while-Schleifen wurde diese Initialisierung vor der Schleife durchgeführt. Als Zweites ist die Schleifenbedingung zu erkennen. Die dritte Anweisung ist das Inkrementieren der Zählervariablen, die üblicherweise am Ende der Schleife steht. Diese drei Elemente werden je durch ein Semikolon getrennt.

Die for-Schleife ist der while-Schleife sehr ähnlich. Sie verpackt ihre Fähigkeiten nur eleganter und bewirkt, dass der Programmierer nicht so leicht wichtige Elemente vergisst. Sie könnten das obige Schema leicht auch als while-Schleife darstellen.

Startanweisung;
while ( Bedingung)
{
    Schleifenkörper;
    Schlussanweisung;
}

Entsprechend unterscheidet sich das Struktogramm nicht von dem der while-Schleife. Es wird lediglich inhaltlich der Kopf der Schleife in den Abfragebereich geschrieben.

Die einfachste Schleife wird durch das Schlüsselwort while eingeleitet. Die deutsche Übersetzung lautet »solange«.

Sie wiederholt Vorgänge, solange eine bestimmte Bedingung erfüllt ist.

Auch im Alltag verwenden wir solche Schleifen. Solange die Suppe noch nicht salzig genug ist, schüttet man noch einen Teelöffel Salz hinein. Und wie in diesem Beispiel zuerst der Salzgehalt geprüft wird, so prüft auch die while-Schleife zuerst die Bedingung und führt dann erst die Anweisung aus.

Der Syntax ähnelt sehr einer if-Anweisung. Und tatsächlich bestehen die Unterschiede nur darin, dass die Schleife die Anweisung wiederholt. Ist die Bedingung von vornherein nicht erfüllt, verhält sich die Schleife exakt wie die if-Anweisung - Sie führt die Anweisung nicht aus.

Die Schleife beginnt mit dem Schlüsselwort while. In Klammern folgt die Bedingung, unter der die direkt anschließende Anweisung ausgeführt wird. Auch hier können mehrere Anweisungen zu einem Anweisungsblock zusammengefasst werden, wenn sie in geschweiften Klammern stehen.

Als erstes Beispiel bringen wir dem Computer das Zählen bei. Denken Sie darüber nach, was Sie tun, wenn Sie zählen. Zunächst beginnen Sie bei einer bestimmten Zahl, typischerweise bei eins. Dann folgt die Wiederholung, in der Sie immer den bisherigen Wert um eins erhöhen. Da Sie auch irgendwann einmal etwas anderes tun wollen als zählen, werden Sie bei einem bestimmten Wert die Wiederholung abbrechen.

Im Programm verwenden Sie eine Variable, die Sie mit dem Startwert vorbesetzen. Dieser Startwert muss vor der Schleife gesetzt werden, sonst würde die Variable in jeder Runde auf ihren Ausgangspunkt zurück gesetzt, und die Schleife würde ewig rotieren. Danach soll das Programm in die Schleife eintreten, in der die Variable immer um eins erhöht wird. Die Schleife beginnt mit dem Schlüsselwort while. Direkt dahinter wird in Klammern die Bedingung formuliert. Solange diese Bedingung gilt, bleibt das Programm innerhalb der Schleife. Wenn Sie bis zehn zählen wollen, müssen Sie hier prüfen, ob die Variable kleiner oder gleich 10 ist. Direkt anschließend an die Bedingung können Sie eine Anweisung angeben, die in der Schleife wiederholt werden soll. Da Sie ja einerseits die Variable um eins erhöhen wollen und andererseits den aktuellen Stand auf dem Bildschirm ausgeben wollen, brauchen Sie aber zwei Anweisungen, die in der Schleife ausgeführt werden sollen. Das kann aber leicht mit einem Block, also geschweiften Klammern gelöst werden. In den Block wird also die Ausgabe der Variablen und die anschließende Erhöhung der Variablen gesetzt.

#include <iostream>
using namespace std;
int main()
{
    i = 1;
    while (i <= 10) // Schleifenbedingung
    {
        cout << i << endl;  // Aktion
        i++; // Ohne diese Erhöhung wird es eine Endlosschleife
    }
 
    return 0;
}

Leicht entstehen Fehler bei der Festlegung der Schleifengrenzen. Würden Sie statt ⇐ nur das Kleinerzeichen verwenden, würde das Programm nur bis neun zählen. Der Grund ist, dass sobald der Inhalt von i den Wert 10 erreicht, die Bedingung nicht mehr gilt und damit das Schleifeninnere nicht mehr betreten wird. Sie können auch eine Schleife bilden, die zehnmal durchläuft, indem Sie bei 0 beginnen und abfragen, ob die Variable kleiner als zehn ist. Dann würde die Variable i von 0 bis 9 laufen. Wenn Sie i allerdings vor der Ausgabe erhöhen, erhalten Sie wieder die Zahlen von 1 bis 10.

#include <iostream>
using namespace std;
int main()
{
    int i = 0;
    while (i < 10)
    {
        i++;
        cout << i << endl;
    }
    return 0;
}

Die while-Schleife prüft die Bedingung am Schleifenkopf. Das bedeutet, dass die Anweisungen in der Schleife gar nicht ausgeführt werden, wenn die Bedingung vor dem Betreten der Schleife unwahr ist.

Achten Sie besonders auf die Formulierung der Schleifenbedingung. Nicht nur Anfängern passiert es, dass die Schleife niemals endet, weil die Schleifenbedingung niemals unwahr wird. Eine solche Schleife wird Endlosschleife genannt. Eine andere Ursache für eine Endlosschleife kann darin bestehen, dass die Bedingung zwar richtig formuliert ist, aber dass der Programmierer vergisst, die Daten, die in der Bedingung abgefragt werden, innerhalb der Schleife zu ändern.

while (true)
{
 
}

In manchen Situationen ist die Prüfung am Kopf der Schleife ungünstig. Manchmal wollen Sie eine Aktion durchführen und werden erst an ihrem Ende erkennen können, ob die Aktion wiederholt werden soll. Ein Kind wird beispielsweise seinen Opa so lange um Süßigkeiten anbetteln, bis dieser keine mehr hat. (Erfahrene Eltern werden zu Recht einwerfen, dass die Abschlussbedingung von dem System Opa nicht eingehalten wird.) Das Kind wird in jedem Fall erst einmal betteln, ansonsten kann es die Bedingung gar nicht erst prüfen. In diesem Fall findet also die Prüfung erst nach dem Durchlauf des Schleifenkörpers statt.

In Programmen wird eine fußgesteuerte Schleife besonders bei Eingabeprüfungen eine typische Anwendung. Innerhalb der Schleife fordert das Programm vom Anwender eine Eingabe an. Erst dann wird geprüft, ob die Eingabe korrekt ist. Ist die Eingabe nicht zufriedenstellend, wird die Schleife wiederholt. Ein weiteres Beispiel ist das Spiel Minesweeper. Der Benutzer soll auf ein Feld klicken. Solange unter dem Feld keine Mine liegt, darf er weiterspielen. Sie können erst am Ende der Schleife feststellen, wohin der Benutzer geklickt hat.

Auch hier werden Sie in den meisten Fällen einen Block aus geschweiften Klammern verwenden, da eine Schleife meist mehrere Anweisungen umfasst.

Im folgenden Beispiel wird rückwärts gezählt. Betrachten Sie das Listing, und überlegen Sie, ob die Zahlen 10, 1 und 0 ausgegeben werden! Prüfen Sie, ob Ihre Vermutungen stimmen!

#include <iostream>
using namespace std;
 
int main()
{
    int i = 10;
    do
    {
        cout << i << endl;
        i--;
    }
    while(i>0);
 
    return 0;
}