Für alle drei Arten von Schleifen, for Schleife, while Schleife und do-while Schleife existieren noch zwei wichtige Anweisungen, nämlich break und continue.

Die break Anweisung steht irgendwo im Schleifenrumpf meist in Verbindung mit einer if Abfrage. Läuft das Programm in sie hinein, bricht sie die Schleife ab. Stößt man im bei der Abarbeitung der Schleife auf eine break Anweisung wird die Schleife ohne weiteres verlassen und das Programm danach vortgesetzt. Sinn der break Anweisung ist es also, die Schleife abzubrechen, wenn ein bestimmter Zustand eintritt, ohne eine Orgie von if ... else... Abfragen einbauen zu müssen. Hier ein Beispiel, in dem ein mögliche Fehler, die Quadratwurzel einer negativen Zahl, abgefangen und die Schleife dann beendet wird:

#include <stdio.h> // für printf
#include <math.h> // für sqrt

int i, x = 55;
double x;

for(i = 100; i > -x; i--)
{
   if(i + 10 < 0) // wenn i + 10 kleiner Null dann...
   {
      printf("Keine Ahnung von komplexen Zahlen... Schleife wird abgbrochen\n");
      break;
   }

   x = sqrt(i + 10); // sqrt - square root - die Quadratwurzel von i + 10
}

Bei geschachtelten Schleifen bezieht sich break natürlich nur auf die aktuelle Schleife. Wenn man die übergeordneten Schleifen auch mit abbrechen will, muß man sich was ausdenken, in etwa so:

int i, j, k, done = 0;

for(i = 0; i < 100; i++)
{
   if(done)
      break;

   for(j = 0; j > -10; j--)
   {
      if(done)
         break;
      for(k = -10; k < 10; k++)
      {
         if(i * j * k < 0)
         {
            done = 1;
            printf("break in i: %d j: %d k: %d\n", i, j, k) ;
            break;
         }
         printf("still looping i: %d j: %d k: %d\n", i, j, k);
      }
   }
}

Die letzten 5 Zeilen des Outputs lauten:

still looping i: 1 j: -1 k: -3
still looping i: 1 j: -1 k: -2
still looping i: 1 j: -1 k: -1
still looping i: 1 j: -1 k: 0
break in i: 1 j: -1 k: 1

Die continue Anweisung springt weiter zum Anfang der Schleife, überspringt also die Anweisungen, die zwischen continue und dem Schleifenende liegen. Der Zweck der continue Anweisung ist es, auf einfache Art die weitere Ausführung des Schleifenrumpfes bis zum nächsten Durchgang zu unterbrechen. Im Gegensatz zu break, wird die Schleife nicht verlassen. Hier ein Beispiel:

int i = 0, x = 0;

while(i < 100)
{
   i++;

   if( (i > 9) && (i < 21) ) // i liegt zwischen 10 und 20
      continue;
   if( (i > 59) && (i < 71) ) // i liegt zwischen 60 und 70
      continue;
   if( (i > 79) && (i < 91) ) // i liegt zwischen 80 und 90
      continue;

   // Summation; wird nur ausgeführt, wenn i nicht zwischen 10 - 20, 60 - 70 und 80 - 90 liegt
   x = x + i;
}

Sowohl break als auch continue dürfen mehrmals an verschiedenen Stellen in der Schleife stehen, hier liegt, wie im Beispiel eben zu sehen, auch der Vorteil.

Endlosschleifen:

Zum einen gibt es ungewollte Endlosschleifen, man programmiert einen logischen Fehler in die Schleife, startet das Programm und wundert sich ein paar Minuten lang, dass nichts mehr passiert. Das Programm muß man dann leider abschießen. Dann startet man es neu, entweder im Debugger, oder mit printf Anweisungen an verschiedenen Stellen und findet dann z.B. so etwas:

int i;

for(i = 0; i < 100; i++)
{
...
   if(i == 42)
      i = 0;// hoppala
...
}

oder etwa so:

int i = 0;

while(i < 100)
{
...
   if( i == 42)
      continue;
...
   i++; // bis i zum ersten mal 42 wurde, ging das noch gut, danach wird i++ nie wieder ausgeführt
}

Dann gibt es noch beabsichtigte Endlosschleifen, dem Programmierer ist keine Abbruchbedingung eingefallen (oder zu viele). Diese müssen dann mit einer oder mehreren break Anweisungen beendet werden:

int x = 0; y = 0, z;

for(; ; ) // endlose for Schleife
{
   z = z + (x * y);
   x++;
   y--;
   z += 10;

   if(z > 1000)
      break;
   if(z < -2000)
      break;
   if(i > 100)
      break;
   if(y < -200)
      break;
}

oder:

char c;

while(1) // endlose while Schleife; 1 ist immer wahr
{
   if(c = getchar() == 'q') // hat der Benutzer q eingetippt?
      break;
}

 

Alle drei Schleifenarten, for while und do-while, ebenso wie break, continue und Endlosschleifen werden Sie des öfteren benutzen, machen Sie sich also damit vertraut.

Folgender Fehler kommt bei der Programmierung von Schleifen machmal vor, ich habe ihn selber schon oft genug gemacht, deshalb hier der Hinweiß:

int i;

for(i = 0; i < 666; i++);
{
...
}

Sehen Sie es? Hinter for(i = 0; i < 666; i++) steht noch ein Semikolon ;! Das heist lieber Compiler, lasse doch mal in einer Schleife i von Null bis 666 laufen, danach führe dann diesen seltsamen alleine stehenden Block in geschweiften Klammern aus (ein mal). Dies ist aber korrekter C Kode, kein Syntaxfehler. Es ist aber wahrscheinlich nicht dass, was Sie eigentlich tun wollten, deshalb bekommen Sie hoffentlich eine Warnung von Compiler, es sei denn Sie haben den warning level des Compilers sehr niedrig eingestellt.

Wenn Sie unbedingt Windows programmieren wollen (oder müssen) dann ist der Petzold auf jeden Fall das richtige: