Rheinwerk Computing < openbook > Rheinwerk 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 Beispielprojekte
12 Windows Presentation Foundation
13 Windows Store-Apps für Windows 8
A Installation und technische Hinweise
B Lösungen der Übungsaufgaben
C Inhalt der Buch-DVD
D Der Autor
Stichwort

Jetzt Buch bestellen
Ihre Meinung?

Spacer
Einstieg in Visual Basic 2012 von Thomas Theis
Ideal für Programmiereinsteiger geeignet
Buch: Einstieg in Visual Basic 2012

Einstieg in Visual Basic 2012
Rheinwerk Computing
579 S., 3., aktualisierte und erweiterte Auflage 2013, brosch., mit DVD
24,90 Euro, ISBN 978-3-8362-1959-4
Pfeil 4 Erweiterte Grundlagen
Pfeil 4.1 Steuerelemente aktivieren
Pfeil 4.1.1 Ereignis Enter
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 Ereigniskette
Pfeil 4.3.2 Endlose Ereignisketten
Pfeil 4.3.3 Textfelder koppeln
Pfeil 4.4 Mehrere Formulare
Pfeil 4.4.1 Allgemeine Code-Module
Pfeil 4.5 Datenfelder
Pfeil 4.5.1 Eindimensionale Datenfelder
Pfeil 4.5.2 Ein Feld durchsuchen
Pfeil 4.5.3 Weitere Feld-Operationen
Pfeil 4.5.4 Mehrdimensionale Datenfelder
Pfeil 4.5.5 Datenfelder initialisieren
Pfeil 4.5.6 Datenfelder sind dynamisch
Pfeil 4.5.7 Collections initialisieren
Pfeil 4.5.8 For-Each-Schleife
Pfeil 4.6 Datenstruktur ArrayList
Pfeil 4.7 Benutzerdefinierte Datentypen
Pfeil 4.8 Prozeduren und Funktionen
Pfeil 4.8.1 Prozeduren
Pfeil 4.8.2 Übergabe per Referenz
Pfeil 4.8.3 Funktionen
Pfeil 4.8.4 Optionale Argumente
Pfeil 4.8.5 Beliebig viele Argumente
Pfeil 4.8.6 Datenfelder als Argumente
Pfeil 4.8.7 Rekursiver Aufruf
Pfeil 4.8.8 Übungen zu Prozeduren und Funktionen
Pfeil 4.9 Konsolenanwendung
Pfeil 4.9.1 Anwendung erzeugen
Pfeil 4.9.2 Ein- und Ausgabe von Text
Pfeil 4.9.3 Eingabe einer Zahl
Pfeil 4.9.4 Erfolgreiche Eingabe einer Zahl
Pfeil 4.9.5 Ausgabe formatieren
Pfeil 4.9.6 Aufruf von der Kommandozeile

Rheinwerk Computing - Zum Seitenanfang

4.8 Prozeduren und FunktionenZur nächsten Überschrift

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

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.


Rheinwerk Computing - Zum Seitenanfang

4.8.1 ProzedurenZur nächsten ÜberschriftZur vorigen Überschrift

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 Prozeduren sind nicht mit Ereignissen verbunden und haben folgenden (vereinfachten) Aufbau:

Sub Prozedurname (Argumentliste)
[ Anweisungsblock ]
[ Exit Sub ]
[ Anweisungsblock ]
End Sub

Besteht die Argumentliste aus mehreren Argumenten, so werden diese durch Kommata voneinander getrennt.

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)

