Was genau ist der Unterschied zwischen einer For und einer While bzw Do While Schleife?

Ich verstehe noch nicht ganz was genau der unterschied ist. Eigentich könnte man doch mit allen drei Methoden dasselbe programmieren?

Bzw. kann mir jemand Anwendungsgebiete für die jeweiligen Schleifen nennen? Wofür man was am besten nutzt...

Answer 1

[IProxy]

Grundsätzlich kannst du aus einer do while schleife alle anderen schleifen Bauen

Bei einer while schleife wird die Bedingung kontrolliert und dann die Anweisung ausgeführt.

Bei einer Do while schleife wird ausgeführt und dann kontrolliert. Führt dazu, das der code minimum einmal ausgeführt wird.

Eine for schleife wird benutz wenn man weiß wie viele schleifendurchläufe man braucht. Z.B einen Countdown.

Answer 2

[Willibergi]

Vielleicht helfen Dir die formalen Namen der drei Schleifen etwas weiter:

• for-Schleife: Zählschleife
• while-Schleife: kopfgesteuerte Schleife
• do-while-Schleife: fußgesteuerte Schleife

Die for-Schleife wird verwendet: entweder wenn man in jedem Schleifendurchgang wissen möchte, der wie vielte es ist oder wenn man schon im Voraus weiß, wie oft die Schleife durchlaufen werden soll. Sie zählt in jedem Durchlauf mit einer vorher definierten Zählvariable durch.

Will ich also die Zahlen von 1 bis 50 untereinander ausgeben, wäre die for-Schleife die richtige Wahl, da man einerseits die Zählvariable ("der wie vielte Schleifendurchlauf ist es?") als auszugebende Zahl verwenden kann (sie erhöht sich ja in jedem Durchlauf um 1) und andererseits genau weiß, wie oft die Schleife durchlaufen soll, nämlich 50 Mal.

Der Code sähe dann so aus (ich fange der Einfachheit halber hier bei 1 an zu zählen):

for(int i=1; i<=50; i++){
   System.out.println(i);
}

Im ersten Durchgang ist i=1 und es wird 1 ausgegeben. Im zweiten Durchgang ist i=2 und so weiter bis im 50. Durchgang i = 50 ist und die Schleife verlassen wird.

Die while-Schleife und die do-while-Schleife unterscheiden sich gar nicht gravierend voneinander. Der einzige Unterschied ist, dass in der while-Schleife am Anfang des Schleifendurchgangs die Bedingung überprüft wird und das bei der do-while-Schleife am Ende geschieht. Die do-while-Schleife wird also in jedem Fall mindestens einmal durchlaufen, auch wenn die Bedingung schon am Anfang falsch ist, da sie erst nach dem Durchgang überprüft wird (daher fußgesteuert).

while- und do-while-Schleifen verwendet man, wenn man eine Schleife so lange durchlaufen lassen will wie eine Bedingung erfüllt ist. Das kann sinnvoll sein, wenn es irrelevant ist, wie oft die Schleife genau durchlaufen wurde.

Im Prinzip ist eine for-Schleife auch nur eine erweiterte while-Schleife. Der Code oben ist beispielsweise gleichbedeutend mit diesem:

int i=1;
while(i <= 50){
   System.out.println(i);
   i++;
}

Um das allerdings kompakter zu gestalten, gibt es die for-Schleife. Also im Grundsatz gar kein großer Unterschied.

LG

Comments

[PWolff]

Lob für die ausführliche Erklärung!

-----

Ich wüsste keinen Compiler, der

for (init; test; incr) { body; }

NICHT durch

init;
while (test) {
  body;
  incr;
}

ersetzt (d. h. in völlig identischen Code umsetzt).

-----

Daneben gibt es in vielen Programmiersprachen noch ein

for each (type element in list) { body; }

wo die Verantwortung für Schleifendurchlauf und -abbruch an list delegiert wird.

[Willibergi]

@PWolff

Klar, im Compiler ist die Schleife gleich. Aber das sieht der Leser bzw. Schreiber des Codes ja nicht.

[PWolff]

@Willibergi

Stimmt auch wieder.

[PeterX593]

Die While-Schleife hat die allgemeine Form

while (bedingung){      anweisung₁;                    anweisung_n;}

Hier ist bedingung die Schleifen­bedingung. Es muss sich um einen Ausdruck handeln, der einen Wert vom Typ boolean, also true oder false ergibt. Die Schleifen­bedingung steht in runden Klammern hinter dem Wort while (engl.: while – solange).

Danach folgt in geschweiften Klammern der Schleifen­körper, also das Programm­stück, das wiederholt werden soll, hier dargestellt durch die Anweisungen anweisung₁, ..., anweisung_n. Jede Anweisung wird mit einem Semikolon abge­schlossen.

