# Verschachtelte Schleifen



## SegFault (24. Apr 2009)

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 (24. Apr 2009)

*Benannte Schleifen*

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


----------



## 0x7F800000 (24. Apr 2009)

SegFault hat gesagt.:


> ```
> //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 (24. Apr 2009)

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 (24. Apr 2009)

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 (24. Apr 2009)

icarus2 hat gesagt.:


> ```
> 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:




SlaterB hat gesagt.:


> mach ne int-Variable returnTo = 1, 2, 3 .., wenn nicht Abbruch dann INT_MAX_VALUE
> 
> am Ende jeder Schleife kommt ein Block
> 
> ...


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 (24. Apr 2009)

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 (24. Apr 2009)

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 (24. Apr 2009)

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 (24. Apr 2009)

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.


----------