Hinweis: Statt des Begriffs Argument (bzw. Argumentliste) 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(x As Double, 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.
  • 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. Dies nennt man auch Übergabe per Wert (engl.: 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.
  • 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:

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

Rheinwerk Computing - Zum Seitenanfang

4.8.2 Übergabe per ReferenzZur nächsten ÜberschriftZur vorigen Überschrift

Visual Basic geht auf Nummer sicher: Argumente werden standardmäßig per Wert übergeben. Dadurch wird dafür gesorgt, dass bei den Basis-Datentypen eine Veränderung der Argumente in der Prozedur (oder Funktion) keine Rückwirkung auf die Originalvariable hat.

Wenn Sie allerdings wünschen, dass es solche Rückwirkungen gibt, dann müssen Sie vor der betreffenden Variablen das Schlüsselwort ByRef 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

Abbildung 4.31 Übergabe per Kopie

Abbildung

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(a As Integer, 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() wurden die Argumente per Wert übergeben. Man hätte auch das Schlüsselwort ByVal vor die Variablennamen setzen können. Dies ist aber der Standard, daher kann man es weglassen. 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.

Rheinwerk Computing - Zum Seitenanfang

4.8.3 FunktionenZur nächsten ÜberschriftZur vorigen Überschrift

Funktionen haben folgenden (vereinfachten) Aufbau:

Function Funktionsname (Argumentliste) As Typ
[ Anweisungsblock ]
[ Exit Function ]
[ Anweisungsblock ]
[ Return ... ]
End Function

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 Wert, den sogenannten Rückgabewert, entweder in ihrem Namen zurück, nachdem er ihnen innerhalb der Prozedur zugewiesen wurde, oder mithilfe des Schlüsselworts Return.

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 werden die beiden Funktionen MaxWert1() und MaxWert2() aufgerufen. Sie berechnen jeweils das Maximum der beiden übergebenen Argumente und geben dieses an die aufrufende Stelle (Projekt Funktionen) zurück, siehe Abbildung 4.33.

Abbildung

Abbildung 4.33 Darstellung des Rückgabewerts

Der zugehörige Code:

Public Class Form1
Private Sub cmdAnzeigen_Click(...) Handles ...
Dim a, b, c, d As Integer
a = 12
b = 17

c = MaxWert1(a, b)
lblAnzeige.Text = "Maximum 1: " & c

d = MaxWert2(a, b)
lblAnzeige.Text &= vbCrLf & "Maximum 2: " & d
End Sub

Function MaxWert1(x As Integer, y As Integer) As Integer
If x > y Then
MaxWert1 = x
Else
MaxWert1 = y
End If
End Function

Function MaxWert2(x As Integer, y As Integer)
If x > y Then
Return x
Else
Return y
End If
End Function
End Class

Listing 4.25 Projekt »Funktionen«

Zur Erläuterung:

Durch die Anweisung c = MaxWert1(a, b) passiert nacheinander Folgendes:

  • Die Funktion MaxWert1() wird aufgerufen, dabei werden zwei Zahlenwerte an die Funktion übergeben.
  • 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 MaxWert1(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 (per Wert oder per Referenz) und auch bezüglich der Inhalte der nachfolgenden Abschnitte unterscheiden sich Prozedur und Funktion nicht.
  • Die Methode MaxWert1() hat den Datentyp Integer, es muss also eine Integer-Variable zurückgeliefert werden.

In der Funktion MaxWert2() wird der Rückgabewert durch das Schlüsselwort Return zurückgeliefert. Die Funktion wird dann auch unmittelbar verlassen, und der Programmablauf kehrt zu der Zeile mit dem Aufruf zurück.

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.


Rheinwerk Computing - Zum Seitenanfang

4.8.4 Optionale ArgumenteZur nächsten ÜberschriftZur vorigen Überschrift

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 Argumentliste 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(x As Double, y As Double,
Optional z As Double = 0,
Optional 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 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.

Rheinwerk Computing - Zum Seitenanfang

4.8.5 Beliebig viele ArgumenteZur nächsten ÜberschriftZur vorigen Überschrift

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(ParamArray x() As Double) As Double Dim Summe As Double = 0

For Each zahl As Double In x
Summe += zahl
Next

If x.Count > 0 Then
Mittelwert = Summe / x.Count
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 For Each-Schleife summiert, in der alle Elemente des Arrays durchlaufen werden.
  • Der Mittelwert einer Reihe von Zahlen ist bekanntlich die Summe der Zahlen geteilt durch ihre Anzahl. Wird die Funktion ohne Parameter aufgerufen, so hat die Eigenschaft Count des Arrays, die für die Anzahl der Elemente steht, den Wert 0. 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 Code-Pfad ein Rückgabewert für die Funktion ermittelt wird.

Rheinwerk Computing - Zum Seitenanfang

4.8.6 Datenfelder als ArgumenteZur nächsten ÜberschriftZur vorigen Überschrift

Datenfelder können auch an Prozeduren oder Funktionen in der Argumentliste übergeben werden. Beachten Sie hierbei einige Besonderheiten:

  • 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.
  • Bei einem Feld in der Argumentliste 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

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

Rheinwerk Computing - Zum Seitenanfang

4.8.7 Rekursiver AufrufZur 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.

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

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

Abbildung 4.36 Halbierung per Rekursion


Rheinwerk Computing - Zum Seitenanfang

4.8.8 Übungen zu Prozeduren und FunktionenZur nächsten ÜberschriftZur vorigen Überschrift

Ü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

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.



Ihre Meinung

Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.

<< zurück
  Zum Rheinwerk-Shop
Zum Rheinwerk-Shop: Einstieg in Visual Basic 2012

Einstieg in Visual Basic 2012
Jetzt Buch bestellen


 Ihre Meinung?
Wie hat Ihnen das Openbook gefallen?
Ihre Meinung

 Buchempfehlungen
Zum Rheinwerk-Shop: Visual Basic 2012






 Visual Basic 2012


Zum Rheinwerk-Shop: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Rheinwerk-Shop: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Rheinwerk-Shop: Java ist auch eine Insel






 Java ist auch
 eine Insel


Zum Rheinwerk-Shop: Einstieg in Python






 Einstieg in Python


 Lieferung
Versandkostenfrei bestellen in Deutschland, Österreich und der Schweiz
InfoInfo





Copyright © Rheinwerk Verlag GmbH 2013
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.


Nutzungsbestimmungen | Datenschutz | Impressum

Rheinwerk Verlag GmbH, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, service@rheinwerk-verlag.de

Cookie-Einstellungen ändern