Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
1 Einführung
2 Grundlagen
3 Fehlerbehandlung
4 Erweiterte Grundlagen
5 Objektorientierte Programmierung
6 Wichtige Klassen in .NET
7 Weitere Elemente eines Windows-Programms
8 Datenbank-Anwendungen mit ADO.NET
9 Internet-Anwendungen mit ASP.NET
10 Zeichnen mit GDI+
11 Neues in Visual Basic 2008
12 Beispielprojekte
A Installation
B Lösungen der Übungsaufgaben
Stichwort

Download:
- ZIP, ca. 8,4 MB
Buch bestellen
Ihre Meinung?

Spacer
 <<   zurück
Einstieg in Visual Basic 2008 von Thomas Theis
Inkl. zahlreicher Beispiele und Uebungen
Buch: Einstieg in Visual Basic 2008

Einstieg in Visual Basic 2008
geb., mit DVD
442 S., 24,90 Euro
Galileo Computing
ISBN 978-3-8362-1192-5
Online bestellenJetzt online bestellen
* versandkostenfrei in (D) und (A)
Pfeil 4 Erweiterte Grundlagen
  Pfeil 4.1 Fokus, Sichtbarkeit, Aktivierungszustand
    Pfeil 4.1.1 Ereignis GotFocus
    Pfeil 4.1.2 Eigenschaften Enabled und Visible
  Pfeil 4.2 Bedienung per Tastatur
    Pfeil 4.2.1 Eigenschaften TabIndex und TabStop
    Pfeil 4.2.2 Tastenkombination für Steuerelemente
  Pfeil 4.3 Ereignisgesteuerte Programmierung
    Pfeil 4.3.1 Eine EreigniskeEreigniskettette
    Pfeil 4.3.2 Endlose Ereignisketten
    Pfeil 4.3.3 Textfelder koppeln
  Pfeil 4.4 Datenfelder
    Pfeil 4.4.1 Eindimensionale statische Datenfelder
    Pfeil 4.4.2 Ein Feld durchsuchen
    Pfeil 4.4.3 Weitere Feld-Operationen
    Pfeil 4.4.4 Mehrdimensionale statische Datenfelder
    Pfeil 4.4.5 Datenfelder initialisieren
    Pfeil 4.4.6 Datenfelder sind dynamisch
  Pfeil 4.5 Strukturen
  Pfeil 4.6 Prozeduren und Funktionen
    Pfeil 4.6.1 Prozeduren
    Pfeil 4.6.2 Übergabe per Referenz
    Pfeil 4.6.3 Funktionen
    Pfeil 4.6.4 Optionale Argumente
    Pfeil 4.6.5 Beliebig viele Argumente
    Pfeil 4.6.6 Datenfelder als Argumente
    Pfeil 4.6.7 Rekursiver Aufruf
    Pfeil 4.6.8 Übungen zu Prozeduren und Funktionen


Galileo Computing - Zum Seitenanfang

4.6 Prozeduren und Funktionen  Zur nächsten ÜberschriftZur vorigen Überschrift

In Visual Basic hat der 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.


Galileo Computing - Zum Seitenanfang

4.6.1 Prozeduren  Zur nächsten ÜberschriftZur vorigen Überschrift

In einer Prozedur sind Anweisungen zusammengefasst, die als logische Einheit zusammen ausgeführt werden sollen. Durch eine klare Aufgabenteilung dieser Prozeduren wird der Programmcode eines Moduls ü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 (p0417).

Public Class frm0417 
   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

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.6.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.

Galileo Computing - Zum Seitenanfang

4.6.2 Übergabe per Referenz  Zur nächsten ÜberschriftZur vorigen Überschrift

Sobald man in Visual Basic die Kopfzeile einer Prozedur (oder auch einer Funktion) abgeschlossen hat, 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 man nicht selbst eines der Schlüsselworte ByVal oder ByRef eingefügt hat.

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 Original-Variable hat.

ByRef

Wenn man allerdings wünscht, dass es solche Rückwirkungen gibt, dann muss man 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 werden beide Möglichkeiten einander gegenübergestellt.

Public Class frm0418 
   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

Abbildung 4.22  Nach Übergabe ByVal und Tausch

Abbildung 4.23  Nach Übergabe ByRef und Tausch

