Continue + Repeat-Until

[himitsu]

Ich dachte ja bisher Continue springt zum Anfang der Schleifen?

Also bei For und While ist es ja so (oder scheint so, da es vom Ende eh immer zum Anfang geht), aber mir scheint es grad so, als wenn bei Repeat zum Ende gesprungen wird?

Problem:
ich hab soeine Schleife ... und wollte mir damit sozusagen ein GOTO ersparen (weil es ja alle hassen)

Delphi-Quellcode:

Repeat
  ... 
  if ... then Continue;
  ...
Until True;

nur springt Delphi bei Continue aus der Schleife raus (halt wie bei Break), anstatt sie zu wiederholen o.O


hab ich da nun falsch gedach, oder geht hier was nicht richtig? (D2009 ... werd's dann daheim nochmal in was älterem Versuchen)


[add]
im aktuellen Fall könnt ich, statt Continue, auch einfach die Funktion auch einfach rekursiv sich selber aufrufen lassen, aber dann nehm ich lieber ein knuffiges Goto :stupid:

Delphi-Quellcode:

Class Function TXMLNodeList.ParseNodePath(Var Nodes: TXMLNodeList; Var NodeName: TWideString; PathOptions: TMXLNodePathOptions): Boolean;
  Var S:   TWideString;
    i, i2: Integer;
    Node:  TXMLNode;

  Begin
    Repeat
      i  := Pos('\', NodeName);
      i2 := Pos('/', NodeName);
      If (i2 > 0) and (i2 < i) Then i := i2;
      If i > 0 Then Begin
        S := Copy(NodeName, 1, i - 1);
        System.Delete(NodeName, 1, i);
        If S = '..' Then Begin
          If Assigned(Nodes) and Assigned(Nodes.Parent) Then
            Nodes := Nodes.Parent.ParentList Else Nodes := nil;
        End Else If S <> '.' Then
          If xpNotCreate in PathOptions Then Begin
            If xpNonFilered in PathOptions Then Begin
              If Nodes.IndexOfNF(S) < 0 Then Node := nil Else Node := Nodes.NodeNF[S];
            End Else
              If Nodes.IndexOf(S)   < 0 Then Node := nil Else Node := Nodes.Node[S];
            If Assigned(Node) Then Nodes := Node.Nodes Else Nodes := nil;
          End Else If xpDoCreate in PathOptions Then Begin
            If xpNonFilered in PathOptions Then Node := Nodes.NodeNF[S] Else Node := Nodes.Node[S];
            If Assigned(Node) Then Nodes := Node.Nodes Else Nodes := Nodes.Add(S).Nodes;
          End Else Begin
            If xpNonFilered in PathOptions Then Node := Nodes.NodeNF[S] Else Node := Nodes.Node[S];
            If Assigned(Node) Then Nodes := Node.Nodes Else Nodes := nil;
           End;
        Continue;
      End;
    Until True;
    Result := Assigned(Nodes);
  End;

[Satty67]

Nach meinem Verständnis...

Continue führt bei while den nachfolgenden Code nicht mehr aus und springt zur while-Prüfung zurück.

Bei Repeat Unil wird der nachfolgende Code auch nicht mehr ausgeführt und auch zu Prüfungsstelle gesprungen, was hier aber Until (True/False) ist. Ist Until = True entspricht continue technisch einem Break.

[fui-tak]

Bei mir funktioniert der Continue Befehl auch ohne Probleme:

Delphi-Quellcode:

procedure TForm1.Button1Click(Sender: TObject);
var a:integer;
begin
   a := 0;
   label1.caption := '';
   repeat
   begin
     a := a + 1;
     if a = 5 then
       Continue;
     label1.caption := label1.caption + IntToStr(a);
   end
   until a >7;
end;

hier ist am Ende der Text von Label1 1234678, die fünf fehlt also


Wird also wahrscheinlich was mit der Bedingung zu tun haben

[gammatester]

Delphi-Quellcode:

repeat .. until true;

kann man wohl kaum als Schleife bezeichen. Technisch schon, aber meinst Du nicht

Delphi-Quellcode:

repeat .. until false;

[himitsu]

OK, ich hab grad mal die neue Hilfe angesehn und da steht jetzt tatsächlich folgendes:

Zitat:

Die Anweisung continue wird innerhalb von Schleifen benutzt, um die Steuerung an das Ende der innersten Schleife zu übergeben,

also es wird wirklich zum Ende gesprungen.


früher hieß es allerdings so und da hätte End (bei For und While) bzw. Unntil (Repeat) nicht angesprungen werden dürfen -.-°

Zitat:

Die Prozedur setzt die Programmausführung mit dem nächsten Durchlauf einer for-, while- oder repeat-Schleife fort.

hab in D7 grad mal dieses ausführen lassen (in FormCreate 'ner leeren/neuen Anwendung)

Delphi-Quellcode:

function X: Boolean;
  begin
    Result := True;
  end;

begin
  repeat
    Sleep(0);
    if Tag = 0 then Continue;
    Beep;
  until X;
end;

und es geht Sleep > Continue > X > end;

also es war schon immer so, nur kam es mir anders vor und es stand auch falsch in der OH :?


nja, danke erstmal ... da sucht man seit 2 Tagen 'nen Fehler und dann sowas :wall:

[add]
ach ja ... ich nehm jetzt Goto und @ gammatester ... es sollte eine Repeat-Continue-Schleife werden:mrgreen:

[jfheins]

Du könntest das ganze auch etwas abwandeln:

Delphi-Quellcode:

repeat 
  ... 
  if ... then Continue; 
  ... 
  break;
Until false;

Dann fängts beim continue wieder oben an ;)

(Aber ein wenig komisch siehts immernoch aus ...)

[himitsu]

joar, das mit'm Break war mir auch schon eingefallen ...
und wie du schon sagtest ... hübsch isses nich :|

Das Problem war hier einfach, daß ich es anders im Kopf hatte (siehe alte OH von D7)
und es eigentlich ganz anders war (siehe neue OH von D09) :wall:

ansonsten fiehlen mir noch im Zusammenhanb mit meinem Problem solche Lösungen ein:

Delphi-Quellcode:

// Beispiel von oben (gekürzt)
Class Function TXMLNodeList.ParseNodePath(...
  Begin
    Repeat
      ...
      If i > 0 Then Begin
        ...
        Continue;
      End;
    Until True;
    Result := Assigned(Nodes);
  End;

// rekursive Lösung
Class Function TXMLNodeList.ParseNodePath(...
  Begin
    ...
    If i > 0 Then Begin
      ...
      ParseNodePath(...
    End;
    Result := Assigned(Nodes);
  End;

// rekursive Lösung - Result anders gesetzt
Class Function TXMLNodeList.ParseNodePath(...
  Begin
    ...
    If i > 0 Then Begin
      ...
      Result := ParseNodePath(...
    End Else Result := Assigned(Nodes);
  End;

// via Goto - wie ich's jetzt hab
Class Function TXMLNodeList.ParseNodePath(...
  Label Loop;
  Begin
    Loop:
    ...
    If i > 0 Then Begin
      ...
      Goto Loop;
    End
    Result := Assigned(Nodes);
  End;

[samso]

oder auch:

Delphi-Quellcode:

While true Do 
Begin
  ...
  If i > 0 Then Begin 
      ... 
  End
  Else
    break;
end;
Result := Assigned(Nodes);

oder vielleicht:

Delphi-Quellcode:

Repeat
  ...
  If i > 0 Then Begin 
      ... 
  End
Until i<=0;
Result := Assigned(Nodes);

[himitsu]

Zitat:

Zitat von samso

oder vielleicht: ...

stümmt eigentlich, jetzt wo ich zuletzt die Variablen verringer/aufgeräumt hatte, ginge das ja auch :shock:
ich glaub ich nehm dann besser mal diese Variante :stupid: