Schleifen

Jeder kennt Situationen, in denen ein bestimmter Vorgang gleich oder ähnlich wiederholt wird. Ohne Steuerung durch ein Programm laufen beispielsweise periodische Vorgänge in der Natur ab, wie z.B. das Jahr und der Tag. Ein Langstreckenläufer wiederholt eine Bahnschleife in einem Stadion vielleicht 30 Mal. Eine bestimmte Form der Wiederholung bezeichnet man auch als Schleife.

Eine Schleife  eines Programmes liegt im weitesten Sinne dann vor, wenn eine Anweisung, die nur einmal im Quelltext steht, wiederholt ausgeführt wird und dies in einer Weise geschieht, bei der es—zumindestens prinzipiell—möglich ist, die Anzahl der Ausführungen von Umständen abhängig zu machen, die erst während der Ausführung des Programmes bekannt werden. Sprachmittel, die zwar die Wiederholung einer nur einmal notierten Anweisung erlauben, aber es verlangen, daß die Zahl der Wiederholungen im Quelltext festgelegt wird, sollen nicht als Schleifen im Sinne dieser Lektion gelten.

Bei der Ausführung einer Schleife wird die zu wiederholende Anweisung dann wiederholt ausgeführt. Dabei ist es möglich, daß diese Anweisung gar nicht ausgeführt wird, einmal ausgeführt wird, zwiefach ausgeführt wird, dreimal ausgeführt wird und so weiter. Man sagt für diese wiederholte Ausführung auch, die Schleife werde durchlaufen.

Termination

Das Erreichen des Endes eines Schleifenvorgangs nennt man auch die Termination der Schleife. Wenn eine Schleife ihr Ende erreicht, dann sagt man sie terminiere.

Wenn eine Schleife ohne erkennbares Ende abläuft, so nennt man dies eine Endlosschleife. Eine Endlosschleife ist also eine Schleife, die nicht terminiert. Der Wechsel von Tag und Nacht stellt beispielsweise solch eine Wiederholung ohne absehbares Ende dar.

Abbrüche

Unter Umständen stellt ein Programm oder ein Betriebssystem Verfahren zum Abbruch von Prozessen während der Laufzeit bereit. Auf manchen Computer kann ein Prozeß beispielsweise durch die Eingabe Strg-C unterbrochen werden.

Aussagenschleifen

Wenn eine Schleife wiederholt wird, solange eine bestimmte Aussage wahr ist, so kann man dies eine Aussagenschleife nennen. Beispielsweise kann ein Läufer so lange im Kreis laufen, wie ihm dies gefällt. Hierbei wäre als die Aussage, daß dem Läufer das Durchlaufen der Schleife noch gefällt. Wenn diese Aussage nicht mehr wahr ist, dann hört das Durchlaufen auf. Ist diese Aussage schon von Anfang an nicht wahr, so wird mit dem Durchlaufen der Schleife gar nicht erst begonnen. (Wenn der Läufer aber noch nie eine Schleife durchlaufen ist, dann muß er sie möglicherweise erst mindestens einmal durchlaufen, um zu wissen, ob ihm dies gefällt.)

Schleifenaussage und Schleifeninhalte

Bei einer Schleife wird eine Anweisung, der Schleifeninhalt, in Abhängigkeit von einer Schleifenaussage  ausgeführt. Dabei kann der Schleifeninhalt im Allgemeinen gar nicht, einmal  oder wiederholt  ausgeführt werden.

Struktogramme

Zur Visualisierung von Schleifenanweisungen gibt es spezielle Struktogrammsymbole. Das folgende Struktogramm zeigt die Wiederholung einer Anweisung "〈Schleifeninhalt 〉" in Abhängigkeit von einem Ausdruck "〈Schleifenaussage 〉".

Schleife im Struktogramm

.----------------------------------. 
|  solange <Schleifenaussage>      | 
|   .------------------------------| 
|   |  <Schleifeninhalt>           | 
'----------------------------------'

Wenn keine Mißverständnisse möglich sind, kann das "solange" auch entfallen und die Schleifenaussage kann durch ein Fragezeichen abgeschlossen werden oder auch gar nicht weiter gekennzeichnet werden.

Schleife im Struktogramm

