4.8 Prozeduren und Funktionen 

In Visual Basic haben Sie als Entwickler die Möglichkeit, eigene Prozeduren und Funktionen zu schreiben. Dies hat folgende Vorteile:
- Gleiche oder ähnliche Vorgänge müssen nur einmal beschrieben werden und können dann beliebig oft ausgeführt werden.
Modularisierung
- Umfangreiche Programme werden modularisiert, d. h. sie werden in kleinere Bestandteile zerlegt, die übersichtlicher sind und einfacher gewartet werden können.
Im Wesentlichen unterscheiden sich Funktionen von Prozeduren dadurch, dass sie nicht nur eine Reihe von Anweisungen ausführen, sondern auch einen Funktionswert, beispielsweise das Ergebnis einer Berechnung, zurückliefern können.
Methoden
Im Zusammenhang mit der Objektorientierung wurde bereits der Begriff der Methode verwendet. Methoden sind Funktionen, die auf ein bestimmtes Objekt oder eine bestimmte Klasse bezogen sind. Sie verfügen über die Möglichkeiten von Prozeduren und Funktionen und weitergehende Möglichkeiten.
4.8.1 Prozeduren 

In einer Prozedur sind Anweisungen zusammengefasst, die als logische Einheit zusammen ausgeführt werden sollen. Durch eine klare Aufgabenteilung zwischen verschiedenen Prozeduren wird der Programmcode übersichtlicher und kann einfacher gewartet werden. Wir haben bereits Ereignisprozeduren und (in einem kleinen Beispiel) allgemeine Prozeduren kennengelernt.
Allgemeine Prozedur
Allgemeine Prozeduren sind nicht mit Ereignissen verbunden und haben folgenden (vereinfachten) Aufbau:
Sub Prozedurname (Argumentliste) [ Anweisungsblock ] [ Exit Sub ] [ Anweisungsblock ] End Sub
Argumente
Besteht die Argumentliste aus mehreren Argumenten, so werden diese durch Kommata voneinander getrennt.
Exit Sub
Die Anweisung Exit Sub kann eingesetzt werden, um die Prozedur aufgrund einer speziellen Bedingung sofort und nicht erst am Ende zu verlassen.
Der Aufruf erfolgt üblicherweise wie folgt:
Prozedurname(Argumentliste)
Parameter
Hinweis: Statt des Begriffs Argument (bzw. Argumentenliste) wird auch häufig der Begriff Parameter (bzw. Parameterliste) verwendet.
Im nachfolgenden Beispiel wird die Prozedur ZeigeMaximum() von zwei verschiedenen Stellen aus aufgerufen. Sie berechnet jeweils das Maximum der beiden übergebenen Argumente und gibt dieses aus (Projekt Prozeduren).
Public Class Form1 Private Sub cmdAnzeige1_Click(...) Handles ... Dim a As Double Dim b As Double a = 4.5 b = 7.2 ZeigeMaximum(a, b) End Sub Private Sub cmdAnzeige2_Click(...) Handles ... Dim c As Double Dim d As Double c = 23.9 d = 5.6 ZeigeMaximum(c, d) End Sub Sub ZeigeMaximum(ByVal x As Double, ByVal y As Double) If x > y Then lblAnzeige.Text = x Else lblAnzeige.Text = y End If End Sub End Class
Listing 4.23 Projekt »Prozeduren«
Zur Erläuterung:
- Die Prozedur ZeigeMaximum() hat zwei Argumente, die beiden Double-Variablen x und y. Folglich muss die Prozedur auch mit zwei (möglichst Double-) Variablen aufgerufen werden, denn sie erwartet dies.
ByVal
- In der ersten Ereignisprozedur wird die Prozedur ZeigeMaximum() mit den Variablen a und b, in der zweiten Ereignisprozedur mit den Variablen c und d aufgerufen. Genauer gesagt werden der Prozedur ZeigeMaximum() nicht die Variablen selbst, sondern deren Werte übergeben. Dafür sorgt das Schlüsselwort ByVal, das uns schon häufig begegnet ist. Es steht für Übergabe der Argumente mit ihrem Wert (per Wert = By Value). Im Unterschied dazu gibt es auch eine Übergabe per Referenz (siehe hierzu Abschnitt 4.8.2).
- In beiden Fällen werden also zwei Zahlenwerte an x und y übergeben. Innerhalb der Prozedur wird mithilfe einer Verzweigung das Maximum dieser beiden Zahlen ermittelt und ausgegeben. Anschließend endet die Prozedur ZeigeMaximum(), und der Programmablauf kehrt zur aufrufenden Ereignisprozedur zurück.
- Die Variablen, mit denen eine Prozedur aufgerufen wird, müssen also nicht die gleichen Namen haben wie die Variablen, die zur Speicherung der übergebenen Werte bereitstehen. Prozeduren werden im Allgemeinen von beliebigen Stellen des Programms aus mit unterschiedlichen Argumenten wiederholt aufgerufen.
Anzahl, Reihenfolge und Datentyp
- Wichtig ist hierbei, dass Anzahl, Reihenfolge und Datentyp der Argumente übereinstimmen.
An dieser Stelle soll noch einmal das Thema Gültigkeitsbereich von Variablen verdeutlicht werden:
Lokal
- Die beiden lokalen Variablen a und b sind nur innerhalb der ersten Ereignisprozedur bekannt und gültig. Bezogen auf die zweite Ereignisprozedur trifft dies für die beiden lokalen Variablen c und d zu.
- Ebenso gilt dies für die beiden Parameter x und y, bezogen auf die allgemeine Prozedur ZeigeMaximum().
- Somit kann es nicht zu Verwechslungen kommen. Selbst wenn einzelne Variablennamen in mehr als einer Prozedur vorkommen, ist die Eindeutigkeit aufgrund des Gültigkeitsbereichs gegeben.
4.8.2 Übergabe per Referenz 

