Zählschleife: Unterschied zwischen den Versionen

Aus EINI
Wechseln zu: Navigation, Suche
(→‎Der Schleifenkopf)
(→‎Die vollständige for-Schleife)
 
(27 dazwischenliegende Versionen von 4 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
−
Die for-Schleife ist eine Schleifenart in Java. In solch einer Schleife werden Befehle solange wiederholt, bis eine Abbruchbedingung erfüllt wurde. Ansonsten ist ein laufendes Programm in einer Endlosschleife gefangen.
+
Eine '''Zählschleife''' ist eine besondere Art der [[Kopfgesteuerte Schleife|kopfgesteuerten Schleife]].  
  
−
= Namensherkunft und Zweck =
+
In den meisten [[Programmiersprache|Programmiersprachen]] wird sie durch das [[Schlüsselwörter|Schlüsselwort]] '''for''' eingeleitet. Daher wird sie auch '''for-Schleife''' genannt. Sie besitzt in ihrer [[Deklaration]] Informationen über [[Anweisung]]en, die bei Schleifeneintritt und bei der Fortsetzung der Schleife ausgeführt werden sollen.
  
−
For Schleifen haben ihren Namen aus Aussagen, wie "Für jedes x in M ..." (engl. ''for each x in M'') und "Für x gleich 3 sei ..." (engl. ''for x equals 3 let''). Sie versuchen die Initialisierung, Überprüfung und Fortsetzung einer while-Schleife durch syntaktischen Zucker zu vereinfachen, indem sie leichter niederzuschreiben sind, dem Programmierer leichter Fehler erkennen lassen und sich im geistigen Lesefluss besser visualisieren lassen. Nehmen Sie z.B. folgenden Satz: "Sei i gleich 0, so wiederhole solange i kleiner ist als 5 folgende Zeilen, von denen eine die Variable i um 1 erhöht ..." und "Für i gleich 1 bis 5 in Schrittgröße 1 führe folgende Zeilen aus: ...". Letzterer wird den meisten Lesern angenehmer sein, da hier alle relevanten Informationen über die Durchführung der Schleife in ihrer Deklaration vorhanden sind. Aus dem selben Grund gibt es for-Schleifen. Prinzipiell lassen sich natürlich alle for-Schleifen auch durch while-Schleifen und umgekehrt umsetzen.
+
= Syntaxdiagramm =
 +
 
 +
[[Datei:for_statement.png]]
 +
 
 +
= Verwendung =
 +
 
 +
Der Name der '''for'''-Schleife leitet sich von Aussagen wie z.B. "Für alle x ..." ab. Sie findet daher meistens Verwendung, wenn über Datensätze iteriert werden soll oder wenn einfach Zahlenbereiche abgezählt werden.
 +
 
 +
In der Praxis ist die '''for'''-Schleife die am häufigsten verwendete Schleife, da bei ihr alle wichtigen Informationen, die zur Semantik einer Schleife gehören, im Kopf der Schleife stehen können. So verwenden manche Programmierer sogar Konstrukte wie <code>for(;x>0;){...}</code>, um '''while'''-Schleifen zu emulieren.
  
 
= Aufbau einer for-Schleife =
 
= Aufbau einer for-Schleife =
 +
 +
Eine for-Schleife besteht, so wie [[while]]- und [[do-while]]-[[Schleifen]], aus einem Kopf und einem Rumpf.
 +
 +
Wichtig: Zwischen Kopf und Rumpf steht '''kein Semikolon'''.
  
 
==Der Schleifenkopf==
 
==Der Schleifenkopf==
  
−
Das Schlüsselwort für eine for-Schleife ist das namensgebende '''for'''. Darauf folgt der Schleifenkopf mit folgendem Aussehen: '''(''' ''1.'' ''';''' ''2.'' ''';''' ''3.'' ''')''' ''4.'' '''.
+
===Aufbau===
  
−
Unter ''1.'' kann eine Zählvariable initialisiert werden, z.B. ''int i = 0;''.
+
Das Schlüsselwort für eine for-Schleife ist das namensgebende '''for'''. Darauf folgt der Schleifenkopf mit folgendem Aussehen: '''(''' ''1.'' ''';''' ''2.'' ''';''' ''3.'' ''')'''.
  
−
Unter ''2.'' kann und sollte eine Bedingung für das Ausführen der Schleife stehen, z.B. ''i < 5''. Solange dies erfüllt ist, wird die Schleife ausgeführt.
+
Unter '''1.''' sollte eine '''Zählvariable''' initialisiert werden, z.B. ''int i = 0;''. Die hier aufgeführte Anweisung wird nur beim Eintritt in die Schleife ausgeführt. Die [[Zählvariable]] heißt so, da sie die Schleifendurchgänge zählt.
  
−
Unter ''3.'' kann eine Fortsetzung stehen, die als letztes im Schleifenrumpf ausgeführt wird, z.B. ''++i''.
+
Unter '''2.''' sollte eine '''Bedingung''' für das Ausführen der Schleife stehen, z.B. ''i < 5''. Solange dies erfüllt ist, wird die Schleife ausgeführt.
  
−
Unter ''4.'', hinter der schließenden runden Klammer, muss eine Anweisung folgen. Diese Anweisung kann leer sein, es wird jedoch für gewöhnlich ein Block von weiteren Anweisungen erwartet.
+
Unter '''3.''' sollte eine '''Fortsetzung''' stehen, die als letztes im Schleifenrumpf ausgeführt wird, z.B. ''++i''.
  
−
Zusammenfassend sieht der Schleifenkopf einer for-Schleife so aus:
+
Der Schleifenkopf einer for-Schleife sieht insgesamt also so aus:
  
−
'''for'''(''Initialisierung'' ; ''Bedinung'' ; ''Fortsetzung'')
+
'''for'''(''Initialisierung'' ; ''Bedingung'' ; ''Fortsetzung'')
  
−
<source lang="java" title="Beispiel">
+
===Beispiel===
 +
<source lang="java" title="Beispielkopf">
 
for( int i = 0 ; i < 5 ; ++i)
 
for( int i = 0 ; i < 5 ; ++i)
 
</source>
 
</source>
Zeile 29: Zeile 42:
 
==Der Schleifenrumpf==
 
==Der Schleifenrumpf==
  
−
Als Schleifenrumpf wird der Programmcode bezeichnet, der in der Schleife wiederholt werden soll. Wenn keine {}-Klammern gesetzt werden, wird nur der erste Befehl nach dem Schleifenkopf wiederholt. Wenn mehrere Befehle wiederholt werden sollen, dann muss auf dem Schleifenkopf { folgen. Nach dem letztem Befehl des Schleifenrumpfs }.
+
===Aufbau===
−
<source lang="java">
+
 
 +
Als '''Schleifenrumpf''' wird der Programmcode bezeichnet, der in der Schleife wiederholt werden soll.  
 +
 
 +
Wenn keine geschweiften Klammern gesetzt werden, wird nur der erste Befehl nach dem Schleifenkopf wiederholt. Wenn mehrere Befehle wiederholt werden sollen, dann muss auf den Schleifenkopf ein [[Block]] mit geschweiften Klammern folgen. Ein leerer Rumpf kann mit einem einzelnen Semikolon nach dem Schleifenkopf signalisiert werden.
 +
 
 +
===Beispiele===
 +
 
 +
====Korrekte Beispiele====
 +
 
 +
<source lang="java" title="Schleifenrumpf">
 
for (...)
 
for (...)
 
{
 
{
Zeile 37: Zeile 59:
 
}
 
}
 
</source>
 
</source>
−
Mit jedem Schleifendurchlauf wird die Variable ''erg'' um 5 erhöht. Danach wird diese im jedem Durchlauf ausgegeben.
+
Mit jedem Schleifendurchlauf wird die Variable ''erg'' um 5 erhöht. Danach wird diese, ebenfalls in jedem Durchlauf, ausgegeben.
  
−
<source lang="java">
+
<source lang="java" title="Leerer Rumpf">
 +
for (...);
 +
erg = erg + 5;
 +
System.out.println(erg);
 +
</source>
 +
Hier wird die Variable ''erg'' nur ein Mal um 5 erhöht und ausgegeben, da die Schleife durch das einzelne Semikolon nach dem Schleifenkopf einen leeren Rumpf hat.
 +
 
 +
<source lang="java" title="Schleifenrumpf ohne Block mit korrekter Einrückung">
 +
for (...)
 +
  erg = erg + 5;
 +
System.out.println(erg);
 +
</source>
 +
Hier wird bei jedem Schleifendurchlauf die Variable ''erg'' um 5 erhöht. Die Ausgabe gehört nicht mehr zu der Schleife, wird also nur einmal nach der Schleife ausgeführt.
 +
 
 +
====Negativbeispiel====
 +
<source lang="java" title="Schleifenrumpf ohne Block mit falscher Einrückung">
 
for (...)
 
for (...)
 
   erg = erg + 5;
 
   erg = erg + 5;
 
   System.out.println(erg);
 
   System.out.println(erg);
 
</source>
 
</source>
 +
Hier wird bei jedem Schleifendurchlauf die Variable ''erg'' um 5 erhöht. Diese Variable wird jedoch nur nach der Schleife einmal ausgegeben, da die Ausgabe nicht innerhalb der Schleife liegt. Das Einrücken der <code>System.out.println(erg)</code> - Zeile ist demnach falsch.
  
−
Auch hier wird bei jedem Schleifendurchlauf die Variable ''erg'' um 5 erhöht. Jedoch wird nur diese Variable nur nach der Schleife einmal ausgegeben.
+
==Die vollständige for-Schleife==
  
−
+
===Aufbau===
  
 +
'''for'''(''Initialisierung'' ; ''Bedingung'' ; ''Fortsetzung'')
  
−
==die (komplette) for-Schleife==
+
{''Befehl(e)''}
  
 +
===Beispiele===
 
<source lang="java">
 
<source lang="java">
 
for( int i = 0 ; i < 5 ; ++i)
 
for( int i = 0 ; i < 5 ; ++i)
 
{
 
{
 
   erg = erg + 5;
 
   erg = erg + 5;
−
   System.out.println(erg)
+
   System.out.println(erg);
 
}
 
}
 
</source>
 
</source>
Zeile 62: Zeile 102:
 
Zunächst wird die Zählvariable ''i'' mit 0 initialisiert. Danach wird geprüft, ob i < 5 ist. Da dies korrekt ist, wird nun der Schleifenrumpf ausgeführt. Auf die Variable ''erg'' wird 5 aufaddiert und danach wird die Variable ausgegeben. Nun wird ''i'' auf 1 erhöht.
 
Zunächst wird die Zählvariable ''i'' mit 0 initialisiert. Danach wird geprüft, ob i < 5 ist. Da dies korrekt ist, wird nun der Schleifenrumpf ausgeführt. Auf die Variable ''erg'' wird 5 aufaddiert und danach wird die Variable ausgegeben. Nun wird ''i'' auf 1 erhöht.
  
−
Der Schleifenkopf wird nun mit i = 1 ausgeführt. Die Initialisierung wird nun nicht mehr ausgeführt, da diese nur zu Beginn der Schleife ausgeführt wird. Es wird also direkt überprüft, ob ''i'' < 5 ist. 1 < 5 ist korrekt, der Schleifenrumpf wird also wieder ausgeführt. Der Variable ''erg'' wird nun wieder 5 aufaddeirt und danach wieder ausgegeben. Anschließend wird ''i'' auf 2 erhöht.
+
Der Schleifenkopf wird nun mit i = 1 ausgeführt. Die Initialisierung wird nicht mehr ausgeführt, da dies nur zu Beginn der Schleife gemacht wird. Es wird also direkt überprüft, ob ''i'' < 5 ist. 1 < 5 ist korrekt, der Schleifenrumpf wird also wieder ausgeführt. Der Variable ''erg'' wird nun wieder 5 hinzugefügt und danach wieder ausgegeben. Anschließend wird ''i'' auf 2 erhöht.
  
 
Analog werden die Fälle für i = 2, i = 3 und i = 4 ausgeführt.
 
Analog werden die Fälle für i = 2, i = 3 und i = 4 ausgeführt.
  
−
Die Bedingung i < 5 ist bei i = 5 nicht mehr erfüllt. Daher wird der Schleifenrumpf nicht mehr ausgeführt. Die Zählvariable ''i'' wird nun verworfen.
+
Die Bedingung i < 5 ist bei i = 5 nicht mehr erfüllt. Daher wird der Schleifenrumpf nicht mehr ausgeführt. Die Zählvariable ''i'' wird nun verworfen.
 +
 
 +
Durch die Initialisierung von i mit 0 und dem Test i '''<''' 5 wird die Schleife genau 5 Mal durchlaufen. Es wäre natürlich auch möglich, die Schleife mit '''int i = 1''' zu initialisieren und den Test i '''<=''' 5 durchzuführen. Dies ist jedoch aus mehreren Gründen unüblich.
 +
 
 +
 
 +
<source lang="java">
 +
int b = 2;
 +
for( int i = 0 ; i < 5 ; ++i)
 +
{
 +
  b = b*2;
 +
}
 +
System.out.println(b);
 +
</source>
 +
 
 +
Genau wie im ersten Beispiel wird auch hier ''i'' mit 0 initialisiert und geprüft, ob i < 5 ist. Die Schleife wird also erneut 5 Mal durchlaufen. Die Variable b wird in jeder Iteration verdoppelt und enthält demnach am Ende den Wert b = (((((2*2)*2)*2)*2)*2). Dieser wird nach Beendigung der Schleife ausgegeben.

Aktuelle Version vom 25. Oktober 2017, 13:49 Uhr

Eine Zählschleife ist eine besondere Art der kopfgesteuerten Schleife.

In den meisten Programmiersprachen wird sie durch das Schlüsselwort for eingeleitet. Daher wird sie auch for-Schleife genannt. Sie besitzt in ihrer Deklaration Informationen über Anweisungen, die bei Schleifeneintritt und bei der Fortsetzung der Schleife ausgeführt werden sollen.

Syntaxdiagramm

For statement.png

Verwendung

Der Name der for-Schleife leitet sich von Aussagen wie z.B. "Für alle x ..." ab. Sie findet daher meistens Verwendung, wenn über Datensätze iteriert werden soll oder wenn einfach Zahlenbereiche abgezählt werden.

In der Praxis ist die for-Schleife die am häufigsten verwendete Schleife, da bei ihr alle wichtigen Informationen, die zur Semantik einer Schleife gehören, im Kopf der Schleife stehen können. So verwenden manche Programmierer sogar Konstrukte wie for(;x>0;){...}, um while-Schleifen zu emulieren.

Aufbau einer for-Schleife

Eine for-Schleife besteht, so wie while- und do-while-Schleifen, aus einem Kopf und einem Rumpf.

Wichtig: Zwischen Kopf und Rumpf steht kein Semikolon.

Der Schleifenkopf

Aufbau

Das Schlüsselwort für eine for-Schleife ist das namensgebende for. Darauf folgt der Schleifenkopf mit folgendem Aussehen: ( 1. ; 2. ; 3. ).

Unter 1. sollte eine Zählvariable initialisiert werden, z.B. int i = 0;. Die hier aufgeführte Anweisung wird nur beim Eintritt in die Schleife ausgeführt. Die Zählvariable heißt so, da sie die Schleifendurchgänge zählt.

Unter 2. sollte eine Bedingung für das Ausführen der Schleife stehen, z.B. i < 5. Solange dies erfüllt ist, wird die Schleife ausgeführt.

Unter 3. sollte eine Fortsetzung stehen, die als letztes im Schleifenrumpf ausgeführt wird, z.B. ++i.

Der Schleifenkopf einer for-Schleife sieht insgesamt also so aus:

for(Initialisierung ; Bedingung ; Fortsetzung)

Beispiel

for( int i = 0 ; i < 5 ; ++i)

Der Schleifenrumpf

Aufbau

Als Schleifenrumpf wird der Programmcode bezeichnet, der in der Schleife wiederholt werden soll.

Wenn keine geschweiften Klammern gesetzt werden, wird nur der erste Befehl nach dem Schleifenkopf wiederholt. Wenn mehrere Befehle wiederholt werden sollen, dann muss auf den Schleifenkopf ein Block mit geschweiften Klammern folgen. Ein leerer Rumpf kann mit einem einzelnen Semikolon nach dem Schleifenkopf signalisiert werden.

Beispiele

Korrekte Beispiele

for (...)
{
  erg = erg + 5;
  System.out.println(erg);
}

Mit jedem Schleifendurchlauf wird die Variable erg um 5 erhöht. Danach wird diese, ebenfalls in jedem Durchlauf, ausgegeben. 

for (...);
erg = erg + 5;
System.out.println(erg);

Hier wird die Variable erg nur ein Mal um 5 erhöht und ausgegeben, da die Schleife durch das einzelne Semikolon nach dem Schleifenkopf einen leeren Rumpf hat. 

for (...)
  erg = erg + 5;
System.out.println(erg);

Hier wird bei jedem Schleifendurchlauf die Variable erg um 5 erhöht. Die Ausgabe gehört nicht mehr zu der Schleife, wird also nur einmal nach der Schleife ausgeführt.

Negativbeispiel

for (...)
  erg = erg + 5;
  System.out.println(erg);

Hier wird bei jedem Schleifendurchlauf die Variable erg um 5 erhöht. Diese Variable wird jedoch nur nach der Schleife einmal ausgegeben, da die Ausgabe nicht innerhalb der Schleife liegt. Das Einrücken der System.out.println(erg) - Zeile ist demnach falsch.

Die vollständige for-Schleife

Aufbau

for(Initialisierung ; Bedingung ; Fortsetzung)

{Befehl(e)}

Beispiele

for( int i = 0 ; i < 5 ; ++i)
{
  erg = erg + 5;
  System.out.println(erg);
}

Zunächst wird die Zählvariable i mit 0 initialisiert. Danach wird geprüft, ob i < 5 ist. Da dies korrekt ist, wird nun der Schleifenrumpf ausgeführt. Auf die Variable erg wird 5 aufaddiert und danach wird die Variable ausgegeben. Nun wird i auf 1 erhöht.

Der Schleifenkopf wird nun mit i = 1 ausgeführt. Die Initialisierung wird nicht mehr ausgeführt, da dies nur zu Beginn der Schleife gemacht wird. Es wird also direkt überprüft, ob i < 5 ist. 1 < 5 ist korrekt, der Schleifenrumpf wird also wieder ausgeführt. Der Variable erg wird nun wieder 5 hinzugefügt und danach wieder ausgegeben. Anschließend wird i auf 2 erhöht.

Analog werden die Fälle für i = 2, i = 3 und i = 4 ausgeführt.

Die Bedingung i < 5 ist bei i = 5 nicht mehr erfüllt. Daher wird der Schleifenrumpf nicht mehr ausgeführt. Die Zählvariable i wird nun verworfen.

Durch die Initialisierung von i mit 0 und dem Test i < 5 wird die Schleife genau 5 Mal durchlaufen. Es wäre natürlich auch möglich, die Schleife mit int i = 1 zu initialisieren und den Test i <= 5 durchzuführen. Dies ist jedoch aus mehreren Gründen unüblich. 


int b = 2;
for( int i = 0 ; i < 5 ; ++i)
{
  b = b*2;
}
System.out.println(b);

Genau wie im ersten Beispiel wird auch hier i mit 0 initialisiert und geprüft, ob i < 5 ist. Die Schleife wird also erneut 5 Mal durchlaufen. Die Variable b wird in jeder Iteration verdoppelt und enthält demnach am Ende den Wert b = (((((2*2)*2)*2)*2)*2). Dieser wird nach Beendigung der Schleife ausgegeben.

Von „https://ls14-eini.cs.tu-dortmund.de/index.php?title=Zählschleife&oldid=2228“