Schleifen

Einführung in die Schleifentechnik

Eine Schleife ist eine Kontrollstruktur in der Programmierung. Mit ihr können Teile des Codes so lange wiederholt werden, wie eine Bedingung gültig ist. Diese Teile des Codes werden Schleifenkörper (oder Schleifenrumpf) genannt. Dies lässt sich mit der nachfolgenden Grafik anschaulich visualisieren:



Hier wird deutlich, dass Sie solange arbeiten müssen, wie das Wochenende nicht erreicht wurde. Die meisten Schleifenarten verwenden für die Laufbedingung eine „Solange wie“Frage. Schleifen, deren Laufbedingung immer erfüllt ist, oder Schleifen, die über keine Bedingung verfügen, sind Endlosschleifen.
In der Informatik wird von Iteration (lateinisch iterare = wiederholen) gesprochen, wenn die Abarbeitung von einzelnen Anweisungen schrittweise wiederholt wird.

Kopfgesteuerte Schleifen

Kopfgesteuerte Schleifen zeichnen sich dadurch aus, dass die Prüfung der Laufbedingung immer vor dem Schleifenkörper stattfindet. Dies kann zur Folge haben, dass der Schleifenkörper niemals durchlaufen wird.



Da die Laufbedingung nicht zutrifft, wird der Schleifenkörper übersprungen und die folgenden Anweisungen im restlichen Programm werden abgearbeitet.

In der Literatur werden die kopfgesteuerten Schleifen auch als kopfgeprüfte oder vorprüfende Schleifen bezeichnet.

for – Schleife

An dieser Stelle soll mit einer kopfgeprüften Schleife begonnen werden. Es handelt sich um die for-Schleife (Zählschleife). Diese Schleife ist, wenn auch nicht ausschließlich, bestens zum Zählen geeignet. In der Visualisierung durch ein Struktogramm wird der Vorgang deutlich:



Aus diesem Struktogramm folgert die nachfolgende Abarbeitung:

							    Wert von x
Schritt 1:	x = 1		einmalige Ausführung		1
Schritt 2: 	Überprüfung, ob x < 5				1
Schritt 3: 	Anzeige von x					1
Schritt 4	x = x + 1					2
Schritt 2: 	Überprüfung, ob x < 5				2
Schritt 3: 	Anzeige von x					2
Schritt 4	x = x + 1					3
Schritt 2: 	Überprüfung, ob x < 5				3
Schritt 3: 	Anzeige von x					3
Schritt 4	x = x + 1					4
Schritt 2: 	Überprüfung, ob x < 5				4
Schritt 3: 	Anzeige von x					4
Schritt 4	x = x + 1					5
Schritt 2: 	Überprüfung, ob x < 5				5

Mit dieser Überprüfung wird festgestellt, dass x nicht mehr < 5 ist und somit folgt nach dieser Prüfung

Schritt 5:	Anzeige von x					5
 

Im Sourcecode stellt sich das vorgestellte Struktogramm wie folgt dar:

for(x=1; x < 5; x++)
{
	System.out.printf(“n%d“,x);
}
System.out.printf(“n%d“,x);

Wie bei anderen Kontrollstrukturen auch, gilt für die for-Schleife, dass diese bis zum Ende der folgenden Anweisung gültig ist. Dies gilt allerdings nur, wenn kein Codeblock vorhanden ist. Deshalb sind die folgenden Anweisungen mit den oben gezeigten in ihrer Wirkung identisch:

for(x=1; x < 5; x++)
	System.out.printf(“n%d“,x);
System.out.printf(“n%d“,x);

Die aus diesen zwei Programmen resultierende Anzeige sieht wie folgt aus:

1
2
3
4
5

Daraus ergibt sich, dass die Bedingung beim Verlassen der Schleife erfüllt wurde. In diesem Fall ist x = 5.

Die for-Schleife wird im Regelfall genutzt, um in einer festen Schrittweise von 1 aufwärts zu zählen. Dieser Schleifentyp bietet aber noch viel mehr:

for(x=10; x > 1; x--)
	System.out.printf(“n%d“,x);