.----------------------------------. 
|  <Schleifenaussage>?             | 
|   .------------------------------| 
|   |  <Schleifeninhalt>           | 
'----------------------------------'

Zählschleifen*

Wenn eine Schleife eine bestimmte Anzahl von Wiederholungen durchlaufen soll, so spricht man auch von einer Zählschleife. Ein Fahrer eines Linienbusses in einer Großstadt hat beispielsweise den Auftrag einen Linienbus sechsmal von Endstation zu Endstation zu fahren.

Eine Zählschleife ist ein spezielle Form der Aussagen?schleife.

Wenn in Zählschleifen eine Variable verwendet wird, um eine bestimmte Anzahl von Schleifendurchläufen zu wiederholen, sollte in Sprachen mit typisierten Variablen immer eine ganzzahlige Variable verwendet werden und nie eine Gleitkommazahl, da das Schleifenverhalten aufgrund von kleinen, schwer vorhersehbaren Fehlern sonst oft nicht wie gewünscht ist. Die vierfache Addition von 0,1 zu 0 könnte bespielsweise 0,3999999999999999 statt 0,4 ergeben, so daß, eine Schleife die enden soll, wenn die Zählschleife den Wert 0,4 erreicht oder überschreitet, dann noch nicht terminieren würde.

Positive und Negative Aussagenschleifen*

Wird die Schleife so formuliert, daß eine bestimmte Bedingung zum Durchlauf positiv erfüllt sein muß, so kann man auch von einer „positiven Aussagenschleife“ sprechen. Diese Schleife kann man formulieren als „Solange die Aussage '〈…〉' wahr ist, wiederhole die Anweisung '〈…〉'“. Beispiel: „Solange noch Wasser im Boot ist, fülle einen Eimer mit diesem Wasser und schütte ihn ins Meer.“

positive Schleife im Struktogramm

.----------------------------------. 
|  solange <Schleifenaussage>      | 
|   -------------------------------| 
|  |  <Schleifeninhalt>            | 
'----------------------------------'

Man auch eine Aussage formulieren, die nicht  erfüllt sein darf, damit die Schleife durchlaufen wird. Dann kann man auch von einer „negativen Aussagenschleife “ sprechen. Diese Schleife kann man formulieren als „Bis die Aussage '〈…〉' wahr ist, wiederhole die Anweisung '〈…〉'“. Beispiel: „Bis das Boot trocken ist, fülle einen Eimer mit Wasser aus dem Boot und schütte ihn ins Meer.“

negative Schleife im Struktogramm

.----------------------------------------. 
|  solange nicht <Schleifenaussage>      | 
|   -------------------------------------| 
|  |  <Schleifeninhalt>                  | 
'----------------------------------------'

Man kann die gleiche Schleife positiv oder negativ formulieren, dies ist eher eine Stilfrage.

Nichtabweisende Aussagenschleifen*

Wenn die Aussage für einen Schleifendurchlauf vor jedem Schleifendurchlauf ausgewertet wird und der Durchlauf nur dann ausgeführt wird, wenn die Aussage wahr ist, so spricht man auch von einer abweisenden Aussagenschleife. Diese Bezeichnung kommt daher, daß es auch möglich ist, daß solch eine Schleife nie durchlaufen wird, wenn die Aussage schon beim Start der Schleife nicht wahr ist.

Eine nichtabweisende Schleife führt im Gegensatz dazu den Schleifeninhalt immer erst einmal aus und berücksichtig den Schleifenausdruck dann erst für die Frage, ob die Ausführung des Schleifeninhalts wiederholt werden soll.

positive nichtabweisende Schleife im Struktogramm

.---------------------------------. 
|  |  <Schleifeninhalt>           | 
|   ------------------------------| 
|  solange <Schleifenaussage>     | 
'---------------------------------'

negative nichtabweisende Schleife im Struktogramm

.-----------------------------. 
|  |  <Schleifeninhalt>       | 
|   --------------------------| 
|  bis <Schleifenaussage>     | 
'-----------------------------'

Eine nichtabweisende Schleife wird auch als eine annehmende Schleife  bezeichnet.

Schleifensteuerung*

Die drei Teile "〈Schleifenvorbereitung 〉", "〈Schleifenaussage 〉" und "〈Schleifenschritt 〉" treten bei der Steuerung von Schleifen in vielen Fällen auf und sollen hier im Einzelnen benannt werden.