Sobald Sie in Visual Basic die Kopfzeile einer Prozedur (oder auch einer Funktion) abgeschlossen haben, wird automatisch das Schlüsselwort ByVal vor den einzelnen Argumenten in der Argumentenliste eingefügt. Dies gilt für die Basis-Datentypen und natürlich nur, sofern Sie nicht selbst eines der Schlüsselworte ByVal oder ByRef eingefügt haben.
Visual Basic geht also auf Nummer sicher: Es sorgt dafür, dass bei den Basis-Datentypen eine Veränderung der Argumente in der Prozedur (oder Funktion) keine Rückwirkung auf die Originalvariable hat.
ByRef
Wenn Sie allerdings wünschen, dass es solche Rückwirkungen gibt, dann müssen Sie vor der betreffenden Variablen das Schlüsselwort ByRef (statt ByVal) einfügen. Dies bedeutet, dass eine Referenz auf die Original-Variable an die Prozedur (oder Funktion) übergeben wird. Über diese Referenz kann die Original-Variable verändert werden.
Im nachfolgenden Programm im Projekt ReferenzÜbergabe werden beide Möglichkeiten einander gegenübergestellt, siehe Abbildungen 4.31 und 4.32.
Abbildung 4.31 Übergabe per Kopie
Abbildung 4.32 Übergabe per Referenz
Der Programmcode:
Public Class Form1 Private Sub cmdKopie_Click(...) Handles ... Dim x, y As Integer x = 5 y = 12 lblAnzeige.Text = "Vorher: x: " & x & ", y: " & y TauscheKopie(x, y) lblAnzeige.Text &= vbCrLf & "Nachher: x: " & x & ", y: " & y End Sub Private Sub cmdReferenz_Click(...) Handles ... Dim x, y As Integer x = 5 y = 12 lblAnzeige.Text = "Vorher: x: " & x & ", y: " & y TauscheReferenz(x, y) lblAnzeige.Text &= vbCrLf & "Nachher: x: " & x & ", y: " & y End Sub Sub TauscheKopie(ByVal a As Integer, ByVal b As Integer) Dim c As Integer c = a a = b b = c End Sub Sub TauscheReferenz(ByRef a As Integer, ByRef b As Integer) Dim c As Integer c = a a = b b = c End Sub End Class
Listing 4.24 Projekt »ReferenzÜbergabe«
Zur Erläuterung:
- In den beiden Ereignisprozeduren cmdKopie() und cmdReferenz() werden jeweils zwei Integer-Variablen mit Startwerten belegt. Anschließend wird jeweils eine Prozedur aufgerufen (TauscheKopie() bzw. TauscheReferenz()). Schließlich werden die Endwerte der beiden Variablen ausgegeben.
- In den beiden aufgerufenen Prozeduren werden jeweils die beiden übergebenen Variablen mithilfe einer dritten Variablen vertauscht (Ringtausch).
- Im Fall der Prozedur TauscheKopie() wurde ByVal verwendet. Die Endwerte stimmen mit den Startwerten überein, denn der Tausch hat nur intern in der Prozedur TauscheKopie() stattgefunden, er hat keine Wirkung nach außen.
- Im Kopf der Prozedur TauscheReferenz() wurde ByRef verwendet. Die Endwerte stimmen nicht mehr mit den Startwerten überein, der Tausch hat eine dauerhafte Auswirkung auf die beiden Original-Variablen.
4.8.3 Funktionen 

