{"id":55000207,"date":"2014-02-01T00:00:00","date_gmt":"2020-01-24T15:58:55","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=207"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Rekursion_mit_VBA","status":"publish","type":"post","link":"https:\/\/access-basics.de\/index.php\/Rekursion_mit_VBA.html","title":{"rendered":"Rekursion mit VBA"},"content":{"rendered":"

Manche Abläufe erfordern den Einsatz von Schleifen mit einer bestimmten Anzahl von Durchläufen oder einer vordefinierten Abbruchbedingung. In speziellen Fällen reichen Schleifen jedoch nicht aus, um zum Ziel zu kommen: Dann müssen rekursiv definierte Funktionen her. Dies sind solche Funktionen, die sich selbst aufrufen. Der vorliegende Artikel erklärt, wie solche Funktionen arbeiten und liefert einige Beispiele.<\/p>\n

Beispieldatenbank<\/h2>\n

Die Beispiele dieses Artikels finden Sie in der Datenbank 1307_RekursionMitVBA.mdb<\/b>.<\/p>\n

Beispiel Fakultät<\/h2>\n

Bei der rekursiven Programmierung ruft sich eine Funktion selbst auf. Für einen einfachen Einstieg nehmen wir ein Beispiel, dass vielerorts zum Einsatz kommt: Die Berechnung der Fakultät einer Zahl. Die Fakultät einer Zahl n <\/b>wird so definiert:<\/p>\n

n! = n x (n-1) x ... x 2 x 1<\/pre>\n
Das bedeutet, dass man alle ganzen Zahlen miteinander multipliziert, die kleiner oder gleich der Zahl n sind. Ein Sonderfall ist die Fakultät von 0 <\/b>– hierfür ist nämlich der Wert 1 <\/b>definiert.<\/p>\n
Um den Schritt zur Rekursion zu machen, definieren wir die Fakultät etwas anders:<\/p>\n
n! = n x (n-1)!<\/pre>\n
Die Fakultät ist hier als das Produkt der Zahl selbst mit der Fakultät der nächstkleineren Zahl definiert. Und diese Fakultät entspricht natürlich wiederum die Zahl multipliziert mit der Fakultät der nächstkleineren Zahl. Es gibt hier auch eine Ausnahme: Wenn n <\/b>den Wert 1 <\/b>annimmt, ist die Fakultät von n <\/b>gleich 1<\/b>.<\/p>\n
Fakultät per VBA<\/h2>\n
Wenn wir die Fakultät mit einer Funktion berechnen möchten, die sich selbst aufruft, müssen wir dieser zunächst einmal die Zahl übergeben, für welche die Fakultät berechnet werden soll. Der Funktionskopf sieht also beispielsweise so aus:<\/p>\n
Public Function <\/span>Fakultaet(lngZahl                        As Long<\/span>) As Long<\/span><\/pre>\n
Beim ersten Aufruf soll die Funktion die Fakultät für die Zahl lngZahl <\/b>ermitteln. Diese entspricht aber wiederum dem Produkt der Zahl und der Fakultät der Zahl minus Eins.<\/p>\n
Innerhalb der Funktion rufen wir die Funktion also erneut auf – mit der um  Eins verminderten Zahl. Das Ergebnis multiplizieren wir dann mit der Zahl selbst.<\/p>\n
Die Anweisung sieht also so aus:<\/p>\n
Fakultaet = lngZahl * Fakultaet(lngZahl - 1)<\/pre>\n
Insgesamt erhielten wir nun eine Funktion wie die Folgende:<\/p>\n
Public Function <\/span>Fakultaet(lngZahl                        As Long<\/span>) As Long<\/span>\r\n     Fakultaet = lngZahl *                  Fakultaet(lngZahl - 1)\r\nEnd Function<\/span><\/pre>\n
Wenn Sie die Funktion nun etwa aus dem Direktfenster mit dem Befehl Debug.Print Fakultaet(4) <\/b>aufrufen, sollte das Ergebnis eigentlich 24 lauten (1 x 2 x 3 x 4<\/b>). Allerdings zeigt Access nach kurzer Zeit eine Fehlermeldung an, die wie in Bild 1 aussieht. Was ist hier passiert Ganz einfach: Wir haben der Funktion nicht mitgeteilt, wann sie anhalten soll. In diesem Fall berechnet sie nacheinander die Fakultät für 4<\/b>, 3<\/b>, 2<\/b>, 1<\/b>, 0<\/b>, -1<\/b>, -2<\/b> und so weiter. <\/p>\n
\"Fehler<\/a><\/p>\n
Bild 1: Fehler bei rekursiver Funktion ohne Abbruchbedingung<\/p>\n
Der Fehler wird schließlich dadurch ausgelöst, dass die Funktion die Zwischenergebnisse jeweils im Arbeitsspeicher unterbringen muss – und mit wachsender Anzahl Aufrufe ist der Speicher irgendwann einmal voll. <\/p>\n
Also bauen wir die Funktion wie in Listing 1 auf. Die Funktion prüft bei jedem Aufruf zunächst, ob der Wert der mit lngZahl <\/b>gelieferten Zahl gleich Eins ist. Ist dies der Fall, ist auch die Fakultät Eins – die Funktion braucht also kein weiteres Mal aufgerufen zu werden. Der Ablauf zur Berechnung der Fakultät von 4 sieht also so aus:<\/p>\n
Public Function <\/span>Fakultaet(lngZahl As Long<\/span>) As Double<\/span>\r\n     If <\/span>lngZahl = 1 Then<\/span>\r\n         Fakultaet = 1\r\n     Else<\/span>\r\n         Fakultaet = lngZahl * Fakultaet(lngZahl - 1)\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 1: Rekursive Berechnung der Fakultät einer Zahl<\/p>\n