Schleife (Programmierung)

Grundprinzip und Ablauf

Eine Schleife ist eine Kontrollstruktur in Programmiersprachen, die einen Anweisungsblock wiederholt. Dieser Block heißt Schleifenrumpf oder Schleifenkörper. Die Wiederholung dauert an, solange eine Laufbedingung gültig bleibt beziehungsweise bis eine Abbruchbedingung eintritt. Führt die Bedingung immer zur Fortsetzung oder fehlt sie ganz, entsteht eine Endlosschleife.

Die Verarbeitung erfolgt iterativ, also schrittweise wiederholt: Außer bei fußgesteuerten Schleifen wird zuerst die Schleifenbedingung geprüft. Ist sie nicht erfüllt, endet die Schleife. Andernfalls wird der gesamte Schleifenrumpf ausgeführt und anschließend erneut geprüft.

Schleifen können beliebig verschachtelt werden, sodass eine innere Schleife im Schleifenkörper einer äußeren liegt. Jede Schleife lässt sich in eine rekursive oder sogar endrekursive Form umwandeln. Compiler können Schleifen zur Beschleunigung des Programmablaufs außerdem entrollen.

Schleifenarten und Bedingungen

Die wichtigsten Schleifenarten unterscheiden sich danach, wann und auf welche Weise die Fortsetzung geprüft wird:

• Bei einer vorprüfenden oder kopfgesteuerten Schleife wird die Bedingung vor jeder möglichen Ausführung des Schleifenrumpfs geprüft. Typisch ist WHILE („solange“). Deshalb kann der Schleifenrumpf auch kein einziges Mal ausgeführt werden.
• Bei einer nachprüfenden oder fußgesteuerten Schleife erfolgt die Prüfung erst nach dem Schleifenrumpf. Typische Formen sind DO…WHILE („ausführen … solange“) und REPEAT…UNTIL („wiederholen … bis“). Der Schleifenrumpf läuft daher mindestens einmal.
• Die Zählschleife ist eine Sonderform der vorprüfenden Schleife und wird meist mit FOR umgesetzt. Sie arbeitet mit einem Zähler.
• Die Mengenschleife ist eine Sonderform der Zählschleife. Sie wird meist mit FOREACH umgesetzt und verarbeitet jedes Element einer Menge, wobei die Reihenfolge beliebig sein kann.

Eine Laufbedingung lässt die Schleife weiterlaufen, solange sie zu „wahr“ ausgewertet wird. Bei einer Abbruchbedingung beendet dagegen ein Ergebnis von „wahr“ die Schleife.

Typische Schleifenkonstrukte

Eine Zählschleife kann in Pseudocode so aussehen: „FOR Iterator:=Anfangszahl TO Endezahl STEP Schrittweite DO Schleifenrumpf.“ Der Computer zählt von einer Anfangszahl bis zu einer Endzahl und führt den Schleifenrumpf bei jedem Schritt aus. Die aktuelle Zahl steht in der Variablen „Iterator“. Häufig sind solche Schleifen auf Ganzzahlen beschränkt. Das Verändern des Iterators im Schleifenkörper ist in vielen Sprachen verboten und gilt als schlechter Programmierstil, weil die Zahl der Durchläufe dadurch schwerer verständlich wird.

Eine kopfgesteuerte Schleife hat die Form „WHILE Logischer Ausdruck DO Schleifenrumpf.“ Die Bedingung, beispielsweise „x > 4“, wird vor dem Schleifenrumpf geprüft. Solange sie wahr ist, werden die Anweisungen ausgeführt. Wird der für die Bedingung wichtige Wert im Schleifenrumpf nicht verändert, läuft die Schleife möglicherweise gar nicht oder unendlich lange.

Fußgesteuerte Varianten lauten „DO Schleifenrumpf WHILE Logischer Ausdruck“ oder „REPEAT Schleifenrumpf UNTIL Logischer Ausdruck“. Bei WHILE ist der Ausdruck eine Laufbedingung, bei UNTIL eine Abbruchbedingung. Weil erst nach dem Rumpf geprüft wird, läuft dieser mindestens einmal. Bleiben die für die Bedingung wichtigen Werte unverändert, endet die Schleife nach genau einem Durchlauf oder läuft unendlich lange.

Eine Mengenschleife hat die Form „FOREACH Element OF Menge DO Schleifenrumpf“ und führt den Rumpf für jedes Element einer Menge wie eines Arrays oder einer Liste aus. Sie lässt sich durch eine Zählschleife von 1 bis „Mächtigkeit(Menge)“ ersetzen, die jeweils das entsprechende Element auswählt. Weil die Abarbeitungsreihenfolge beliebig ist und eine Iteration nicht von der „vorhergehenden“ abhängen kann, kann ein Compiler Mengenschleifen besonders einfach automatisch parallelisieren.