Funktionen haben folgenden (vereinfachten) Aufbau:
Function Funktionsname (Argumentliste) As Typ [ Anweisungsblock ] [ Exit Function ] [ Anweisungsblock ] End Function
As
Jede Funktion besitzt wie eine Variable einen bestimmten Datentyp, der hinter As angegeben wird. Funktionen werden im Allgemeinen dazu verwendet, einen Wert zu berechnen. Sie liefern diesen Rückgabewert in ihrem Namen zurück, nachdem er ihnen innerhalb der Prozedur zugewiesen wurde.
Exit Function
Die Anweisung Exit Function kann eingesetzt werden, um die Funktion aufgrund einer speziellen Bedingung sofort und nicht erst am Ende zu verlassen.
Im nachfolgenden Beispiel wird die Funktion MaxWert() aufgerufen. Sie berechnet das Maximum der beiden übergebenen Argumente und gibt dieses an die aufrufende Stelle (Projekt Funktionen) zurück, siehe Abbildung 4.33.
Abbildung 4.33 Darstellung des Rückgabewerts
Der zugehörige Code:
Public Class Form1 Private Sub cmdAnzeigen_Click(...) Handles ... Dim a, b, c As Integer a = 12 b = 17 c = MaxWert(a, b) lblAnzeige.Text = "Maximum: " & c End Sub Function MaxWert(ByVal x As Integer, ByVal y As Integer) As Integer If x > y Then MaxWert = x Else MaxWert = y End If End Function End Class
Listing 4.25 Projekt »Funktionen«
Zur Erläuterung:
Durch die Anweisung c = MaxWert(a, b) passiert nacheinander Folgendes:
- Die Funktion MaxWert() wird aufgerufen, dabei werden zwei Zahlenwerte an die Funktion übergeben.
Rückgabewert
- Innerhalb der Funktion wird mithilfe einer Verzweigung das Maximum dieser beiden Zahlen ermittelt und als Rückgabewert der Funktion gespeichert. Die Funktion endet und der Programmablauf kehrt zu der Zeile mit dem Aufruf zurück.
- Dort wird der ermittelte Wert über die Zuweisung der Variablen c übergeben. Diese Variable wird anschließend ausgegeben.
- Hätte die Anweisung nur MaxWert(a, b)gelautet, so hätten alle diese Schritte stattgefunden, außer der Übergabe an c. Der Funktionsaufruf wäre in diesem Fall vergeblich gewesen – ein häufiger Fehler bei Programmier-Einsteigern.
- Bezüglich der Übergabe (ByVal oder ByRef) und auch bezüglich der Inhalte der nachfolgenden Abschnitte unterscheiden sich Prozedur und Funktion nicht.
- Die Methode MaxWert() hat den Datentyp Integer, es muss also eine Integer-Variable zurückgeliefert werden.
- Hinweis: Sie sollten darauf achten, dass eine Funktion in jedem Fall einen Wert zurückliefert (siehe auch Abschnitt 4.8.5). Dies ist besonders bei Durchlauf unterschiedlicher Codepfade (Ausführungswege), zum Beispiel aufgrund von Verzweigungen oder Ausnahmebehandlungen, zu beachten.
4.8.4 Optionale Argumente 