Bei Ausführung der While-Schleife wird zunächst geprüft, ob die Schleifen­bedingung erfüllt ist, d.h. ob sie den Wert true ergibt. Ist dies der Fall, so werden die Anweisungen des Schleifen­körpers ausgeführt. Wenn der Schleifen­körper fertig ausgeführt ist, springt das Programm wieder an den Anfang der While-Schleife und prüft erneut die Schleifen­bedingung. Ist diese immer noch erfüllt, wird der Schleifen­körper erneut ausgeführt usw. – solange, bis die Schleifen­bedingung irgendwann einmal nicht mehr erfüllt ist. Dann wird der Schleifen­körper nicht mehr ausgeführt, sondern es wird mit den hinter dem Schleifen­körper folgenden Anweisungen fortgefahren.

Beispiel:  Die folgende While-Schleife gibt die Zahlen von 1 bis 10 auf dem Bildschirm aus.

int i = 1;

while (i <= 10)
{
    System.out.println(i);
    i = i + 1;
}

Hier ist die Schleifen­bedingung der Ausdruck i<=10, und der Schleifen­körper besteht aus den zwei Anweisungen System.out.println(i) und i=i+1, jeweils abge­schlossen durch ein Semikolon.

Damit die Schleifen­bedingung ausgewertet werden kann, wird vor Beginn der While-Schleife die Variable i mit einem Wert belegt.

In diesem Beispiel ist die Schleifen­bedingung zu Anfang erfüllt, denn i hat den Wert 1, und es gilt 110. Somit wird mit System.out.println(i) der Wert von i, also die 1, auf dem Bildschirm ausgegeben, gefolgt von einem Zeilen­vorschub. Mit der Anweisung i=i+1 wird anschließend der Wert von i um 1 erhöht, also auf 2 gesetzt.

Damit ist der Schleifen­körper fertig ausgeführt. Das Programm springt wieder an den Anfang der While-Schleife und prüft erneut die Schleifen­bedingung. Diese ist immer noch erfüllt, denn es ist 210, also wird der Schleifen­körper erneut ausgeführt usw. – solange bis i den Wert 11 erreicht hat, dann wird der Schleifen­körper nicht mehr ausgeführt.

Der Programm­ablauf einer While-Schleife lässt sich wiederum mit Hilfe eines Fluss­diagramms ver­anschaulichen. Das Fluss­diagramm für das obige Beispiel­programm ist in Bild 1 dargestellt.

Bild 1: Flussdiagramm des Beispielprogramms (While-Schleife)

For-Schleife

Häufig dienen Schleifen dazu, Anweisungen eine bestimmte Anzahl von Malen zu wiederholen. Im vorigen Beispiel etwa wird zehnmal etwas ausgegeben. Wie wir gesehen haben, lässt sich dies mit einer While-Schleife realisieren. Ein kompakterer Programmcode ergibt sich jedoch bei Benutzung der For-Schleife:

int i;

for (i=1; i<=10; i=i+1)
{
    System.out.println(i);
}

Bei der For-Schleife werden die Initialisierung der Variablen (i=1), die Schleifen­bedingung (i<=10), sowie die Aktion, die am Ende des Schleifen­körpers stattfinden soll (i=i+1), zusammen­gefasst.

Die For-Schleife hat die allgemeine Form

for (initialisierung; bedingung; aktion){      anweisung₁;                    anweisung_n;}

Welche Initialisierung vorgenommen wird, wie die Bedingung aussieht, und welche Art von Aktion stattfindet, ist hierbei dem Programmierer überlassen – alle drei Teile können sogar leer sein. Es ist jedoch guter Programmier­stil, die For-Schleife tatsächlich nur so wie in obigem Beispiel zu benutzen, nämlich als Zählschleife. Bei einer Zählschleife erhält eine Laufvariable einen Anfangswert und "läuft" dann bis zu einem Endwert. In Beispiel etwa läuft die Laufvariable i von 1 bis 10.

Für Schleifen, die keine Zähl­schleifen sind, sollte die For-Schleife nicht verwendet werden.

 

Weiter mit:  [Entwurf von Programmschleifen]  oder  

 

Answer 3

[Crysali]

for-Schleifen und while-schleifen laufen nur, wenn eine Bedingung erfüllt ist, wohingegen eine do-while-Schleife genau einmal läuft, bevor geprüft wird, ob eine Bedingung erfüllt ist und die Schleife weiterläuft.

Oft braucht man die do-while-Schleife nicht, kann aber manchmal ganz nützlich sein.

• https://docs.microsoft.com/de-de/dotnet/csharp/language-reference/keywords/do

Comments

[PeterX593]

Die While-Schleife hat die allgemeine Form

while (bedingung){      anweisung₁;                    anweisung_n;}

Hier ist bedingung die Schleifen­bedingung. Es muss sich um einen Ausdruck handeln, der einen Wert vom Typ boolean, also true oder false ergibt. Die Schleifen­bedingung steht in runden Klammern hinter dem Wort while (engl.: while – solange).

