Verschachtelte Schleifen

[SegFault]

Hallo Zusammen ich habe folgendes Problem mit Schleifen. Ich mach das jetzt mal in einer Art Pseudo Java Code

while( irgendwas )  //Schleife 1.
{
    tue_was();
    while( was anderes ) //Schleife 2.
    {
         if ( bedingung1 )
         {
              //Hier muss zum Anfang der Schleife 1 gesprungen werden
         }
         else if ( bedingung2 )
         {
              //Hier muss zum Anfang der Schleife 2 gesprungen werden(Ich denke ein einfaches continue genügt)
         }
         else
         {
              //Beide Schleifen Abbrechen und normalen ablauf fortsetzen
          }
     }
}

Das ganze soll auch noch tiefer verschachtelt gehen. Dabei sollten in der letzten Schleife immer n+1 Bedingungen geprüft werden. Wobei jede Bedingung dazu führt das irgend eine übergeordnete Schleife erneut ausgeführt wird (Wie kann ich also gezielt zu Schleifen springen). Nur der Else Block führt zum Abbruch aller Schleifen. Mir fällt spontan nichts ein wie ich das (sinnvoll) lösen kann.

 

[SvenK]

Benannte Schleifen

Das erinnert mich zwar an GOTO (und mir wird ziemlich schlecht bei dem Gedanken), aber so würde es funktionieren

 

[0x7F800000]

              //Hier muss zum Anfang der Schleife 1 gesprungen werden

Ich sag jetzt zwar was, aber ich will dass du es am besten gleich wieder vergisst. In java sind prinzipiell labels erlaubt:

outer: for(;;){
   //do stuff
   for(;;){
       //do stuff
       if(thisOrThat){
            break outer; //oder continue outer
       }
    }
}

diese sollte man aber nur in ausnahmefällen bzw. gar nicht verwenden.

Das ganze soll auch noch tiefer verschachtelt gehen.

wie tief denn? Alles was wesentlich komplexer als 2 verschachtelte schleifen ist, ist hack. Man sollte dann einzelne schleifen in separate hilfsmethoden auslagern.

Dabei sollten in der letzten Schleife immer n+1 Bedingungen geprüft werden. Wobei jede Bedingung dazu führt das irgend eine übergeordnete Schleife erneut ausgeführt wird

Nix für ungut, aber das hört sich so an, als ob jemand, der die rekursion nicht gerafft hat, sich in den Fuß schießen will. Was hast du genau vor?

 

[icarus2]

So etwas hier wäre möglich:

while(irgendwas){
		
		boolean unterbrechen = false;
		
		while(was anderes){
			if (bedingug1){
				break;			
			}
			else if(bedingug2){
				continue;
			}
			else {
				unterbrechen = true;
				break;
			}
		}
		
		if(unterbrechen){
			break;
		}
	}

 

[SlaterB]

mach ne int-Variable returnTo = 1, 2, 3 .., wenn nicht Abbruch dann INT_MAX_VALUE

am Ende jeder Schleife kommt ein Block

if (returnTo <= eigene Stufe) {
  if (returnTo == eigene Stufe) {
     continue;
  }
  break;
}

 

[0x7F800000]

		if(unterbrechen){
			break;
		}
	}

uh je oh je... Das ist ja noch hackiger als goto's :autsch: Die goto's erfordern zumindest keine zusätzlichen unnötigen if-abfragen. :noe:

mach ne int-Variable returnTo = 1, 2, 3 .., wenn nicht Abbruch dann INT_MAX_VALUE

am Ende jeder Schleife kommt ein Block

if (returnTo <= eigene Stufe) {
  if (returnTo == eigene Stufe) {
     continue;
  }
  break;
}

Zwar unüblich, aber hin und wieder kann man ja auch mal Slater'sB Vorschläge in Frage stellen... ???:L Wozu soll denn so ein Konstrukt gut sein? :rtfm:

 

[icarus2]

Nun ja, schön ist es nicht, das stimmt. Wenn immer n ums 1 erhöht werden muss würde sich vielleicht wirklich die Rekursion anbieten.

Edit:

[Java]
while(!unterbrechen){

while(was anderes){
if (bedingug1){
break;
}
else if(bedingug2){
continue;
}
else {
unterbrechen = true;
break;
}
}
}
[/Java]

Ist das so etwas weniger grässlich?

 

[SegFault]

Das es sehr an ein GOTO Erinnert war mir klar, war auch mein erster Gedanke aber das gibts ja nicht.

Vielleicht komme ich doch eher weiter wenn ich sage was ich damit machen will.
Ich möchte Automatisiert Quellcode erzeugen. Das ganze geschieht aufgrund eines Petrinetzes.
Optisch sieht das ein wenig wie ein Programmablaufplan aus.
Und dort ist es erlaubt Konstrukte zu erzeugen die im Ablauf eine Verzweigung beinhalten welche innerhalb eines Verzweigungspfades an weiter vorne liegenden Stellen springen. Und das muss ich nun irgendwie hinbiegen und wollte das per Schleife lösen.

Mir fällt auch keine wirklich brauchbare lösung ein. Ich denke auch in der Realtität wird dieser Fall so gut wie nie vorkommen somit werde ich ihn per Definition ausschließen.

 

[0x7F800000]

hmm, nun ja, im generierten code ist schon einiges mehr erlaubt, der zählt nicht so ganz als code, der soll einfach nur stimmen.

Was du da aber genau machen willst kann ich mir persönlich nicht so recht vorstellen, vielleicht weiß hier einer mehr von petrinetzen...

 

[SegFault]

Prinzipiell sind Petrinetze nichts anderes als eine art Programmablaufplan, nur eben für Parallele Prozesse. Die Parallelität hab ich jetzt aber erstmal hier rausgelassen weil sie für das Problem hier kein Bezug haben.

GGf generier ich labels oder ich nehme einfache Schleifen und sorge dafür das ein Über Kreuz aufrufen von solchen Schleifen nicht erlaubt ist. Das sollte sich Auswerten lassen. So das geschachtelte Schleifen OK sind aber sobald ich höher als eine Ebene zurück Springen will (einfaches break, bzw continue) wird das nicht erlaubt.