10.8 Die while-Schleife 

Mit Schleifen können Sie Anweisungsblöcke mehrfach hintereinander ausführen lassen. Das Grundgerüst der Schleifenbedingung while sieht folgendermaßen aus:

while(Bedingung == wahr) {
   /* Abarbeiten von Befehlen bis Bedingung ungleich wahr */
}

Ist die Bedingung, die in den Klammern nach while folgt, wahr, so wird der Anweisungsblock in geschwungenen Klammern (oft auch »curly brackets« genannt) ausgeführt. Diese Anweisungen werden sooft ausgeführt, bis die Bedingung in den Klammern falsch, also unwahr ist. Den zugehörigen Programmablaufplan sehen Sie in Abbildung 10.9.

Üblicherweise läuft die while-Schleife in drei Schritten ab:

Initialisierung – die Schleifenvariable bekommt einen Wert.

Bedingung – die Schleifenvariable wird daraufhin überprüft, ob eine bestimmte Bedingung bereits erfüllt ist.

Reinitialisieren – die Schleifenvariable erhält einen anderen Wert.

Hier klicken, um das Bild zu Vergrößern

Abbildung 10.9   Programmablaufplan der while-Schleife

In der Praxis sieht dies etwa so aus:

int var=0;           // Initialisieren
while(var < 10) {    // Solange var kleiner als 10 – Bedingung
      // weitere Anweisungen
      var++;         // Reinitialisieren
   }

Jetzt folgt ein Listing mit einer while-Schleife:

/* while1.c */
#include <stdio.h>
int main(void) {
   int zahl=1, tmp=0;
   while(zahl <= 10) {
      tmp=tmp+zahl;
      printf("%d+",zahl++);     /* Zahl + 1 */
   }
   printf("\b = %d\n",tmp);
   return 0;
}

Das Programm führt die while-Schleife so lange aus, bis die Variable zahl kleiner oder gleich 10 ist. Hier ein kurzer Durchgang des Programms Schritt für Schritt:

while(zahl<=10)

Ist die Zahl kleiner oder gleich 10? Die Zahl hat den Wert 1, also wird in den Anweisungsblock gesprungen. Hier wird zuerst die Addition tmp=tmp+zahl durchgeführt. Somit ist der Wert von tmp 1. Jetzt wird die Variable zahl um 1 erhöht (zahl++). Der while-Anweisungsblock endet, und das Programm springt zurück zum Anfang der while-Anweisung. Es erfolgt eine erneute Überprüfung daraufhin, ob die Zahl immer noch kleiner oder gleich 10 ist. Da sie jetzt den Wert 2 hat, geht es wie vorher schon im Anweisungsblock weiter. Das wird so lange wiederholt, bis zahl den Wert 11 erreicht hat. Denn dann ist die Bedingung, ob zahl kleiner oder gleich 10 ist, falsch (unwahr). Das Programm läuft nach dem while-Anweisungsblock weiter und gibt das Ergebnis 55 aus.

10.8.1 Endlosschleife (while) 

Die while-Schleife wird oft absichtlich in Form einer Endlosschleife implementiert. Für die Beendung einer Endlosschleife sorgt dann nicht die Schleifenbedingung, sondern das Schlüsselwort break. Mit der break-Anweisung können Sie die Schleife jederzeit verlassen. Ein Beispiel einer Endlosschleife:

/* while2.c */
#include <stdio.h>
int main(void) {
   int zahl, summe=0;
   printf("Summenberechnung\nBeenden der Eingabe mit 0 \n");
   while(1) {    /* Endlosschleife, weil: 1 ist immer wahr */
      printf("Bitte Wert eingeben > ");
      scanf("%d", &zahl);
      if(zahl == 0)    /*  Haben wir 0 eingegeben ...?   */
         break;        /* ... dann raus aus der Schleife */
      else
         summe+=zahl;
   }
   printf("Die Summe aller Werte beträgt: %d\n", summe);
   return 0;
}

Die Zeile

while(1)

verkörpert die Endlosschleife. Der Inhalt dieser Schleife ist immer wahr, da Sie hier den Wert 1 haben. Sie könnten dort jede beliebige Zahl außer 0 hinschreiben. Sie haben in den vorangegangenen Kapiteln gesehen, dass 1 (und alle anderen Werte ungleich 0) für »wahr« (true) und 0 für »unwahr« (false) steht.

Zurück zu dem Programm. Sie werden so lange aufgefordert, eine Zahl einzugeben, bis Sie den Wert 0 verwenden:

if(zahl == 0)    /*  Falls 0 eingegeben wurde ... */
   break;        /*  ... dann Schleife verlassen  */

Hat die Variable zahl den Wert 0, wird mit der Anweisung break aus dem Anweisungsblock herausgesprungen.

10.8.2 Fehlervermeidung bei while-Schleifen 

Natürlich können Sie mit Schleifen auch diverse Fehler machen. Im Folgenden sollen daher einige häufig auftretende Fehler angesprochen werden.

Schließen Sie eine Schleife niemals mit einem Semikolon ab. Folgendes Beispiel erzeugt ungewollt eine Endlosschleife:

int x=0;
while(x > 10); /* Fehler durch Semikolon am Ende */
   {
      printf("Der Wert von x beträgt %d\n", x);
      x++;
   }

Die Variable x wird niemals im Anweisungsblock inkrementiert werden, da die while-Schleife nichts anderes tut, als ständig die Bedingung zu prüfen, ob x größer als 10 ist.

Vermeiden Sie außerdem – wenn möglich – Überprüfungen auf Gleichheit in den Schleifen:

int x=2;
while(x == 10) {
   printf("Der Wert von x beträgt %d \n", x);
   x*=x;
}

Die Bedingung der while-Schleife wird nie erfüllt. Verwenden Sie in einem solchen Fall besser die Überprüfung auf kleiner oder gleich, etwa wie folgt:

while(x <= 10)

Eine weitere Fehlerquelle können die logischen Operatoren in der while-Schleife darstellen, wie das folgende Programmbeispiel verdeutlicht:

/* while3.c */
#include <stdio.h>
int main(void) {
   int zahl1=0, zahl2=0;
   while((zahl1++ < 5) || (zahl2++ < 5) )
      printf("Wert von zahl1: %d zahl2: %d \n ", zahl1, zahl2);
   return 0;
}

Da hier der erste Ausdruck fünfmal wahr ist, wird wegen des logischen ODER-Operators der zweite Ausdruck nicht ausgewertet. Erst wenn also der erste Ausdruck unwahr, also 5 ist, wird der zweite Ausdruck fünfmal durchlaufen. Als Nebeneffekt wird aber gleichzeitig der erste Ausdruck bei jedem Schleifendurchlauf inkrementiert. Und so kommt es, dass die Variable zahl1 am Ende den Wert 10 hat, statt 5 wie ursprünglich beabsichtigt.