Vorzeitiger Abbruch

Wenn sich ein Sonderfall nur schwer in der regulären Schleifenbedingung ausdrücken lässt, kann die Ausführung aus dem Schleifenkörper heraus beeinflusst werden.

Ein Iterationsabbruch mit „CONTINUE“ beendet nur den aktuellen Durchlauf: Der verbleibende Teil des Schleifenrumpfs wird übersprungen, danach beginnt die Prüfung für die nächste Iteration. „CONTINUE Schleifenbezeichner“ kann sich in verschachtelten Schleifen auf eine bestimmte äußere Schleife beziehen. Dabei werden die inneren Schleifen vollständig beendet und die bezeichnete äußere Schleife mit ihrer nächsten Iteration fortgesetzt.

Ein Schleifenabbruch mit „BREAK“ beendet dagegen die aktuelle Schleife vollständig. Das Programm setzt seine Arbeit mit der ersten Anweisung nach der Schleife fort. „BREAK Schleifenbezeichner“ beendet in einer Verschachtelung außerdem sämtliche inneren Schleifen und die bezeichnete äußere Schleife. Als Bezeichner wird häufig ein Name ähnlich einer Sprungmarke verwendet; bei Zählschleifen dient mitunter der Name des Iterators dazu.

Umsetzung mit Sprüngen und Assembler

Grundsätzlich lässt sich jede Schleifenform durch bedingte und unbedingte Sprungbefehle darstellen. Dazu werden Marken, englisch „Labels“, als Ziele von Goto-Anweisungen verwendet. In der strukturierten Programmierung wird von Goto meist abgeraten, weil dadurch schwer überschaubarer „Spaghetticode“ entstehen kann. Bei der Umsetzung einer For-Schleife durch einfachere Befehle können sich Varianten in Sonderfällen unterscheiden, etwa bei einer Schrittweite von 0 oder wenn Start- beziehungsweise Endwert die kleinste oder größte darstellbare Zahl sind.

Eine While-Do-Schleife prüft am Anfang: Ist der logische Ausdruck falsch, springt das Programm hinter die Schleife. Andernfalls führt es die Befehlssequenz aus und springt zur erneuten Prüfung zurück. Ist der Ausdruck bereits zu Beginn falsch, gibt es keinen Durchlauf.

Eine Do-While-Schleife führt zuerst die Befehlssequenz aus und springt bei erfüllter Bedingung zurück. Sie ist nachprüfend und läuft mindestens einmal. Eine Repeat-Until-Schleife arbeitet ebenso, springt aber zurück, solange die Abbruchbedingung noch nicht erfüllt ist. Sie ist damit eine Do-While-Schleife mit Abbruchbedingung statt Laufbedingung.

Assembler bietet gewöhnlich keine for-, while- oder repeat-Konstrukte höherer Programmiersprachen. Schleifen werden dort mit unbedingten und bedingten Sprüngen aufgebaut. Bedingte Sprünge richten sich nach einem Statusflag der CPU, beispielsweise dem Zero-Flag. Ist die Sprungvoraussetzung nicht erfüllt, wird der Programmcounter (PC) um eins erhöht und der folgende Befehl ausgeführt.

Das angegebene AVR-Beispiel erzeugt durch aktives Warten eine Verzögerung von insgesamt 5000 Takten: Zwei verschachtelte Schleifen verzögern 4998 Takte. Das Register R0 enthält den äußeren Zähler 7, R1 den inneren Zähler 237. „dec“ vermindert den jeweiligen Registerwert, und „brne“ springt zurück, solange der Wert nicht 0 ist. Zwei abschließende „nop“-Befehle ergänzen die restlichen 2 Takte. Manche Assemblerbefehle verbinden Zählen, Prüfen und Springen und verlangen dafür den Iterator in einem bestimmten Register.

Die x86-Architektur besitzt den besonderen LOOP-Befehl. Er ist jedoch nur auf i8086- und i80286-Prozessoren schneller als eine entsprechende Kombination etwa aus DEC oder SUB und einem bedingten Sprung wie JNZ. Für CPUs ab dem Intel 80386 sollte LOOP daher nicht mehr verwendet werden. Auf Prozessoren vor dem i386 benötigt der Befehl weniger Speicherplatz, ist schneller und kann den Code lesbarer machen.