Hallo Carsten
Ich habe keinen Schimmer, wovon Du redest.
Na dann versuche ich dir das mal nahe zu bringen 
Schaden kann es ja nicht 
Aber ich weiß auch nicht, warum der Umstand mit dem
Extra-Prozedur-Aufruf sein muß, außer vielleicht für die
Wiederverwendbarkeit des Codes.
Richtig. Wenn man es richtig anstellt wird sie arg flexibel und kann in jedem Project verwendet werden und nicht nur für Comboboxen
Das hier habe ich jedenfalls ausprobiert und es
läuft:
Private Sub ComboBox1_KeyPress(ByVal KeyAscii As
MSForms.ReturnInteger)
Select Case KeyAscii
Case vbKey0 To vbKey9, vbKeyBack, 46 'Pkt
Case Else
KeyAscii = 0
MsgBox „Datumsformat!“, vbExclamation
End Select
End Sub
Ja klar. Aber hast du mehr wie nur eine Combobox etc. die du prüfen magst ist das umstaendlich hoch 4!
Aber nun mal kurz zu Byref und Byval.
Wenn du eine Sub oder Function aufrufst kannst du ihr doch Parameter übergeben. Standard ist glaube ByRef
Das bedeutet eine Declaration alla
Public Sub Test(x as Long)
ist das selbe wie
Public Sub Test(Byref x as long)
Dim x as DeineKlasse
Set x = New DeineKlasse
oder
Dim x as New DeineKlasse
Das selbe zaehlt für Objecte!
Du kannst dir merken, alles was du nicht mit New instanzierst sind primitive Datentypen!
Soweit alles klar?
Wenn wir uns nun einmal den Speicher anschauen.
Stelle ihn dir einmal vor als 2 Vierecke die nebeneinander sind
Das linke Viereck ist der sogenannte Heap. das rechte Viereck dagegen der Stack!
SPEICHER
------------------------
| | |
| | |
| HEAP | STACK |
| | |
| | |
------------------------
Wenn du nun eine Variable anlegst, so wird diese doch im „Speicher“ gespeichert. Dazu wird sie im Stack abgelegt. Handelt es sich hierbei um primitive Datentypen so wird deren Wert dort direkt abgelegt. Handelt es sich aber um einen Verweis ( Refernz) so wird im Stack lediglich eine Adresse angelegt. Diese Adresse ist die Position der Daten im Heap. Also eine Verweis nach dem Heap! Im Heap selbst stehen dann die Daten
'primitiver Datentyp
Dim X as long
X=10
' Verweis
Dim Z as New Deine Klasse
HEAP | Stack
|
daten von | 10 'Daten von X
DeineKlasse | 1232431232'Adresse im Heap
an Adresse xyz im Heap |
es lässt sich nen bissl blöd erklären, aber ich hoffe du hast den Sinn verstanden.
So, nun gehen wir mal davon aus das du eine Variable ByVal übergibst. Byval selbst legt eine Kopie der Daten im Stack an und auf diese kannst du dann zugreifen.
In dem Bsp wird für X welchen den wert 10 hat eine kopie im Stack angelegt.In der Sub / Function wo du die Variable Byval uebergeben hast, liegt ja nun die Kopie vor. Diese kannst du in der Sub / Function veraendern wie du willst. Jedoch verlaesst du die Sub / Function wird diese Kopie wieder gelöscht. Der orginal Wert bleibt aber! das heisst eine Variable die du via Byval übergibst kannst du nicht aendern in der Sub. Sofern es sich um einen primitiven Datentyp handelt. Übergibst du sie aber ByRef so übergibst du sie als Verweis. Das heisst die Sub bekommt lediglich einen zeiger auf die Variable im Stack. Diese zeigt jedoch auf den orginal Wert. Wenn du diesen nun aenderst, so aenderst du den orginalen Wert. Beim verlassen der Sub / Function dann, wird zwar der Verweis gelöscht aber die orginalen Daten liegen geaendert im Stack vor!
Soweit alles klar?
So nun schauen wir uns mal die Refernzen an.
Du übergibst eine Referenz Byref. Das heisst du bekommst einen Zeiger direkt auf den Stack und von da aus auf dem Heap auf die orginalen Daten! Du änderst diese nun! Beim verlassen der Sub / function verfaellt der zeiger, aber die Daten sind geaendert. Eigentlich logisch oder?
So nun kommt ein kleines Phaenomaen! Du uebergibst eine Referenz Byval! Es wird ja eine Kopie von den Daten im Stack angelegt. Im Stack steht aber nun der zeiger ( Die Adresse) wo sich die Daten im Heap befinden. Nun aenderst du etwas. Du greifst ueber den kopierten zeiger im Stack auf die Orginalen daten im Heap zu, da ja nur der Inhalt vom stack kopiert wird und nicht die vom Heap!
HEAP Stack
DeineDaten XYZ'Zeiger auf den Heap
Adresse XYZ Kopie von XYZ
Beide Daten im Stack zeigen auf die selben Daten im Heap!!!
Nun aenderst du etwas. Das bedeutet das du ueber die Kopie im Stack auf die orginalen Daten im Heap zugreifst und somit die orginalen Daten aenderst!
Wenn du nun die Sub / Function verlaesst so wird die Kopie gelöscht aber die Daten im Heap sind geaendert!
Auf Deutsch heisst das, das es keine Rolle spielt ob du eine Referenz Byval oder ByRef übergibst! Bei Primitiven Datentypen schon
Viele Grüße
Carsten
MfG Alex