Schleifensteuerung im Struktogramm

.-------------------------------------. 
|  <Schleifenvorbereitung>            | 
|-------------------------------------| 
|  solange <Schleifenaussage>         | 
|    ---------------------------------| 
|   |  <Sonstiger Schleifeninhalt>    | 
|    ---------------------------------| 
|   |  <Schleifenschritt>             | 
'-------------------------------------'

Schleifenvorbereitung*

Die Schleifenvorbereitung wird einmal vor dem ersten Schleifendurchlauf erledigt. Ein Läufer, der mehrere Runden auf einer Bahn laufen will, zieht beispielsweise zur Vorbereitung der Durchläufe Laufschuhe an und nimmt einen Zettel und einen Stift in die Hand.

Schleifenaussage*

Die Schleifenaussage wird vor jedem Schleifendurchlauf ausgewertet, um zu prüfen, ob die Schleifenanweisung erneut ausgeführt werden soll. (Bei nichtabweisenden Schleifen jedoch nicht vor dem ersten Schleifendurchlauf.). Ein Läufer kann beispielsweise prüfen, ob die Laufschuhe noch in Ordnung sind und ob noch nicht 32 Striche auf seiner Strichliste sind (wenn er 32 Durchläufe laufen will).

Schleifeninhalt*
Schleifenschritt*

Am Ende jeder Schleifenanweisung kann der notwendige Übergang zum nächsten Durchlauf der Schleife erfolgen. Ein Läufer kann beispielsweise nach jeder Runde einen Strich auf eine Strichliste machen, um sein Umläufe zu zählen.

Standardschleife*

Eine allgemeine und empfehlenswerte Form einer Schleife ist die Standardschleife  (sr), bei der als Aussage für den Schleifendurchlauf nur der Wert eines Bits geprüft wird. Für die entsprechende Variable wird der Name "looping" empfohlen. Eine Standardschleife enthält also als Aussage immer nur "solange looping = 1" (oder "solange looping" bei einer Boolean-Variablen) Die Steuerung der Schleife erfolgt dann ausschließlich dadurch, daß dieses Bit je nach Bedarf gesetzt wird. Einige knifflige Fragen bezüglich der strukturierten Programmierung von Schleifen (beispielsweise die Vermeidung der Wiederholung eines Befehls zum Einlesen in einer Eingabeprüfungsschleife) können durch eine Standardschleife einfach und elegant gelöst werden.

Standardschleife im Struktogramm

.-------------------------------------------. 
|  looping := 1                             | 
|-------------------------------------------| 
|  looping = 1?                             | 
|   .---------------------------------------| 
|   |  <Schleifeninhalt>                    | 
|   |  (Hier zum Beenden der Schleife       | 
|   |  looping := 0 setzen.)                | 
'-------------------------------------------'

Das folgende Beispiel zeigt das Einlesen der Augenzahl eines Würfels mit Eingabeaussage als Standardschleife: Wenn keine gültige Augenzahl (also eine Zahl von 1 bis 6) eingegeben wurde, soll die Eingabe wiederholt werden. Die Standardschleife macht es unnötig, sich mit verschiedenen Formen von Schleifen zu beschäftigen, da sie es erlaubt, alle auf einheitliche Weise zu fomulieren. Darüberhinaus ist es ohne Standardschleife recht schwierig zu erreichen, daß das Einlesen der Variablen nur einmal im Programmtext erscheint. (In den 60er Jahren wurde dieses Problem sogar in Informatik-Fachzeitschriften diskutiert.)

Struktogramm "Eingabeprüfung"

.-------------------------------------------. 
|  looping := 1                             | 
|-------------------------------------------| 
|  looping = 1?                             | 
|   .---------------------------------------| 
|   |  Ausgabe "Bitte Zahl eingeben!"       | 
|   |---------------------------------------| 
|   |  Einlesen zahl                        | 
|   |---------------------------------------| 
|   |  zahl < 7?                            | 
|   |  Ja                            | Nein | 
|   |--------------------------------|------| 
|   |  zahl > 0?                     |      | 
|   |  Ja                     | Nein |      | 
|   |-------------------------|------|      | 
|   |  looping := 0           |      |      | 
'-------------------------------------------'