In dem vorliegenden Beispiel zählt die Schleife in einer Schrittweite von 1 abwärts.

 
for(x=1; x < 50; x=(x+4)*2)
	System.out.printf(“n%d“,x);

In diesem Fall wird die Veränderung mit einer komplexen Formel realisiert.



In dem Beispiel erkennen Sie unter (1), dass beliebig viele Vorgaben für den Start der Schleife genutzt werden können. Dasselbe gilt für die Veränderung (3). Auch hier lassen sich beliebig viele Variablen modifizieren. In beiden Fällen erfolgt eine entsprechende Trennung durch ein „,“. Die solange-wie-Überprüfung, also die Bedingungen, müssen durch eine boolesche Verknüpfung erfolgen. Wenn die Anzahl der einzelnen Elemente beliebig ist, folgert die nachstehende Variation:

for(;;);

Hier sehen Sie eine Schleife ohne jeden Startwert, ohne Überprüfung und ohne jegliche Veränderung. Da diese Schleife bis zur nächsten Anweisung gültig ist und das Semikolon für eine leere Anweisung steht, sehen wir hier eine Schleife, die endlos läuft und nichts macht.
Schleifen können bei Bedarf in beliebiger Tiefe geschachtelt werden. In dem nachfolgenden Struktogramm und dem dazugehörigen Programm sehen Sie eine Möglichkeit, wie das kleine „Einmaleins“ realisiert werden kann:

for( n=1 ; n < 11 ; n++)
{
	for(m = 1; m < 11; m++)
        {
	      x = n * m;
	      System.out.printf(“%d = %d * %d”, x,n,m);
        }
}

Mit dem nachfolgenden Programm können Sie sich Ihre eigene ASCII-Tabelle 3-spaltig anzeigen lassen:

for( n=1 ; n < 11 ; n++)
{
	System.out.printf(“%d - %c“, n, n);
	if(n % 3 == 0)
	{
		System.out.printf(“n“);
        }
}

while – Schleife

In fast allen Programmiersprachen gibt es die while-Schleife als Kontrollstruktur. Mit ihr können Anweisungen solange ausgeführt werden, wie eine Bedingung erfüllt ist. Die Bedingung wird vor der Anweisungsfolge geprüft, deshalb handelt es sich auch um eine kopfgeprüfte Schleife. Da dieser Schleifentyp nur die Bedingung überprüft und nicht über die Fähigkeit verfügt, eine Eingangsbedingung zu setzen, muss dies vor der Überprüfung stattfinden. Die Veränderung während des Durchlaufs muss im Schleifenkörper geschehen, sonst laufen Sie Gefahr, eine Endlosschleife anzufertigen.

In dem folgenden Struktogramm und der dazugehörenden Codierung wird die Anwendung deutlich. Die Anweisungen in der Schleife sollen so lange durchlaufen werden, wie der User nicht ein „e“ für Ende eingegeben hat:



Schritt 1: Die Endbedingung wird gesetzt, Geschieht dies nicht, kann dies möglicherweise dazu führen, dass der Schleifenkörper nicht durchlaufen wird, da die Überprüfung negativ ist.

Schritt 2: Die Überprüfung findet statt. Sollte die Prüfung zutreffend sein, wird der Schleifenkörper abgearbeitet.

Schritt 3: Anweisungen im Schleifenkörper.

Schritt 4: Folgende Anweisungen nach Beendigung der Schleife.

Die dazugehörige Codierung:

String Wert = “ “  ;
Schritt 1: 	char Endbedingung = ’X’ ;
Schritt 2:	while ( Endbedingung != ’e’)
                {
Schritt 3:	    Wert = System.console().readLine(“Eingabe - e = Ende-“) ;
Schritt 3:	    Endbedingung = Wert.charAt(0) ;
                }
Schritt 4:	//weitere Anweisungen
		…

Fußgesteuerte Schleifen do – while – Schleife

In fast allen Programmiersprachen gibt es die do-while-Schleife als Kontrollstruktur. Sie ist mit einer Ausnahme vergleichbar mit der while()-Schleife. Es handelt sich hier um eine fußgeprüfte Schleife. Wie Sie im Folgenden erkennen, wird der Schleifenkörper bei Einsatz der do-while-Schleife immer mindestens einmal durchlaufen.

Auch mit der do-while-Schleife werden Anweisungen so lange ausgeführt werden, wie eine Bedingung erfüllt ist. Die Bedingung wird aber erst nach der Anweisungsfolge geprüft, deshalb handelt es sich um eine fußgeprüfte Schleife. Auch dieser Schleifentyp verfügt nur über die Fähigkeit, die Bedingung zu prüfen. In dem folgenden Struktogramm und der dazugehörenden Codierung wird die Anwendung deutlich. Die Anweisungen in der Schleife sollen so lange durchlaufen werden, wie der User nicht ein „e“ für Ende eingegeben hat:

Das Struktogramm und die dazugehörende Codierung macht die Anwendung deutlich. Die Anweisungen in der Schleife sollen solange durchlaufen werden, wie der User nicht ein „e“ für Ende eingegeben hat:



Schritt 1: Die Endbedingung wird „nicht“ gesetzt, trotzdem wird der Schleifenkörper mindestens einmal abgearbeitet.

Schritt 2: Anweisungen im Schleifenkörper.

Schritt 3: Die Überprüfung findet statt. Sollte die Prüfung zutreffend sein, wird der Schleifenkörper wiederholt abgearbeitet.

Schritt 4: Folgende Anweisungen nach Beendigung der Schleife.

Die dazugehörige Codierung:

String Wert = “ “;
char Endbedingung = ‘X‘;
do
{
	     Wert = System.console().readLine(“Eingabe - e = Ende-“);
             Endbedingung = Wert.charAt(0);
} while ( Endbedingung != ‘e‘);
//weitere Anweisungen
		…

Sprungbefehle in einer Schleife

Die nachfolgend geschilderten Sprungbefehle werden hier nur der Vollständigkeit halber gelistet. Diese Anweisungen implizieren ein goto. Die Verwendung kann sehr schnell zu einer unsauberen Programmierung führen. Sie können jede dieser Anweisungen mit einer angepassten Logik vermeiden. Deshalb sind diese Anweisungen auch nicht mit entsprechenden Übungen hinterlegt.

continue

Die Anweisung continue bewirkt, dass der restliche dem continue folgende Schleifenkörper nicht abgearbeitet wird. Durch continue wird erreicht, dass zuerst die Bedingung erneut geprüft wird und anschließend der Schleifenkörper von vorne abgearbeitet wird.

break

Die Anweisung break bewirkt, dass der restliche dem break folgende Schleifenkörper nicht abgearbeitet wird. Durch break wird erreicht, dass die Schleife beendet wird. Dies kann zur Folge haben, dass etwaige Zähler oder sonstige Bedingungen unkontrollierte Werte aufweisen.

Zusammenfassung Schleifen

Grundsätzlich können Sie jede Problemstellung, die einer Schleife bedarf, mit jedem der drei Schleifentypen realisieren. Sie haben beispielhaft bereits in den Übungen die for-Schleife mit einer while-Schleife und einer do-while-Schleife nachgeahmt. Allerdings sollten Sie bei der Programmentwicklung bedenken, dass jeder Schleifentyp sich für bestimmte Aufgaben besonders anbietet. Wenn in einer Aufgabe gezählt wird, oder sich ein Zähler gleichmäßig verändert, werden Sie der for-Schleife sicherlich den Vorzug geben. Wenn ein zählendes Element fehlt, bietet sich die while-Schleife an. Wenn der Schleifenkörper mindestens einmal durchlaufen wer-den soll, muss die do-while-Schleife genutzt werden. Sie ist deshalb ideal für eine Menüführung geeignet.

Es gibt in anderen Programmiersprachen noch weitere Schleifentypen, die hier kurz Erwähnung finden sollen. In der Programmiersprache Pascal, aber nicht nur dort, erfreut sich der Schleifentyp repeat-until besonderer Beliebtheit. Es handelt sich hier um eine Fußgeprüfte Schleife, die im Gegensatz zu den vorgestellten solange-wie-Schleifen so lange läuft, bis eine Bedingung erfüllt wurde.