Zählschleife

FOR Iterator:=Anfangszahl TO Endezahl STEP Schrittweite DO Schleifenrumpf.

Bei einer For-Schleife zählt der Computer von einer Anfangszahl bis zu einer Endzahl und wiederholt dabei jedes Mal den Codeblock („Schleifenrumpf“). Die aktuelle Zahl wird in eine Variable („Iterator“) gesetzt, damit sie bei Bedarf in dem Codeblock Verwendung finden kann. Häufig ist die Zählschleife auf Ganzzahlen beschränkt. Das Ändern der Iterator-Variablen im Schleifenkörper ist bei vielen Programmiersprachen verboten und gilt als schlechter Programmierstil, da es oft zu schwer verständlichem Code führt – es läuft der Denkweise zuwider, direkt am Schleifenkopf die Anzahl der Durchläufe ablesen zu können.

Kopfgesteuerte Schleife

WHILE Logischer Ausdruck DO Schleifenrumpf.

Bei einer kopfgesteuerten Schleife erfolgt die Abfrage der Bedingung, bevor der Schleifenrumpf ausgeführt wird, also am Kopf des Konstruktes. Eine logische Operation kann beispielsweise sein: (x > 4) Solange diese Bedingung wahr ist, werden die Anweisungen innerhalb der Schleife ausgeführt. Wird der Inhalt der logischen Operation nicht im Schleifenrumpf verändert, ist diese Kontrollstruktur meist nicht die richtige, weil diese Schleife sonst kein einziges Mal durchlaufen wird oder unendlich lang läuft.

Fußgesteuerte Schleife

DO Schleifenrumpf WHILE Logischer Ausdruck

bzw.

REPEAT Schleifenrumpf UNTIL Logischer Ausdruck

Bei einer fußgesteuerten Schleife erfolgt die Abfrage der Bedingung, nachdem der Schleifenrumpf ausgeführt wurde, also am Fuß des Konstruktes. Auf WHILE (dt.: solange) folgt eine Laufbedingung, auf UNTIL (dt.: bis) eine Abbruchbedingung. Wie für die kopfgesteuerte Schleife gilt: Wird der Inhalt der logischen Operation nicht im Schleifenrumpf verändert, ist diese Kontrollstruktur meist nicht die richtige, weil diese Schleife sonst genau einmal durchlaufen wird oder unendlich lang läuft.

Mengenschleife

FOREACH Element OF Menge DO Schleifenrumpf

Eine Mengenschleife führt den Schleifenrumpf für jedes Element einer Menge (z. B. Array oder Liste) aus.

Sie kann ersetzt werden durch eine Zählschleife mit dem Schleifenkörper

FOR Iterator2 := 1 TO Mächtigkeit(Menge) DO
  BEGIN
    Element:= Iterator2-tes Element von Menge;
    Schleifenrumpf
  END

Da die Reihenfolge der Abarbeitung bei der Mengenschleife beliebig ist, bleibt dem Compiler überlassen, wie er vorgeht. Aufgrund des sicher gegebenen Umstands, dass eine Iteration nicht von der „vorhergehenden“ abhängig sein kann, kann ein Compiler Mengenschleifen am einfachsten automatisch parallelisieren.

Iterationsabbruch

CONTINUE

bzw.

CONTINUE Schleifenbezeichner

Die erste Variante bricht die aktuelle Iteration ab, es geht weiter mit der Prüfung der Laufbedingung für die nächste Iteration. Die zweite Variante beendet in verschachtelten Schleifen alle inneren und wirkt wie die erste Variante für diejenige äußere Schleife, welche durch Schleifenbezeichner angesprochen wird. Oft kommt hier entweder ein Name ähnlich einer Sprungmarke zum Einsatz; in Zählschleifen erfolgt die Identifizierung mitunter über den Namen des Iterators.

Schleifenabbruch

BREAK

bzw.

BREAK Schleifenbezeichner

Die erste Variante bricht die aktuelle Schleife ab, es geht weiter mit der ersten Anweisung nach der Schleife. Die zweite Variante beendet in verschachtelten Schleifen alle inneren komplett sowie diejenige äußere Schleife, welche durch Schleifenbezeichner angesprochen wird. Oft kommt hier entweder ein Name ähnlich einer Sprungmarke zum Einsatz; in Zählschleifen erfolgt die Identifizierung mitunter über den Namen des Iterators.

