LOOP aus Unterfunktionen z.B. benutzen

[Manfred]

ich denke mal viele programmieren Funktionen, in denen etliches an Quelltext aufgeführt wird. Ich habe mal im Jahr 2001 einen Weiterbildungskurs belegt in JAVA, in dem der Dozent meinte, man soll möglichst alles in Funktionen packen, das z.B. das Main Programm nur Funktionsaufrufe hat, aber möglichst wenig bis keine weiteren Zeilen Quelltext. Z.B.

Code: Alles auswählen

PROCEDURE main()
tu1()
tu2()
tu3()
usw.
return

OK, das ist sicherlich nicht das Problem. Was wäre aber, wenn nun z.B. folgendes eintreten würde?

Code: Alles auswählen

PROCEDURE main()
tu1()
tu2()
Do while
     tu3()
     tu4()
EXIT
enddo
return

Tu3() würde einmal ein Ergebnis liefern welches ein Loop hervorruft und einmal eins, welches ein EXIT hervorruft. Da ich das aber nicht einfach nur so in die Funktion Tu3() einbinden kann, weil der Compiler dann sicherlich meckern würde (es fehlt im ja dann die Do While Angabe). Ich aber auch keine zusätzlichen Zeilen unter tu3() schreiben möchte (auch aus besagtem oben erwähnten Grund). Wie müßte man dann sowas lösen? Geht das überhaupt so? Mit dem EXIT wäre sicherlich möglich, wenn man mit Begin Sequence statt Do While arbeiten würde (Habe ich in meinem Projekt hier inflationär genutzt wie schon mehrfach erwähnt in anderen Threads) und dann eine BREAK angibt würde die "Do While" Schleife ja verlassen.

Ich fand den Vorschlag sehr interessant, weil man dann nur "schlanken" Code sieht, sich aber im Zweifelsfall die entsprechende Funktion aufrufen kann.

[Manfred]

Sorry, es soll natürlich heißen, Tu3() kann ein LOOP ODER ein EXIT hervorbringen.

[satmax]

Verstehe ich eventuell falsch, aber einfach so:

Code: Alles auswählen

PROCEDURE main()
tu1()
tu2()
Do while  tu3()
enddo
tu4()
return

oder

Code: Alles auswählen

PROCEDURE main()
tu1()
tu2()
Do while  tu3()
 tu4()
enddo
...
return

Oder die Schleife in tu3, ...

Wie oben erwähnt, eventuell verstehe ich hier etwas falsch.

[Manfred]

Die Do While Schleife reagiert erst wenn sie wieder am Anfang steht. Wenn zwischendurch Tu3() ein .F. liefern würde, wird alles erst abgearbeitet was danach kommt. Das darf aber nicht Tu3() sagt was zu tun ist und dann aber sofort. Sollte aber auch nur als Beispiel stehen.

Ach so, habe ich jetzt erst erkannt. ICh möchte auch nicht eine Abfrage um Tu3() z.B. bauen. Dann habe ich ja wieder unnötigen Code verbaut. Tu3() aufrufen und mehr nicht.

[satmax]

Da müsste tu3 in einem Tread laufen oder eine Eventschleife haben. Dann würde ich tu4 gleich innerhalb von tu3 aufrufen, also tu3() änhlich einer state maschine aufbauen.

[Manfred]

also wie gesagt, ein Abbruch könnte mit Begin Sequence BREAK umgesetzt werden. Das geht in Unterfunktionen nach oben durchzusetzen. Das habe ich schon umgesetzt gesehen. Aber ist das der elegante Weg?

[Wolfgang Ciriack]

Wenn tu3 ein Funktion ist und verschiedenen Rückgabewerte haben kann, sollte man diese auch auswerten, sonst brauchst du keine function, dann nimm procedure. Meine Meinung

[Manfred]

NEEEEE

