Schleifen

Schleifen ermöglichen es, Code beliebig oft zu wiederholen. Ähnlich wie bei einer Verzweigung kann mithilfe einer Abbruchbedingung festgelegt werden, wie oft der Code wiederholt werden soll.

Hier ist ein einfaches Beispiel: In einem Programm sollen die Zahlen von 0 bis 10 ausgegeben werden, ohne dass der Code für die Ausgabe jeder Zahl zehnmal geschrieben werden muss. Sobald alle Zahlen ausgegeben wurden, wird dies in der Kommandozeile angezeigt.

Das Diagramm veranschaulicht, wie das Programm funktioniert. Jetzt können wir diesen Plan in ein C-Programm umsetzen:

#include <stdio.h>

int main() {
    int zahl = 0;

    // Schleife mit Abbruchbedingung
    while (zahl <= 10) {
        // Der Wert der Variablen "zahl" wird hier ausgegeben.
        printf("%d \n", zahl);
        // Die Variable "zahl" wird um eins erhöht.
        ++zahl;
    }
    
    // Nachdem alle Zahlen ausgegeben wurden und die Schleife verlassen wird, 
    // wird dies auf der Kommandozeile mitgeteilt.
    printf("\nAlle Zahlen wurden ausgegeben. \n");

    return 0;
}

In der Programmierung sind Abbruch-Bedingungen und Zählvariablen sehr wichtig, vor allem bei Schleifen. Lass uns genauer betrachten, wie diese Konzepte funktionieren.

Abbruch-Bedingung

Die Abbruch-Bedingung legt fest, wann eine Schleife beendet wird. Denk zum Beispiel an unser vorheriges Beispiel, bei dem wir die Zahlen von 0 bis 10 ausgeben wollten. Die Abbruch-Bedingung war ganz einfach: Solange die Zahl kleiner oder gleich 10 ist (zahl <= 10), wird die Schleife weitergeführt. Sobald diese Bedingung nicht mehr erfüllt ist, wird die Schleife beendet, und das Programm setzt seinen Ablauf fort.

Zählvariable (Counter)

Die Zählvariable, die oft auch als "Counter" bezeichnet wird, ist eine Variable, die in einer Schleife verwendet wird, um den Fortschritt der Schleife zu verfolgen. In unserem Beispiel haben wir die Variable "zahl" als Zählvariable genutzt, und bei jedem Durchlauf der Schleife haben wir sie um eins erhöht (++zahl). Das sorgt dafür, dass die Schleife bei jedem Durchgang mit einer neuen Zahl arbeitet, bis die Abbruch-Bedingung nicht mehr erfüllt ist.

Endlos-Schleifen

Wenn eine Schleife keine korrekte Abbruch-Bedingung hat oder die Zählvariable nicht richtig aktualisiert wird, führt dies zu einer sogenannten "Endlos-Schleife". In einer Endlos-Schleife wiederholt sich der Schleifenkörper endlos, ohne jemals zu stoppen. Das kann dazu führen, dass das Programm nicht mehr reagiert und möglicherweise abstürzt.

In C gibt es drei unterschiedliche Formen von Schleifen. Im folgenden Abschnitt werden wir genauer auf diese drei Schleifentypen eingehen.

while

While ist eine Art von Schleife in der Programmierung, die als "kopfgesteuert" bezeichnet wird. Dies bedeutet, dass die Abbruch-Bedingung am Anfang der Schleife überprüft wird, bevor der Code ausgeführt wird. Diese Überprüfung erfolgt also, bevor der Code innerhalb der Schleife überhaupt erreicht wird.

#include <stdio.h>

int main() {
    int zahl = 0;

    while (zahl <= 10) {
        printf("%d \n", zahl);
        ++zahl;
    }

    printf("\nAlle Zahlen wurden ausgegeben. \n");

    return 0;
}

In deinem gezeigten Beispiel verwenden wir eine while-Schleife, um die Zahlen von 0 bis 10 auszugeben. Hier ist, wie es funktioniert:

Zuerst wird eine Variable namens zahl mit dem Wert 0 initialisiert. Diese Variable dient als Zählvariable, die den Fortschritt der Schleife verfolgt.
Dann beginnt die while-Schleife. Sie überprüft zuerst die Abbruch-Bedingung, die in diesem Fall lautet: zahl <= 10. Das bedeutet, dass die Schleife solange ausgeführt wird, wie zahl kleiner oder gleich 10 ist.
Wenn die Abbruch-Bedingung zu Beginn erfüllt ist (was in diesem Fall der Fall ist, da zahl am Anfang 0 ist), wird der Schleifenkörper ausgeführt. Im Schleifenkörper wird die aktuelle Zahl (den Wert von zahl) ausgegeben und dann wird zahl um eins erhöht (++zahl).
Nachdem der Schleifenkörper ausgeführt wurde, geht die Kontrolle zurück zur Abbruch-Bedingung. Die Bedingung wird erneut überprüft. Solange die Bedingung wahr (true) ist, wird der Schleifenkörper erneut ausgeführt, und dieser Prozess wiederholt sich, bis die Bedingung nicht mehr wahr ist.
Sobald zahl den Wert 11 erreicht (weil wir es bei jedem Durchgang um eins erhöhen), wird die Bedingung zahl <= 10 nicht mehr erfüllt, und die Schleife wird beendet.
Schliesslich wird die Ausführung des Programms fortgesetzt, und die Meldung "Alle Zahlen wurden ausgegeben." wird angezeigt.

Diese Art von Schleife ist sehr nützlich, wenn du eine Aktion mehrmals ausführen möchtest, solange eine bestimmte Bedingung erfüllt ist. Sie stellt sicher, dass der Schleifenkörper nur dann ausgeführt wird, wenn die Abbruch-Bedingung von Anfang an wahr ist.

do-while

Die do-while-Schleife ist ein weiteres grundlegendes Konzept in der Programmierung und unterscheidet sich von der zuvor besprochenen while-Schleife. Hierbei handelt es sich um eine "fussgesteuerte" Schleife, was bedeutet, dass die Abbruch-Bedingung erst nach der Ausführung des Schleifenkörpers überprüft wird. Lass uns dieses Konzept anhand eines Beispiels in C genauer betrachten:

#include <stdio.h>

int main() {
    int zahl = 0;

    do {
        printf("%d \n", zahl);
        ++zahl;
    } while (zahl <= 10);

    printf("\nAlle Zahlen wurden ausgegeben. \n");

    return 0;
}

Hier erklären wir Schritt für Schritt, wie die do-while-Schleife funktioniert:

Zuerst wird die Variable zahl mit dem Wert 0 initialisiert. Diese Variable dient wieder als Zählvariable, um den Fortschritt der Schleife zu verfolgen.
Die do-while-Schleife beginnt immer mit der Ausführung des Schleifenkörpers, bevor die Abbruch-Bedingung überprüft wird. Das bedeutet, dass der Schleifenkörper mindestens einmal ausgeführt wird, unabhängig von der Bedingung.
Im Schleifenkörper wird die aktuelle Zahl (den Wert von zahl) ausgegeben, und dann wird zahl um eins erhöht (++zahl).
Nachdem der Schleifenkörper ausgeführt wurde, geht die Kontrolle zur Abbruch-Bedingung über, die in diesem Fall zahl <= 10 ist.
Solange die Bedingung wahr ist, wird der Schleifenkörper erneut ausgeführt, und dieser Prozess wiederholt sich. Die Schleife wird so lange wiederholt, wie die Bedingung erfüllt ist.
Sobald zahl den Wert 11 erreicht (weil wir es bei jedem Durchgang um eins erhöhen), wird die Bedingung zahl <= 10 nicht mehr erfüllt, und die Schleife wird beendet.
Schliesslich wird die Ausführung des Programms fortgesetzt, und die Meldung "Alle Zahlen wurden ausgegeben." wird angezeigt.