Optional
Normalerweise muss die Zahl der Argumente in Aufruf und Deklaration einer Prozedur (oder Funktion) übereinstimmen. Sie können allerdings auch optionale Argumente verwenden. Diese müssen beim Aufruf nicht angegeben werden. Sie werden in der Argumentliste durch das Schlüsselwort Optional gekennzeichnet, müssen immer am Ende der Argumentenliste stehen und mit einem Wert initialisiert werden. Sinnvoll ist der Einsatz von optionalen Argumenten, falls eine Methode viele häufig vorkommende Standardwerte hat.
Im nachfolgenden Beispiel wird die Funktion Addiere() insgesamt dreimal aufgerufen, einmal mit zwei Argumenten, einmal mit drei Argumenten und einmal mit vier Argumenten. Sie berechnet jeweils die Summe der übergebenen Argumente und liefert diese zurück (Projekt OptionaleArgumente).
Public Class Form1 Private Sub cmdAnzeigen1_Click(...) Handles ... Dim a As Double = 4.5, b As Double = 7.2, c As Double = 10.3, d As Double = 9.2 lblAnzeige.Text = Addiere(a, b, c, d) End Sub Private Sub cmdAnzeigen2_Click(...) Handles ... Dim a As Double = 4.5, b As Double = 7.2, c As Double = 10.3 lblAnzeige.Text = Addiere(a, b, c) End Sub Private Sub cmdAnzeigen3_Click(...) Handles ... Dim a As Double = 4.5, b As Double = 7.2 lblAnzeige.Text = Addiere(a, b) End Sub Function Addiere(ByVal x As Double, ByVal y As Double, Optional ByVal z As Double = 0, Optional ByVal q As Double = 0 ) As Double Addiere = x + y + z + q End Function End Class
Listing 4.26 Projekt »OptionaleArgumente«
Zur Erläuterung:
- Die Funktion Addiere() erwartet insgesamt vier Parameter vom Datentyp Double. Die beiden letzten Parameter sind optional und werden mit dem Wert 0 initialisiert.
- Werden also die beiden letzten Parameter bei einem Aufruf der Funktion nicht angegeben, so haben sie den Wert 0. Da innerhalb der Funktion eine Addition der vier Parameter stattfindet, ist dies der geeignete Wert; das Ergebnis der Funktion wird nicht verfälscht.
- Bei Prozeduren oder Funktionen mit optionalen Argumenten, die andere Aufgaben zu erfüllen haben, können andere Werte zur Initialisierung sinnvoll sein.
- In den drei Ereignisprozeduren wird die Funktion Addiere() mit vier, drei oder zwei Parametern aufgerufen. In allen Fällen führt dies erfolgreich zur Addition und Ausgabe der Werte.
- Ein Aufruf mit nur einem Parameter hätte zu einer Fehlermeldung geführt, da der Parameter y nicht optional ist.
- Der Anweisungsteil Optional ByVal z As Double = 0 vereinbart z als optionales Argument vom Datentyp Double und initialisiert ihn mit 0. Alle anderen Variablen können ebenfalls bei ihrer Deklaration mit einem Wert initialisiert werden. Dies wurde in den verschiedenen Ereignisprozeduren vorgenommen.
4.8.5 Beliebig viele Argumente 

ParamArray
Mithilfe des Schlüsselwortes ParamArray können Sie eine Prozedur formulieren, an die beliebig viele Parameter übergeben werden können. ParamArray verträgt sich nicht mit Optional, Sie müssen sich also für eine der beiden Lösungen entscheiden.
Im nachfolgenden Beispiel wird die Funktion Mittelwert () insgesamt dreimal aufgerufen, einmal ohne Argument, einmal mit zwei Argumenten und einmal mit vier Argumenten. Sie berechnet jeweils den Mittelwert der übergebenen Argumente und liefert diesen zurück (Projekt BeliebigVieleArgumente).
Public Class Form1 Private Sub cmdAnzeigen1_Click(...) Handles ... lblAnzeige.Text = Mittelwert() End Sub Private Sub cmdAnzeigen2_Click(...) Handles ... Dim a As Double = 4.5, b As Double = 7.2 lblAnzeige.Text = Mittelwert(a, b) End Sub Private Sub cmdAnzeigen3_Click(...) Handles ... Dim a As Double = 4.5, b As Double = 7.2, c As Double = 10.3, d As Double = 9.2 lblAnzeige.Text = Mittelwert(a, b, c, d) End Sub Function Mittelwert( ByVal ParamArray x() As Double) As Double Dim i As Integer Dim Summe As Double = 0 Dim Anzahl As Double For i = 0 To x.GetUpperBound(0) Summe += x(i) Next Anzahl = x.GetUpperBound(0) + 1 If Anzahl > 0 Then Mittelwert = Summe / Anzahl Else Mittelwert = 0 End If End Function End Class
Listing 4.27 Projekt »BeliebigVieleArgumente«
Zur Erläuterung:
- Die Funktion Mittelwert() wird mit unterschiedlichen Anzahlen von Parametern aufgerufen (0, 2 und 4).
- Zur Aufnahme der Parameter steht der Parameter-Array x zur Verfügung. Dabei handelt es sich um ein Feld, dessen Größe nicht festgelegt ist.
- Innerhalb der Funktion werden die Parameter mithilfe einer Schleife summiert. Die Obergrenze für die Schleife wird über die Methode GetUpperBound() ermittelt, da jeweils zunächst festgestellt werden muss, wie viele Elemente der Parameter-Array hat.
- Der Mittelwert einer Reihe von Zahlen ist bekanntlich die Summe der Zahlen geteilt durch ihre Anzahl. Wird die Funktion ohne Parameter aufgerufen, so ergibt GetUpperBound() den Wert –1. Es würde dann eine Division durch 0 durchgeführt werden. Dies gilt es zu vermeiden.
- Konnte innerhalb einer Funktion kein Wert für die Funktion ermittelt werden, so gilt wie bei Variablen auch hier der Startwert 0. Im Sinne eines sauberen Programmierstils sollten Sie dies ebenfalls vermeiden. Eine Funktion sollte während ihres Verlaufs immer explizit einen Wert erhalten.
- Die Entwicklungsumgebung macht auch darauf aufmerksam: Falls Sie den Else-Zweig weglassen würden, dann würde die Warnung angezeigt werden, dass nicht in jedem Codepfad ein Rückgabewert für die Funktion ermittelt wird.
4.8.6 Datenfelder als Argumente 