For-Schleife

Es gibt mehrere Alternativen, For-Schleifen mit Hilfe einfacherer Befehle zu implementieren. Im Normalfall verhalten sich diese Alternativen gleich, aber in einigen speziellen Situationen gibt es Unterschiede. Beispiele für spezielle Situationen sind:

• Die Schrittweite ist 0 (nicht in allen Varianten der For-Schleife möglich).
• Der Startwert oder der Endwert sind die kleinst- oder größtmögliche darstellbare Zahl.

Eine ausführlichere Darstellung der Varianten befindet sich im Artikel For-Schleife.

While-Do-Schleife

WHILE Logischer Ausdruck DO Befehlssequenz.

entspricht:

Marke1:
  IF NOT Logischer Ausdruck GOTO Marke2           (bedingter Vorwärtssprung zum Verlassen der Schleife)
  Befehlssequenz
  GOTO Marke1                                     (Rückwärtssprung für die nächste Iteration)
Marke2:

Die Befehlssequenz wird keinmal durchlaufen, wenn der logische Ausdruck schon zu Beginn falsch ist.

Do-While-Schleife

DO Befehlssequenz WHILE Logischer Ausdruck

entspricht:

Marke1:
  Befehlssequenz
  IF Logischer Ausdruck GOTO Marke1       (bedingter Rückwärtssprung für die nächste Iteration, wenn Bedingung erfüllt ist)

Hier wird die Schleife mindestens einmal durchlaufen. Die Do-While-Schleife ist damit nachprüfend.

Repeat-Until-Schleife

REPEAT Befehlssequenz UNTIL Logischer Ausdruck

entspricht:

Marke1:
  Befehlssequenz
  IF NOT Logischer Ausdruck GOTO Marke1     (bedingter Rückwärtssprung für die nächste Iteration, wenn Bedingung nicht erfüllt ist)

Sie ist also lediglich eine Do-While-Schleife mit Abbruchbedingung statt Laufbedingung.

Befehle in Assemblersprache

Assemblercode bietet normalerweise nicht die aus höheren Programmiersprachen bekannten for/while/repeat Konstrukte. Da aber auch hier Schleifen eingesetzt werden müssen (Verzögerung durch aktives Warten (s. u.), serielles adressiertes Verarbeiten von Daten), stehen einfache Sprungbefehle für unbedingte und bedingte Sprünge zur Verfügung.

Letztere entscheiden anhand eines Statusflags der CPU (z. B. Zero-Flag), ob gesprungen werden muss. Trifft die Voraussetzung nicht zu, so wird der Programmcounter (PC) einfach um eins erhöht. Es wird dann also als Nächstes der Befehl nach dem bedingten Sprungbefehl ausgeführt.

Beispiel für Code für einen AVR-Mikrocontroller, der unter Verwendung einer Schleife um insgesamt 5000 Takte durch aktives Warten verzögert:

                ; delaying 4998 clocks in 2 loops
    ldi R0, 7   ; initialisiere äußeren Schleifenzähler mit 7
Marke1:
                ; innere Schleife
    ldi R1, 237 ; initialisiere inneren Schleifenzähler mit 237 (dezimal)
Marke2:
    dec R1      ; Vermindert Inhalt in R1 um 1
    brne Marke2 ; Sprung nur, wenn R1 nun nicht 0 ist. („BRanch if Not Equal to zero“)
    dec R0      ; äußeren Schleifenzähler um 1 verringern
    brne Marke1
                ; delaying additional 2 clocks
    nop
    nop

Häufig gibt es angepasste Assemblerbefehle, die mehrere Aktionen kombinieren („Prüfe Iterator auf Ist-Gleich-…, wenn ungleich springe nach …“, „Zähle Iterator 1 herunter, wenn er noch immer größer 0 ist, springe nach …“). Oft setzen diese voraus, dass ein Zähl-Iterator sich z. B. in einem bestimmten Register befindet.