ich kann ja eine IF Abfrage über etliche Zeilen einbauen. Dann kann es ja verschiedene Ergebnisse geben. Eins, das einen erneuten Durchlauf macht (LOOP) eins, dass einen Abbruch macht (EXIT) oder eins, das alles nachfolgende durchläuft. Ich möchte nur einfach die IF Abfrage oder was es auch immer wäre auslagern. Das war meine Eingangsfrage. Mehr nicht. Und die Auwertung soll ja in der Funktion stattfinden. Es soll halt nicht alles in der Hauptprocedure stehen. Alles nur Funk auf Funk. Mehr nicht.
Es ist auch nur eine Idee, weil ich es halt so einmal gehört hatte. So kurz vor Weihnachten gibt es eben noch/wieder viel Hoffnung.....

[Martin Altmann]

Wenn abhängig vom Ergebnis einer Funktion eine andere Funktion aufgerufen werden soll oder aber nicht, dann kannst Du das nur mit entsprechenden "Strukturkommandos" im Hauptgerüst erreichen!
Ansonsten müsstest Du den Aufruf von Tu4() in Tu3() verlagern.
Punkt!

[Martin Altmann]

Eine andere Möglichkeit gäbe es nur bedingt, wenn Du als einen Parameter für die Tu4() die Tu3() mitgibst - dann würdest Du in Tu4() als Parameter das Ergebnis des Aufrufes haben und könntest entsprechend reagieren (z.B. die Funktion wieder verlassen).
Damit hast Du aber nicht erreicht, dass Dein Konstrukt erneut aufgerufen wird (oder auch nicht).

Viele Grüße,
Martin

[Manfred]

Au weiah,

Ziel des ganzen ist es doch nur die Codes in eine Funktion auszulagern. Aber dieser Einwand zeigt mal wieder, dass die Aussage von damals wohl nicht ganz zuende gedacht war. Weil mir das jetzt auch wieder in den Sinn kommt, dass ja auch Unterroutinen aufgerufen werden können. Und damit ist ja das Vereinfachen wieder komplizierter geworden. Außer man gliedert nur den Code aus, der keine weiteren Routinen aufruft. Aber die Reihenfolge sollte schon so sein, wie eingangs aufgelistet. So war auch die Aussage des Dozenten.

[Wolfgang Ciriack]

Dann must du mindestens, so wie Martin auch schrieb, es so machen:

Code: Alles auswählen

PROCEDURE main()
tu1()
tu2()
Do while
     x:=tu3()
     tu4(x)
EXIT
enddo
return

und in tu4 den Rückgabewert von tu3 beachten. Oder

Code: Alles auswählen

Do while
     tu4( tu3() )
EXIT
enddo

[Manfred]

jaja, deshalb ja meine Erkenntnis, dass es damals keine zuende gedachte Idee war. Wenn nämlich 30 Funktionen aufeinander folgen, die evtl. noch von der vorherigen ein wenig abhängig sind, dann wird es eng mit den Parametern. Also nur interessant, wenn es um Code geht, der nur irgendwas macht, aber nicht für einen Abbruch, oder eine Wiederholung sorgt.

[Herbert]

Hallo Manfred
Deine Denkweise ist wieder mal in Höchstform

Wolfgangs Denkansatz finde ich sehr gut. Oder es müsse die Schlaufe auch in eine der Prozeduren hinein...

Mein Käse dazu:
Ob Prozedur oder Funktion ist egal. Beides folgt derselben Idee. Variablen können doch auch per Referenz übergeben werden und verändern sich inhaltlich im aufrufenden Programm.
Einfacherweise gelten folgende Regeln:
- wenn derselbe Code mehr als einmal verwendet wird, muss eine Funktion geschrieben werden. Prozeduren sind übrigens zu vermeiden, denn ich kann auf die Auswertung eines Rückgabewertes verzichten. Sehr oft ist ein Return false oder true hilfreich. Es könnte auch so lauten

Code: Alles auswählen

   IF NOT tu(4) THEN
      EXIT

- wird ein Codeteil unübersichtlich, kann ein logisch zusammengehörender Teil in eine Funktion weggelagert werden.
- in einer Sache Eigenständiges wird in eine Klasse gelegt

Wie du am Schluss selber feststellst, darf dies nicht zu zerstückelt passieren, sonst läufst du Gefahr, dass Verschachtelungen entstehen, welche sehr eigenartige Ergebnisse produzieren können.