Datenfelder können auch an Prozeduren oder Funktionen in der Argumentenliste übergeben werden. Beachten Sie hierbei einige Besonderheiten:
Per Referenz
- Der Name eines Felds stellt lediglich eine Referenz auf das Feld dar. Daher haben Veränderungen von Elementen eines Felds in einer Prozedur immer Rückwirkungen auf das Originalfeld, selbst wenn das Feld mit ByVal übergeben wird.
- Bei einem Feld in der Argumentenliste muss keine Dimensionsgröße angegeben werden, ähnlich wie bei ParamArray. Dadurch ist eine Funktion flexibler und kann unterschiedliche Felder verarbeiten.
- Allerdings müssen Sie die Anzahl der Dimensionen kennzeichnen. Sie können also kein eindimensionales Feld an ein zweidimensionales Feld übergeben.
Das nachfolgende Programm (Projekt DatenfeldAlsArgument) veranschaulicht eine solche Übergabe. Es wird eine Funktion Verdoppeln() aufgerufen, die alle Elemente des Originalfelds verdoppelt, siehe Abbildung 4.34.
Abbildung 4.34 Feld an Prozedur übergeben
Der zugehörige Code:
Public Class Form1 Private Sub cmdAnzeige_Click(...) Handles ... Dim x(4, 2) As Integer Dim i, k As Integer For i = 0 To 4 For k = 0 To 2 x(i, k) = (i + 1) * (k + 1) lblAnzeige.Text &= x(i, k) & " " Next k lblAnzeige.Text &= vbCrLf Next i lblAnzeige.Text &= vbCrLf Verdoppeln(x) For i = 0 To 4 For k = 0 To 2 lblAnzeige.Text &= x(i, k) & " " Next k lblAnzeige.Text &= vbCrLf Next i End Sub Sub Verdoppeln(ByVal z(,) As Integer) For i = 0 To z.GetUpperBound(0) For k = 0 To z.GetUpperBound(1) z(i, k) = z(i, k) * 2 Next k Next i End Sub End Class
Listing 4.28 Projekt »DatenfeldAlsArgument«
Zur Erläuterung:
- In der Ereignisprozedur wird ein Feld mit 5 x 3 Elementen mit Zahlen gefüllt. Es wird dann zweimal vollständig angezeigt, einmal vor dem Aufruf der Prozedur Verdoppeln(), einmal danach. Sie sehen, dass alle Elemente verdoppelt wurden.
- Im Kopf der Prozedur Verdoppeln() wird mit z(,) angezeigt, dass diese Prozedur ein zweidimensionales Feld erwartet, ohne Festlegung auf die Größe der beiden Dimensionen.
- Die Prozedur könnte also mit einem Feld der Größe 5 × 3 Elemente, aber auch mit einem Feld der Größe 1000 × 1000 Elemente aufgerufen werden.
- Innerhalb der Prozedur wird eine geschachtelte Schleife durchlaufen. Die Methode GetUpperBound() wird dabei eingesetzt, um die unterschiedlichen Obergrenzen (aufgrund der unterschiedlichen Dimensionsgrößen) für den Index der inneren bzw. äußeren Schleife zu ermitteln.
4.8.7 Rekursiver Aufruf 

