Unterschied While-Schleife <-> RepeatUntil-Schleife

[Crattely]

Hi
ich muss im Informatikunterricht ein Referat über die While-Schleife und die RepeatUntil-Schleife halten.
Ich habe auch soweit schon alles vorbereitet, allerdings hat mein Lehrer mir jetzt heute gesagt, dass ich noch ein Beispiel bringen soll, an dem man den Unterschied zwischen den beiden Schleifen (kopfgesteuert/fußgesteuert) sieht.
Dabei sollte bei diesem Beispielprogramm halt eine Schleife funktionieren und die andere nicht.

Hat jemand hier eine Idee was ich da für ein Programm nehmen könnte ?
Ihr müsst mir keinen kompletten Quelltext schreiben, mir reciht schon eine Idee.
Dazu sollte man vielleicht sagen, dass wir noch auf Konsolenebene programmieren, muss also nicht Großartiges sein.

[himitsu]

Im Prinzip mußt du dir ja nur erstmal überlegen was genau der Unterschied ist.

Bei REPEAT wird erst der Schleifeninhalt ausgeführt und dann die Abbruchbedingung (eigentlich die Fortzetzungsbedingung) gebrüft, womit immer mindestens einmal die Schleif durchlaufen wird.
Beim WHILE wird immer zuerst geprüft und dann ausgeführt (oder auch nicht).



Du brauchst also Beispiele, wo dieses Prüfungsverhalten benötigt wird:

- das Liefern einer "eindeutigen" Zufallszahl
(erst Zahl bestimmen, dann prüfen ob's die schon gab und wenn ja, dann nochmal suchen)

- einen Wert in einer Liste suchen
(hier muß ja zuerst geprüft werden, ob der Index/Eintrag noch in der Liste vorkommt, bevor man drauf zugreift ... z.B. für Listen mit EoF)

[jfheins]

Moin,
also erstmal ist natürlich zu sagen, dass die beiden Schleifen wirklich gleich mächtig sind. Was mit der einen geht, geht auch mit der anderen - ganz sicher. Es sind dann vielleicht ein paar Codezeilen mehr.
So als Beispiel würde mir einfallen: Zahleneingabe auf der Konsole. Wenn Buchstaben eingegeben wurden, Fehler ausgeben und nochmal fragen. (repeat ist praktischer)

[DeddyH]

Schaff doch einfach eine Bedingung, die nicht zutrifft. Diese nimmst Du bei dann bei beiden als Schleifenbedingung. Z.B.

Delphi-Quellcode:

Zahl := 10;
while Zahl < 10 do
  begin
    ...
  end;
repeat
  ...
until Zahl >= 10;

[edit]

Zitat von jfheins:

Was mit der einen geht, geht auch mit der anderen - ganz sicher.

Vorsicht! Man muss immer im Hinterkopf behalten, dass die Fußschleife mindestens einmal durchlaufen wird. Greift man also im Schleifenkörper auf etwas zu, was gar nicht da ist, macht es *Bumm*. In der Kopfschleife kann man das vorher prüfen (OK, bei einer Fußschleife auch, aber dann nicht erst in der Schleifenbedingung). [/edit]

[himitsu]

Zitat von jfheins:

Was mit der einen geht, geht auch mit der anderen - ganz sicher. Es sind dann vielleicht ein paar Codezeilen mehr.

Ganz sicher nur, wenn man eventuell weitere IFs oder die Bedingung um weitere Prüfungen erweitert.

Im Prinzip kann man sich ganz leicht entscheiden was man am Besten nehmen sollte:
- Kommt der Wert für die Abbruchbedingung aus dem Schleifeninhalt, wird also innerhalb der Schleife bestimmt, dann REPEAT, welches nach der Schleife auswertet.
- Kommt die Abbruchbedingung hauptsächlich von außerhalb und muß vor der Schleifenabarbeitung geprüft werden, dann WHILE.

Es gibt dann noch ein paar Mischbedingungen, wo man sich dann entscheiden muß, was man als besser/einfacher hält.

FOR ist z.B. eine WHILE-Schleife, bzw. es arbeitet genauso wie diese, nur daß der Grenzwert für die Abbruchbedingung schon vor dem ersten Durschlauf bestimmt und zwischendurch nicht neu berechnet wird und daß es eben immer eine einschrittige Zählvariable gibt, welche sich (offiziell) auch nicht beeinflussen läßt.

[Popov]

Also repeat-until nimmt man, wenn die Schleife mindestens ein Mal ausgeführt werden soll. Hier ein kleines Beispiel:

Delphi-Quellcode:

var
  Eingabe: string;
begin
  repeat
    Eingabe := InputBox('Eingabe', 'Geben sie einen Namen ein', '');
  until Trim(Eingabe) <> '';

  ShowMessage('Der Name lautet: ' + Eingabe);
end;

Die repeat-until Schleife achtet hier drauf, dass ein Name eingegeben wird. Zuerst wird über InputBox nach einem Namen gefragt. Wird ein leeres Feld zurückgegeben (das wird in until geprüft) geht es zurück zu repeat und die Frage wird wiederholt. Das Ganze wird wiederholt bis die Eingabe nicht leere ist.

Ein weiteres Beispiel. Gesucht sind Zufallszahlen 2, 5 oder 7. In der Schleife wird einfach eine Zufallszahl zwischen 0 und 9 erzeugt, aber so lange wiederholt bis die Zufallszahl entweder 2, 5, oder 7 ist.

Delphi-Quellcode:

var
  k: Integer;
begin
  Randomize;
  repeat
    k := Random(10);
  until (k = 2) or (k = 5) or (k = 7);

  ShowMessage('Die Zufallszahl aus 2, 5 oder 7 lautet: ' + IntToStr(k));
end;

-----------------

Bei while wird zuerst geprüft ob die Schleife überhaupt nötig ist. Ein schönes Beispiel findet man zu Pos Funktion:

Delphi-Quellcode:

var
  S: string;
begin
  S := '   123.5';
  { Leerzeichen in Nullen konvertieren }
  while Pos(' ', S) > 0 do
    S[Pos(' ', S)] := '0';
end;

In S ist eine Zahl die vorne paar Leerzeichen enthält. In der while Zeile wird zuerst geprüft ob sich in S noch ein Leerzeichen befindet, wenn ja dann wird es in der Schleife durch ein 0 Zeichen ersetzt.

Vereinfacht könnte man sagen, dass es bei while bereits ein Ergebnis gibt, das lediglich mit Hilfe von while-Schleife irgendwie noch bearbeitet oder überprüft wird. Bei repeat wird in der Schleife erst das Ergebnis erzeugt und dann unter until überprüft. Wie gesagt, vereinfacht dargestellt.

[Furtbichler]

WHILE: "Solange hier jemand ist, hau ich mir eine aufn Kopp'.
REPEAT: "Ich haue mir solange eine auf den Kopf, bis keiner mehr da ist".

Wenn ich nun ganz alleine bin, gehe ich im ersten Fall schmerzfrei aus, weil ich erst schaue, ob jemand da ist.
Im zweiten Fall hau ich erstmal drauf los und merke hinterher erst, wie blöd ich war.

In einem Workshop ging es um das Iterieren in einem Array.

Delphi-Quellcode:

i := 0;
While i < ElementAnzahl do begin
  if A[i] = GesuchteZahl then
    GesuchterIndex := i;
  i := i + 1
end;
...
i := 0;
repeat
  if A[i] = GesuchteZahl then
    GesuchterIndex := i;
  i := i + 1
until i >= ElementAnzahl;

Beide Schleifen machen auf den ersten Blick das Gleiche.

Aber was ist, wenn die ElementAnzahl=0 ist?

[Maya]

Du könntest doch einfach ein kleines Progi machen, mit einen Edit-Feld, wo du Zahlen eingibst und zwei Labels, eine für die WHILE-Schleife und eine für die REPEAT-Schleife.

Beim Knöpfchen-Drücken, werden dann die Schleifen mit der eingegebenen Zahl ausgeführt. In den zwei Labels wird dann angezeigt, wie oft die Schleife ausgeführt wurde. Wenn die Schleife

Ich hab da mal was vorbereitet: (bitte das jetzt mit der legendären Jean Pütz-Stimme vorstellen)

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var Zahl: Integer;
    Beschriftung: String;
begin
  if Trim(Edit1.Text)<>'' then
    begin
      Zahl:=StrToInt(Edit1.Text);
      While Zahl<10 do
        begin
          Beschriftung:=lblWhile.Caption+#10#13+IntToStr(Zahl);
          lblWhile.Caption:=Beschriftung;
          Zahl:=Zahl+1;
        end;

      Zahl:=StrToInt(Edit1.Text);
      Repeat
        Beschriftung:=lblRepeat.Caption+#10#13+IntToStr(Zahl);
        lblRepeat.Caption:=Beschriftung;
        Zahl:=Zahl+1;
      Until Zahl<10;
    end;
end;

Ich weiß jetzt nicht, welches Delphi du nimmst, ggf. musst du bei dem Edit halt einstellen, dass da nur Zahlen 'reindürfen (NumbersOnly) oder halt kurz was kleines Schreibseln, dass da nur Zahlen 'rein können.

EDIT: Mir fällt gerade auch auf, dass bei der REPEAT-Schleife sich bei Zahlen, die größer als 10 sind, eine Endlosschleife bildet. Ich war schon immer Meisterin der Endlosschleifen. -.- Ich schau mal, ob ich das behoben bekomme.

[Bummi]

Bei Zahlen kleiner Zehn hast Du auch eine Problem bei Deiner Repeatschleife

[Maya]

Zitat von Bummi:

Bei Zahlen kleiner Zehn hast Du auch eine Problem bei Deiner Repeatschleife

Nein, wieso? Er führt sie einmal aus und dann war's das. Hab es eigentlich mehrmals getestet.

Nicht gleich schreien: ich teste noch mal!

EDIT: Er führt die bei mir genau einmal durch. Da sieht man doch den gewünschten Unterschied.