***************************************************************
*                                                             *
*      Abschluss Kap.5: die Uebergabetypen ByVal und          *
*                       ByRef, Subs mit Argumenten            *
*                                                             *
***************************************************************


Machen wir zunaechst noch die Implementation von Teil (1b) von 
week6.pdf: Wir kopieren den code von 

Sub TestInversionFormula_a()

aus week6(a).xlsm in ein 

Sub TestInversionFormula_b() 

und machen die entsprechenden Modifikationen:

-> do the actual coding. 




Die Uebergabetypen ByVal und ByRef (by value und by reference): 

Wenn man eine Variable, nennen wir sie x, in einem Sub, nennen 
wir es TestSub, an eine Funktion, nennen wir sie TestFunction,  
uebergibt, und in der Funktion wird dann mit dieser Variablen 
gerechnet und der Wert von x veraendert, dann wird typischer-
weise, das ist die default-Einstellung, die identisch ist mit 
dem Uebergabetyp ByRef, auch der Wert von x im TestSub mit 
veraendert. Wenn man das nicht moechte, muss man diese Variable 
x an TestFunction mit dem Uebergabetyp ByVal uebergeben:   


Sub TestSub()

Dim x as double
Dim y as double

x = 3
y = TestFunction(x)
Debug.Print x, y 
'das Ausfuehren von TestFunction hat den Wert von x geaendert

x = 3
y = TestFunction2(x)
Debug.Print x, y 
'das Ausfuehren von TestFunction2 hat den Wert von x nicht geaendert

x = 3
y = TestFunction3(x)
Debug.Print x, y 
'das Ausfuehren von TestFunction3 hat den Wert von x geaendert: 
'der Uebergabetyp ByRef ist die Default-Einstellung

End Sub


Function TestFunction(a As Double) As Double
  
  Dim result As Double
  result = a ^ 2
  a = a + 1
  TestFunction = result
  
End Function

Function TestFunction2(ByVal a As Double) As Double
  
  Dim result As Double
  result = a ^ 2
  a = a + 1
  TestFunction2 = result
  
End Function

Function TestFunction3(ByRef a As Double) As Double
  
  Dim result As Double
  result = a ^ 2
  a = a + 1
  TestFunction3 = result
  
End Function



Unterprogramme oder Subs mit Argumenten:

Haeufig moechte man innerhalb eines groesseren Programms 
gewisse Manipulationen an Vektoren und Matrizen in ein 
Unterprogramm auslagern, um den Code uebersichtlich zu 
halten. Dieses Unterprogramm soll selber keinen Wert 
zurueckgeben, sondern nur die Vektoren und Matrizen 
oder allgemeiner die arrays, die ByRef uebergeben werden 
(der Uebergabetyp ByVal ist fuer arrays gar nicht moeglich) 
entsprechend manipulieren. Das geht etwa mit folgender 
Syntax: 

Wir definieren das Unterprogramm, was in diesem Fall 
den Vektor x elementweise quadriert und in einen Vektor 
y schreibt:

Sub TestUnterSub(x() As Double, y() As Double)

  Dim nlower As Long, nupper As Long, n As Long
  nlower = LBound(x)
  nupper = UBound(x)
  ReDim y(nlower To nupper)
  
  For n = nlower To nupper
    y(n) = x(n) ^ 2
  Next n

End Sub


Dieses Unterprogramm kann man dann in einem Hauptprogramm 
mit folgender Syntax aufrufen. Es gibt 2 Moeglichkeiten, 
mit oder ohne dem Call-Statement:


Sub HauptTestSub()

Dim v() As Double
Dim w() As Double
ReDim v(7 To 8)
v(7) = 3
v(8) = 30

'folgendes funktioniert:
TestUnterSub v(), w()
Debug.Print w(7), w(8)

'folgendes funktioniert auch:
Call TestUnterSub(v(), w())
Debug.Print w(7), w(8)

'dies liefert Fehlermeldung:
'TestUnterSub(v(),w())

'dies liefert ebenfalls Fehlermeldung:
'Call TestUnterSub v(), w()

End Sub