Eine Schleife ist eine Kontrollstruktur in Programmiersprachen. Sie wiederholt einen Teil des Codes (den sog. Schleifenkörper) solange, bis eine Abbruchbedingung eintritt. Schleifen, die ihre Abbruchbedingung niemals erreichen sind Endlosschleifen.
Prinzipiell werden unterschieden:
- die kopfgesteuerte Schleife, bei der erst die Abbruchbedingung geprüft wird, bevor der Schleifenkörper durchlaufen wird (meist mit WHILE eingeleitet).
- die fußgesteuerte Schleife, bei der nach dem Durchlauf des Schleifenkörpers die Abbruchbedingung überprüft wird (meist als DO-WHILE oder REPEAT-UNTIL Konstrukt).
- die Zählschleife, eine Sonderform der kopfgesteuerten Schleife (meist als FOR-Schleife implementiert).
Befehle in höheren Programmiersprachen
Hier folgen ein paar der bekanntesten Schleifen in Pseudocode. Die Verwendung in echten Programmiersprachen ist meist sehr ähnlich.
FOR Iterator:=Anfangszahl TO Endezahl DO Befehlssequenz.
Hier zählt der Computer von einer Anfangszahl bis zu einer Endzahl und wiederholt dabei jedesmal den Codeblock. Die aktuelle Zahl wird in eine Variable gesetzt, damit sie bei Bedarf Verwendung in dem Codeblock finden kann.
WHILE Logischer Ausdruck DO Befehlssequenz.
Der Codeblock wird solange wiederholt, bis die logische Operation einen falschen Rückgabewert liefert. Eine logische Operation kann beispielsweise sein: (x > 4) Solange diese Bedingung wahr ist, läuft die Schleife. Wird der Inhalt der logischen Operation nicht im wiederholten Teil des Programmcodes verändert, ist diese Kontrollstruktur meist nicht die richtige, weil diese Schleife sonst kein einziges Mal durchlaufen wird oder unendlich lang läuft.
DO Befehlssequenz WHILE Logischer Ausdruck
bzw.
REPEAT Befehlssequenz UNTIL Logischer Ausdruck
Funtioniert genau so wie die WHILE-Schleife, allerdings wird die Abbruchbedingung erst nach den Durchlauf des eingeschlossenen Programmcodes überprüft. Das kann beim Programmieren durchaus hilfreich sein.
Befehle in Assembler
Assemblercode verfügt normaler Weise nicht über 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 unbedingten oder auch bedingten Sprünge zur Verfügung.
Letztere entscheiden anhand eines Statusflags der CPU (z.B. Zero-Flag), ob gesprungen werden muss. Trift 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 eine Verzögerungsschleife für AVR Microcontroller, die 5000 clocks verzögert:
; delaying 4998 clocks
ldi R0, $07
Label0: ldi R1, $ed
Label1: dec R1 ; Vermindert Inhalt in R1 um 1
brne Label1 ; Sprung nur, wenn R1 nun nicht 0 ist.
dec R0 ; alternativ gehts hier weiter
brne Label0
; delaying 2 clocks
nop
nop
Implementation
Früher war es üblich, in Programmen Sprünge (GOTO-Befehl) zu verwenden. In einfachen Programmiersprachen wie BASIC ist dies manchmal notwendig. Auch Programme in Fortran verwenden oft Sprungbefehle. In Assembler schließlich ist gar nichts anderes möglich.
Die Konstrukte FOR, WHILE-DO und REPEAT-UNTIL entstammen der strukturierten Programmierung. Sie machen die Verwendung von GOTO im Programmtext unnötig. Manche Sprachen wie z.B. Modula haben daher gar keine Sprunganweisungen mehr. In anderen Sprachen wird die Verwendung von GOTO soweit wie möglich vermieden.
Sprachen, die Sprunganweisungen verwenden, ermöglichen das Einfügen einer Marke (engl. Label). Eine solche Marke kann dann als Ziel einer GOTO-Anweisung dienen.
Implementation mit Sprungbefehlen
Früher war es üblich, in Programmen Sprünge (GOTO-Befehl) zu verwenden. In einfachen Programmiersprachen wie BASIC ist dies manchmal notwendig. Auch Programme in Fortran verwenden oft Sprungbefehle.
Sprachen, die Sprunganweisungen verwenden, ermöglichen das Einfügen einer Marke (engl. Label). Eine solche Marke kann dann als Ziel einer GOTO-Anweisung dienen.
Ersatz des FOR-Befehls durch GOTO
FOR Iterator:=Anfangszahl TO Endezahl DO Befehlssequenz.
entspricht:
Iterator:=Anfangszahl Marke1: IF Iterator>Endezahl GOTO Marke2 (bedingter Vorwärtssprung) Befehlssequenz Iterator:=Iterator+1 GOTO Marke1 (Rückwärtssprung) Marke2:
Die Befehlssequenz wird also keinmal durchlaufen, wenn die Anfangszahl größer als die Endezahl ist (z.B. in for i:=1 to 0 do ...).
Ersatz des WHILE-DO-Befehls durch GOTO
WHILE Logischer Ausdruck DO Befehlssequenz.
entspricht:
Marke1: IF NOT Logischer Ausdruck GOTO Marke2 (bedingter Vorwärtssprung) Befehlssequenz GOTO Marke1 (Rückwärtssprung) Marke2:
Wieder wird die Befehlssequenz keinmal durchlaufen, wenn der logische Ausdruck schon zu Beginn falsch ist.
Ersatz des DO-WHILE-Befehls durch GOTO
DO Befehlssequenz WHILE Logischer Ausdruck
entspricht:
Marke1: Befehlssequenz IF Logischer Ausdruck GOTO Marke1 (bedingter Rückwärtssprung)
Ersatz des REPEAT-UNTIL-Befehls durch GOTO
REPEAT Befehlssequenz UNTIL Logischer Ausdruck
entspricht:
Marke1: Befehlssequenz IF NOT Logischer Ausdruck GOTO Marke1 (bedingter Rückwärtssprung)