1. Startseite
2. C
3. Schleifen

Schleifen

Schleifen werden in der Programmierung dazu verwendet, bestimmte Anweisungen wiederholt auszuführen.

while

Die einfachste Form der Schleife ist die "while"-Schleife. Die "while"-Schleife gehört zu den kopfgesteuerten Schleifen bei Ihr steht hinter dem Schlüsselwort "while" innerhalb von Klammern ein Ausdruck, der geprüft wird. Wenn der Ausdruck wahr ist, wird das Programm in den Schleifenkörper springen und die Anweisungen ausführen, und zwar so lange, bis der Ausdruck in den Klammern nicht mehr wahr ist. Der Schleifenkörper wird durch die geschweiften Klammern begrenzt.

Im Beispiel erstellen wir einen Countdown, der von "10" runter zählt.

int main() {
 int zahl = 10;
 while (zahl >= 0) {
  printf("%i\n", zahl);
  zahl--;
 }
}

Zuerst initialisieren wir die Variable "zahl". Das muss bereits außerhalb der "while"-Schleife passieren. Nach dem Schlüsselwort "while" wird der Ausdruck geprüft. Weil die Variable den Wert "10" hat und damit größer ist als der wert "0", wird das Programm die Anweisungen im Schleifenkörper ausführen. Die erste Anweisung gibt den Wert der Variable "zahl" mit einem abschließenden Zeilenumbruch aus. In der zweiten Anweisung wird der Wert der Variable "zahl" durch den, Dekrement um 1 verringert. Der neue Wert der Variable ist jetzt "9". Am Schleifenende wird der Ausdruck erneut geprüft und der Schleifenkörper wird solange durchlaufen, bis der Ausdruck nicht mehr zutrifft.

do-while

Eine ähnliche Schleife ist die "do-while"-Schleife. Sie gehört zu den fußgesteuerten Schleifen, weil der Ausdruck erst am Ende der Schleife und nicht am Anfang geprüft wird. Das ist nützlich, wenn sich der zu prüfende Ausdruck erste durch den Schleifendurchlauf ergibt. Wir zählen wieder einen Countdown runter.

int main() {
 int zahl = 10;
 do {
  printf("%i\n", zahl);
  zahl--;
 } while (zahl >= 0);
}

Sieht genauso aus wie die Ausgabe aus dem Beispiel vorher, aber ein entscheidender Unterschied ist zu beachten. Auch wenn der Ausdruck zu keiner Zeit zutrifft, zum Beispiel weil die Variable "zahl" den Wert "-50" hat, wird die "do-while"-Schleife mindestens 1-mal ausgeführt, weil die Prüfung des Ausdrucks erst nach dem Schleifendurchlauf erfolgt.

for

Eine andere kopfgesteuerte Schleife ist die "for"-Schleife. Sie wird häufig eingesetzt, wenn die genaue Anzahl der Durchläufe vorher feststeht. Bei Ihr erfolgt die Initialisierung genau einmal vor dem ersten Schleifendurchlauf. Die Syntax sieht folgendermaßen aus:

for (Initialisierung; Prüfung; Änderung) { Anweisungsblock }

Mit dem Schlüsselwort "for" wird die Schleife eingeleitet. Die Initialisierung der Variable wird als Erstes zwischen den runden Klammern angegeben. Darauf folgt der Ausdruck, der vor jedem Schleifendurchlauf geprüft wird. An dritter Stelle innerhalb der runden Klammern wird angegeben, was passieren soll, wenn die Schleife einen Durchlauf beendet hat. Dann wird wieder der Ausdruck geprüft und anschließend die Änderung vorgenommen, bis der Ausdruck nicht mehr zutrifft.

int main() {
 for (int zahl = 10; zahl>=0; zahl--) {
  printf("%i\n", zahl);
 }
}

Auch bei der "for"-Schleife stehen die Anweisungen für jeden Schleifendurchlauf zwischen den geschweiften Klammern.

Schleifen können auch ineinander verschachtelt werden, daraus ergeben sich meist völlig neue Möglichkeiten in der Programmierung. Ein häufiger Einsatz ist das Arbeiten mit Tabellenstrukturen. Wir erstellen als Beispiel das kleine "1 mal 1", indem wir eine Tabelle mit 10 x 10 Feldern ausgeben, in dem das Ergebnis einer Multiplikation von 2 Zahlen einfach abgelesen werden kann.

int main() {
 for (int multiplikator = 1; multiplikator<=10; multiplikator++) {
  for (int multiplikand = 1; multiplikand<=10; multiplikand++) {
   printf("%i\t", multiplikator * multiplikand);
  }
  printf("\n");
 }
}

 1  2  3  4  5  6  7  8	 9 10
 2  4  6  8 10 12 14 16	18 20	
 3  6  9 12 15 18 21 24	27 30	
 4  8 12 16 20 24 28 32	36 40	
 5 10 15 20 25 30 35 40	45 50	
 6 12 18 24 30 36 42 48	54 60	
 7 14 21 28 35 42 49 56	63 70	
 8 16 24 32 40 48 56 64	72 80	
 9 18 27 36 45 54 63 72	81 90	
10 20 30 40 50 60 70 80	90 100	

In der ersten Schleife wird der Multiplikator initialisiert und auf den Wert "1" gesetzt. Weil der Wert unter "10" liegt, geht die Schleife in den Schleifenkörper. Hier geht es direkt in die verschachtelte "for"-Schleife. Hier wird der Multiplikand initialisiert und auf den Wert "1" gesetzt. Auch hier liegt der Wert unter "10" und das Programm geht in den Schleifenkörper. Jetzt wird das Ergebnis der Multiplikation mit einem Tabulatorzeichen ausgegeben: "1x1=1". Weil die Schleife durchlaufen wurde, wird der Wert vom Multiplikanden auf 2 erhöht und die Schleife gibt das nächste Ergebnis aus ("1x2=2") usw. bis der Multiplikand den Wert "10" übersteigt. Ab hier stimmt der Ausdruck der verschachtelten Schleife nicht mehr und das Programm springt aus der verschachtelten Schleife raus, zurück auf die erste Schleife. Hier wird ein Zeilenumbruch ausgegeben. Die erste Schleife ist zum ersten Mal durchlaufen und setzt den Wert vom Multiplikator auf 2 hoch. Der Ausdruck der ersten Schleife ist noch erfüllt und das Programm geht in die nächste Schleife. Insgesamt gibt es 100 Schleifendurchläufe, die in 10 Reihen mit 10 Spalten das kleine 1 Mal 1 ausgeben.