Danach folgt in geschweiften Klammern der Schleifen­körper, also das Programm­stück, das wiederholt werden soll, hier dargestellt durch die Anweisungen anweisung₁, ..., anweisung_n. Jede Anweisung wird mit einem Semikolon abge­schlossen.

Bei Ausführung der While-Schleife wird zunächst geprüft, ob die Schleifen­bedingung erfüllt ist, d.h. ob sie den Wert true ergibt. Ist dies der Fall, so werden die Anweisungen des Schleifen­körpers ausgeführt. Wenn der Schleifen­körper fertig ausgeführt ist, springt das Programm wieder an den Anfang der While-Schleife und prüft erneut die Schleifen­bedingung. Ist diese immer noch erfüllt, wird der Schleifen­körper erneut ausgeführt usw. – solange, bis die Schleifen­bedingung irgendwann einmal nicht mehr erfüllt ist. Dann wird der Schleifen­körper nicht mehr ausgeführt, sondern es wird mit den hinter dem Schleifen­körper folgenden Anweisungen fortgefahren.

Beispiel:  Die folgende While-Schleife gibt die Zahlen von 1 bis 10 auf dem Bildschirm aus.

int i = 1;

while (i <= 10)
{
    System.out.println(i);
    i = i + 1;
}

Hier ist die Schleifen­bedingung der Ausdruck i<=10, und der Schleifen­körper besteht aus den zwei Anweisungen System.out.println(i) und i=i+1, jeweils abge­schlossen durch ein Semikolon.

Damit die Schleifen­bedingung ausgewertet werden kann, wird vor Beginn der While-Schleife die Variable i mit einem Wert belegt.

In diesem Beispiel ist die Schleifen­bedingung zu Anfang erfüllt, denn i hat den Wert 1, und es gilt 110. Somit wird mit System.out.println(i) der Wert von i, also die 1, auf dem Bildschirm ausgegeben, gefolgt von einem Zeilen­vorschub. Mit der Anweisung i=i+1 wird anschließend der Wert von i um 1 erhöht, also auf 2 gesetzt.

Damit ist der Schleifen­körper fertig ausgeführt. Das Programm springt wieder an den Anfang der While-Schleife und prüft erneut die Schleifen­bedingung. Diese ist immer noch erfüllt, denn es ist 210, also wird der Schleifen­körper erneut ausgeführt usw. – solange bis i den Wert 11 erreicht hat, dann wird der Schleifen­körper nicht mehr ausgeführt.

Der Programm­ablauf einer While-Schleife lässt sich wiederum mit Hilfe eines Fluss­diagramms ver­anschaulichen. Das Fluss­diagramm für das obige Beispiel­programm ist in Bild 1 dargestellt.

Bild 1: Flussdiagramm des Beispielprogramms (While-Schleife)

For-Schleife

Häufig dienen Schleifen dazu, Anweisungen eine bestimmte Anzahl von Malen zu wiederholen. Im vorigen Beispiel etwa wird zehnmal etwas ausgegeben. Wie wir gesehen haben, lässt sich dies mit einer While-Schleife realisieren. Ein kompakterer Programmcode ergibt sich jedoch bei Benutzung der For-Schleife:

int i;

for (i=1; i<=10; i=i+1)
{
    System.out.println(i);
}

Bei der For-Schleife werden die Initialisierung der Variablen (i=1), die Schleifen­bedingung (i<=10), sowie die Aktion, die am Ende des Schleifen­körpers stattfinden soll (i=i+1), zusammen­gefasst.

Die For-Schleife hat die allgemeine Form

for (initialisierung; bedingung; aktion){      anweisung₁;                    anweisung_n;}

Welche Initialisierung vorgenommen wird, wie die Bedingung aussieht, und welche Art von Aktion stattfindet, ist hierbei dem Programmierer überlassen – alle drei Teile können sogar leer sein. Es ist jedoch guter Programmier­stil, die For-Schleife tatsächlich nur so wie in obigem Beispiel zu benutzen, nämlich als Zählschleife. Bei einer Zählschleife erhält eine Laufvariable einen Anfangswert und "läuft" dann bis zu einem Endwert. In Beispiel etwa läuft die Laufvariable i von 1 bis 10.

Für Schleifen, die keine Zähl­schleifen sind, sollte die For-Schleife nicht verwendet werden.

 

Weiter mit:  [Entwurf von Programmschleifen]  oder  

 

Answer 4

[LisamagPferde04]

Einfach zusammengefasst:
For bei einer vorher bekannten Länge. Zum Beispiel bei arrays.

While und do while wenn es vorher unbekannt ist wie lange etwas laufen soll.
Bei do wird der Inhalt aber auf jeden Fall einmal ausgeführt. So kann manchmal Redundanz im Code vermieden werden.

Comments

[safur]

Schön gesagt, man könnte noch Kopf und Fuß-gesteuerte Schleifen erklären :-)