Zur Erläuterung:

  • In den beiden Ereignisprozeduren cmdKopie() und cmdReferenz() werden jeweils zwei Integer-Variablen mit Startwerten belegt. Anschließend wird 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 jedoch mit den Startwerten überein, denn der Tausch hat nur intern in der Prozedur TauscheKopie() stattgefunden, er hat keine Wirkung nach außen.
  • In 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.

Galileo Computing - Zum Seitenanfang

4.6.3 Funktionen  Zur nächsten ÜberschriftZur vorigen Überschrift

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 (p0419) zurück.

Abbildung 4.24  Funktion

Public Class frm0419 
   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

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 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.

Galileo Computing - Zum Seitenanfang

4.6.4 Optionale Argumente  Zur nächsten ÜberschriftZur vorigen Überschrift

Optional

Normalerweise müssen Zahl und Reihenfolge der Argumente in Aufruf und Deklaration einer Prozedur (oder Funktion) übereinstimmen. Man kann 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.

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 (p0420).

Public Class frm0420 
   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

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.

Galileo Computing - Zum Seitenanfang

4.6.5 Beliebig viele Argumente  Zur nächsten ÜberschriftZur vorigen Überschrift

ParamArray

Mithilfe des Schlüsselwortes ParamArray kann man eine Prozedur formulieren, an die beliebig viele Parameter übergeben werden können. ParamArray verträgt sich nicht mit Optional, man muss 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 (p0421).

Public Class frm0421 
   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 
      End If 
   End Function 
End Class

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 sollte dies ebenfalls vermieden werden. Eine Funktion sollte während ihres Verlaufs immer explizit einen Wert erhalten.

Galileo Computing - Zum Seitenanfang

4.6.6 Datenfelder als Argumente  Zur nächsten ÜberschriftZur vorigen Überschrift

Datenfelder können auch an Prozeduren oder Funktionen in der Argumentenliste übergeben werden. Hierbei sind einige Besonderheiten zu beachten:

    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 muss die Anzahl der Dimensionen gekennzeichnet werden. Es kann also kein eindimensionales Feld an ein zweidimensionales Feld übergeben werden.

Das nachfolgende Programm (p0422) veranschaulicht eine solche Übergabe. Es wird eine Funktion Verdoppeln() aufgerufen, die alle Elemente des Originalfelds verdoppelt.

Public Class frm0422 
   Private Sub cmdAnzeigen_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) 
            lblAnzeige1.Text &= x(i, k) & " " 
         Next 
         lblAnzeige1.Text &= vbCrLf 
 
      Next 
      lblAnzeige1.Text &= vbCrLf 
 
      Verdoppeln(x) 
 
      For i = 0 To 4 
         For k = 0 To 2 
            lblAnzeige1.Text &= x(i, k) & " " 
         Next 
         lblAnzeige1.Text &= vbCrLf 
      Next 
   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 
      Next 
   End Sub 
End Class

Abbildung 4.25  Feld an Prozedur übergeben

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. Man sieht, 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. den Index der äußeren Schleife zu ermitteln.

Galileo Computing - Zum Seitenanfang

4.6.7 Rekursiver Aufruf  Zur nächsten ÜberschriftZur vorigen Überschrift

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.1). Bestimmte Problemstellungen lassen sich programmiertechnisch am elegantesten durch eine Rekursion lösen.

Im nachfolgenden Programm (p0423) 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.

Public Class frm0423 
   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

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 mitverfolgen kann.

    Abbildung 4.26  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 Funktion 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 Original-Variable x halbiert. Dies kann man auch an der letzten Ausgabe erkennen.

Abbildung 4.27  Halbierung per Rekursion


Galileo Computing - Zum Seitenanfang

4.6.8 Übungen zu Prozeduren und Funktionen  topZur vorigen Überschrift

Übung p0425:

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

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.



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






 <<   zurück
  Zum Katalog
Zum Katalog: Einstieg in Visual Basic 2008






Einstieg in Visual Basic 2008
bestellen
 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Visual Basic 2008






 Visual Basic 2008


Zum Katalog: Einstieg in Visual C++ 2008






 Einstieg in
 Visual C++ 2008


Zum Katalog: Einstieg in Visual C# 2008






 Einstieg in
 Visual C# 2008


Zum Katalog: Visual C# 2008






 Visual C# 2008


Zum Katalog: Visual C# - Video-Training






 Visual C# -
 Video-Training


Zum Katalog: Einstieg in PHP 5 und MySQL 5






 Einstieg in PHP 5
 und MySQL 5


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo





Copyright © Galileo Press 2008
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de