Die do-while-Schleife ist besonders nützlich, wenn du sicherstellen möchtest, dass die Schleife mindestens einmal ausgeführt wird, bevor die Abbruch-Bedingung überprüft wird.

for

Die for-Schleife funktioniert ähnlich wie die while-Schleife, aber es gibt einen entscheidenden Unterschied: Im Kopf der for-Schleife können zusätzliche Bedingungen festgelegt werden. Der Aufbau des Schleifenkopfes in einer for-Schleife sieht folgendermassen aus:

for( initialisierung; bedingung; inkrement)

An erster Stelle in der for-Schleife befindet sich die Initialisierung der Zählvariable. Dies ist der Ausgangswert, von dem aus die Zählvariable startet.
An zweiter Stelle steht die Abbruchbedingung. Diese Bedingung wird, ähnlich wie bei der while-Schleife, vor jedem Schleifendurchlauf überprüft. Solange diese Bedingung wahr ist, wird der Schleifenkörper ausgeführt.
An dritter Stelle wird das Inkrement festgelegt. Dieser Schritt definiert, wie die Zählvariable nach jedem Schleifendurchlauf aktualisiert wird. Typischerweise wird die Zählvariable um eins erhöht, aber du kannst hier auch andere Werte verwenden, je nach den Anforderungen deines Programms.

#include <stdio.h>

int main() {

    int i;

    for ( i = 0; i <= 10; i++) {
        printf("%d \n", i);
    }
    printf("\nAlle Zahlen wurden  
    ausgegeben.");

    return 0;
}

Hier wird das Beispiel genau erklärt:

Zuerst wird eine Variable i deklariert und mit dem Wert 0 initialisiert. Diese Variable dient als Zählvariable, die den Fortschritt der Schleife überwacht.
Die for-Schleife beginnt mit der Initialisierung, gefolgt von einem Semikolon ;. Hier wird i auf 0 gesetzt.
Nach der Initialisierung kommt der Bedingungsteil, ebenfalls gefolgt von einem Semikolon ;. In diesem Fall ist die Bedingung i <= 10. Das bedeutet, dass die Schleife solange ausgeführt wird, wie i kleiner oder gleich 10 ist.
Der letzte Teil der for-Schleife ist der Aktualisierungsteil, hier i++. Dies bedeutet, dass i nach jedem Durchgang der Schleife um eins erhöht wird.
Der Schleifenkörper, der von geschweiften Klammern {} umgeben ist, wird jedes Mal ausgeführt, wenn die Bedingung (hier i <= 10) wahr ist. Im Schleifenkörper wird die aktuelle Zahl (den Wert von i) ausgegeben.
Nachdem der Schleifenkörper ausgeführt wurde, wird i um eins erhöht (durch i++).
Die Bedingung i <= 10 wird erneut überprüft. Solange sie wahr ist, wird der Schleifenkörper erneut ausgeführt, und dieser Prozess wiederholt sich, bis die Bedingung nicht mehr wahr ist.
Sobald i den Wert 11 erreicht, ist die Bedingung i <= 10 nicht mehr erfüllt, und die Schleife wird beendet.
Schliesslich wird die Ausführung des Programms fortgesetzt, und die Meldung "Alle Zahlen wurden ausgegeben." wird angezeigt.

Die for-Schleife ist besonders nützlich, wenn du genau weisst, wie oft du einen Codeblock ausführen möchtest. Sie erlaubt es, die Initialisierung, Bedingung und Aktualisierung in einer einzigen Zeile zu definieren, was den Code oft übersichtlicher macht.

Zusammenfassung

Schleifen sind in der Programmierung essenziell und erlauben die wiederholte Ausführung von Code. Sie verwenden eine Abbruch-Bedingung und eine Zählvariable, um den Ablauf zu steuern. Es gibt drei grundlegende Arten von Schleifen: while, do-while und for, die jeweils ihre eigenen Besonderheiten haben.

Quiz

Aufgaben

Die Aufgaben zu Schleifen sind auf GitHub zu finden.