Funktionen und Prozeduren können jederzeit andere Funktionen oder Prozeduren aufrufen. Man spricht hier von geschachtelten Aufrufen. Das Programm kehrt jeweils – aus einer beliebigen Schachtelungstiefe – zur aufrufenden Stelle zurück.
Rekursion
Funktionen und Prozeduren können sich auch selbst aufrufen. Dieser Vorgang wird als Rekursion bezeichnet. Eine rekursive Funktion muss eine Verzweigung beinhalten, die die Rekursion wieder beendet, da es sonst zu einer endlosen Kette von Selbst-Aufrufen kommt, ähnlich wie bei einer endlosen Ereigniskette (siehe Abschnitt 4.3.2). Bestimmte Problemstellungen können Sie programmiertechnisch am elegantesten durch eine Rekursion lösen.
Im nachfolgenden Programm (Projekt RekursiverAufruf) wird eine Zahl so lange halbiert, bis ein bestimmter Grenzwert erreicht oder unterschritten wird. Zur Verdeutlichung der unterschiedlichen Abläufe wird der Halbierungsvorgang einmal mithilfe einer Schleife, einmal mithilfe einer Rekursion durchgeführt.
Der Programmcode:
Public Class Form1 Private Sub cmdSchleife_Click(...) Handles ... Dim x As Double x = 22 lblAnzeige.Text = "x: " & x & vbCrLf Do x = x / 2 lblAnzeige.Text &= "x: " & x & vbCrLf Loop While x > 0.1 End Sub Private Sub cmdRekursion_Click(...) Handles ... Dim x As Double x = 22 lblAnzeige.Text = "x: " & x & vbCrLf Halbieren(x) lblAnzeige.Text &= "x: " & x & vbCrLf End Sub Sub Halbieren(ByRef z As Double) z = z / 2 If z > 0.1 Then lblAnzeige.Text &= "z: " & z & vbCrLf Halbieren(z) End If End Sub End Class
Listing 4.29 Projekt »RekursiverAufruf«
Zur Erläuterung der Schleife:
- In der Ereignisprozedur cmdSchleife_Click() wird die Variable x mit 22 initialisiert. Anschließend wird sie in einer Do ... Loop While Schleife so lange halbiert, bis sie den Wert 0,1 erreicht oder unterschritten hat. Bei jedem Durchlauf der Schleife wird der aktuelle Wert angezeigt, sodass man die fortlaufende Halbierung verfolgen kann, siehe Abbildung 4.35.
Abbildung 4.35 Halbierung per Schleife
Zur Erläuterung der Rekursion:
- In der Ereignisprozedur cmdRekursion_Click() wird die Variable x ebenfalls mit 22 initialisiert. Anschließend wird allerdings die Prozedur Halbieren() aufgerufen. Diese führt eine Halbierung durch.
- Anschließend wird geprüft, ob der Grenzwert erreicht oder unterschritten wurde.
- Ist dies der Fall, endet die Prozedur Halbieren() und das Programm endet mit der letzten Anweisung in der Ereignisprozedur cmdRekursion_Click().
- Ist der Grenzwert noch nicht erreicht, so ruft die Prozedur Halbieren() sich selbst wieder auf. Dieser Vorgang kann sich mehrmals wiederholen.
- Sobald der Grenzwert erreicht oder unterschritten wird, wird die Prozedur Halbieren() beendet, ggf. mehrmals nacheinander, und das Programm endet mit der letzten Anweisung in der Ereignisprozedur cmdRekursion_Click().
- Hätte sich der rekursive Aufruf nicht innerhalb einer Verzweigung befunden, so hätte sich die Prozedur endlos aufgerufen.
- Die Variable x (in der Prozedur heißt sie z) wurde jeweils per Referenz übergeben, daher wurde immer die Originalvariable x halbiert. Dies kann man auch an Ausgabe in Abbildung 4.36 erkennen.
Abbildung 4.36 Halbierung per Rekursion
4.8.8 Übungen zu Prozeduren und Funktionen 

Übung ÜProzeduren
Übung ÜProzeduren
Schreiben Sie ein Programm, in der zwei Double-Variablen beliebige Werte zugewiesen werden. Anschließend soll eine Prozedur aufgerufen werden, der diese beiden Variablen übergeben werden. Innerhalb der Prozedur wird der Mittelwert der beiden Zahlen berechnet und ausgegeben.
Übung ÜFunktionen
Übung ÜFunktionen
Schreiben Sie ein Programm, in der zwei Double-Variablen beliebige Werte zugewiesen werden. Anschließend soll eine Funktion aufgerufen werden, in der der Mittelwert der beiden Zahlen berechnet und zurückgeliefert wird. Die Ausgabe soll in der aufrufenden Prozedur erfolgen.