ABOUT Visual Basic - das Webmagazin: KnowHow

ABOUT Visual Basic Programmieren Programmierung Download Downloads Tips & Tricks Tipps & Tricks Know-How Praxis VB VBA Visual Basic for Applications VBS VBScript Scripting Windows ActiveX COM OLE API ComputerPC Microsoft Office Microsoft Office 97 Office 2000 Access Word Winword Excel Outlook Addins ASP Active Server Pages COMAddIns ActiveX-Controls OCX UserControl UserDocument Komponenten DLL EXE

(-hg)

Im Gegensatz zu Visual Basic kennen die meisten Programmiersprachen (und auch andere Basic-Dialekte) inkrementierende und dekrementierende Operatoren oder Anweisungen und auch eine Anweisung zum Vertauschen der Inhalte zweier Variablen.

In Visual Basic ist zum Inkrementieren bzw. Dekrementieren dagegen eine etwas umständliche Schreibweise notwendig (Ausnahme: Datumswerte - hier gibt es die Funktion DateAdd), etwa:

A = A + 1
B = B - 1

Und zum Vertauschen ist eine Hilfsvariable notwendig:

H = A
A = B
B = H

Das Windows-API bietet hierbei keine brauchbare Unterstützung oder Verkürzung. Es gibt zwar Funktionen wie InterlockedIncrement, InterlockedDecrement und InterlockedExchange (die Kollege Wolfgang Kluge entdeckt hat). Sie sind zwar etwas schneller als der Weg in reinem Visual Basic, sie sind jedoch lediglich für Werte des Datentyps Long geeignet (und eigentlich gar nicht in erster Linie zu diesem Zweck vorgesehen, wie aus den Dokumentationen hervorgeht).

Zur Einsparung der umständlichen Schreibweisen können Sie diese in Hilfsfunktionen verpacken und in ein Standard-Modul auslagern. Die folgenden Funktionen enthalten Implementierungen für alle Datentypen - jeweils einmal in der allgemeinen Form für Variants (jedoch wegen der Variant-Verwendung etwas langsamer) und in spezialisierten Formen für die Datentypen Integer, Long, Single und Double. Sie übergeben den Sub-Prozeduren die zu inkrementierende bzw. dekrementierende Variable als Parameter und optional den Wert des Inkrements bzw. Dekrements (Voreinstellung 1 bzw. -1).

Beispiele:

Dim A As Variant

A = 10
Inc A

ergibt A = 11;

Dim B As Long

B = 100
Dec B

ergibt 99;

Dim C As Single

C = 5,5
Inc C, 0,5

ergibt 6.

Die Prozeduren:

Private Declare Sub InterlockedIncrement Lib "kernel32" _
 (lpAddend As Long)
Private Declare Sub InterlockedDecrement Lib "kernel32" _
 (lpAddend As Long)

Public Sub Inc(Var As Variant, Optional ByVal Increment As Long = 1)
  Var = CLng(Var) + Increment
End Sub

Public Sub IncI(Var As Integer, Optional ByVal Increment As _
 Integer = 1)
  Var = Var + Increment
End Sub

Public Sub IncL(Var As Long, Optional ByVal Increment As Long = 1)
  If Increment = 1 Then
    InterlockedIncrement Var
  Else
    Var = Var + Increment
  End If
End Sub
 
Public Sub IncS(Var As Single, Optional ByVal Increment As _
 Single = 1)
  Var = Var + Increment
End Sub

Public Sub IncD(Var As Double, Optional ByVal Increment As _
 Double = 1)
  Var = Var + Increment
End Sub

Public Sub Dec(Var As Variant, Optional Decrement As Long = -1)
  Var = CLng(Var) + Decrement
End Sub

Public Sub DecI(Var As Integer, Optional Decrement As _
Integer = -1)
  Var = Var + Decrement
End Sub

Public Sub DecL(Var As Long, Optional Decrement As Long = -1)
  If Decrement = 1 Then
    InterlockedDecrement Var
  Else
    Var = Var + Decrement
  End If
End Sub

Public Sub DecS(Var As Single, Optional Decrement As Single = -1)
  Var = Var + Decrement
End Sub

Public Sub DecD(Var As Double, Optional Decrement As Double = -1)
  Var = Var + Decrement
End Sub

Die Prozeduren Inc und Dec bzw. deren datentypspezifische Varianten erhöhen bzw. vermindern den Wert einer Variablen um 1 (Voreinstellung) oder einen beliebigen Wert

Ein wenig spezialisierter sind die Funktionen IncTo und DecTo bzw. deren datentypspezifische Varianten. Sie inkrementieren oder dekrementieren einen Wert um einen bestimmten Wert, solange er unter einer vorgegebenen Obergrenze bzw. über einer vorgegebenen Untergrenze liegt. Im Prinzip beruhen For-Schleifen auf diesem Prinzip. IncTo und DecTo haben jedoch den Vorteil, dass die vorgegebenen Ober- bzw. Untergrenzen nicht exakt getroffen werden müssen, um die Schleife zu beenden, wenn der Grenzwert nicht durch das Inkrement bzw. das Dekrement teilbar ist.

So können Sie mit IncTo beispielsweise den Ausgangswert 2 in einer Do...Loop-Schleife um 5 erhöhen, so lange die Obergrenze von 30 nicht erreicht wird. So lange eine Inkrementierung erfolgt, gibt die Funktion IncTo den Rückgabewert True zurück. Bei der letzten Inkrementierung beim Stand von 27 würde der Grenzwert 30 überschritten - der Wert wird nun nicht mehr erhöht und die Funktionen gibt den Wert False zurück, so dass die Schleife verlassen wird:

Dim A As Integer

A = 2
Do While IncTo(A, 30, 5)
  '...
Loop

Die Funktionen:

Public Function IncTo(Var As Variant, ToVar As Variant, _
 Optional ByVal Increment As Long = 1) As Boolean
  Dim nVar As Variant
  
  nVar = CLng(Var) + Increment
  If nVar <= CLng(ToVar) Then
    Var = nVar
    IncTo = True
  End If
End Function

Public Function IncToI(Var As Integer, ToVar As Integer, _
 Optional ByVal Increment As Integer = 1) As Boolean
  Dim nVar As Integer
  
  nVar = Var + Increment
  If nVar <= ToVar Then
    Var = nVar
    IncTo = True
  End If
End Function

Public Function IncToL(Var As Long, ToVar As Long, _
 Optional ByVal Increment As Long = 1) As Boolean
  Dim nVar As Long
  
  nVar = Var + Increment
  If nVar <= ToVar Then
    Var = nVar
    IncTo = True
  End If
End Function

Public Function IncToS(Var As Single, ToVar As Single, _
 Optional ByVal Increment As Single = 1) As Boolean
  Dim nVar As Single
  
  nVar = Var + Increment
  If nVar <= ToVar Then
    Var = nVar
    IncTo = True
  End If
End Function

Public Function IncToD(Var As Double, ToVar As Double, _
 Optional ByVal Increment As Double = 1) As Boolean
  Dim nVar As Double
  
  nVar = Var + Increment
  If nVar <= ToVar Then
    Var = nVar
    IncTo = True
  End If
End Function

Public Function DecTo(Var As Variant, Optional ToVar As Variant, _
Optional ByVal Increment As Long = 1) As Boolean
  Dim nVar As Variant
  
  nVar = CLng(Var) + Increment
  If nVar >= CLng(ToVar) Then
    Var = nVar
    DecTo = True
  End If
End Function

Public Function DecToI(Var As Integer, Optional ToVar As Integer, _
 Optional ByVal Increment As Integer = 1) As Boolean
  Dim nVar As Integer
  
  nVar = Var + Increment
  If nVar >= ToVar Then
    Var = nVar
    DecTo = True
  End If
End Function

Public Function DecToL(Var As Long, Optional ToVar As Long, _
 Optional ByVal Increment As Long = 1) As Boolean
  Dim nVar As Long
  
  nVar = Var + Increment
  If nVar >= ToVar Then
    Var = nVar
    DecTo = True
  End If
End Function

Public Function DecToS(Var As Single, Optional ToVar As Single, _
 Optional ByVal Increment As Single = 1) As Boolean
  Dim nVar As Single
  
  nVar = Var + Increment
  If nVar >= ToVar Then
    Var = nVar
    DecTo = True
  End If
End Function

Public Function DecToD(Var As Double, Optional ToVar As Double, _
Optional ByVal Increment As Double = 1) As Boolean
  Dim nVar As Double
  
  nVar = Var + Increment
  If nVar >= ToVar Then
    Var = nVar
    DecTo = True
  End If
End Function

Die Funktionen IncTo und DecTo bzw. deren datentypspezifische Varianten erhöhen bzw. vermindern den Wert einer Variablen so lange eine vorgegebene Obergrenze nicht überschritten bzw. eine vorgegebene Untergrenze nicht unterschritten wird

Ähnlich wie Inc und Dec kapseln die Prozeduren zum Vertauschen der Inhalte zweier Variablen die umständliche Visual Basic-Syntax (nur beim Datentyp Long wird die schnellere API-Funktion InterlockedExchange verwendet). Bei der allgemeinen Variante wird sogar berücksichtigt, dass einer der beiden Werte oder beide Werte Objekte sein können, bei denen die Zuweisungen mit der Set-Anweisung erfolgen müssen. Ebenso kommt dementsprechend die spezialisierte Variante SwapObj dazu. Und für Datumswerte gibt es schließlich noch die Variante SwapDate.

Private Declare Function InterlockedExchange Lib "kernel32" _
 (lpVar1 As Long, ByVal Var2 As Long) As Long
						
Public Sub Swap(Var1 As Variant, Var2 As Variant)
  Dim nVar As Variant
  
  If IsObject(Var1) And IsObject(Var2) Then
    Set nVar = Var1
    Set Var1 = Var2
    Set Var2 = nVar
  ElseIf IsObject(Var1) Then
    Set nVar = Var1
    Var1 = Var2
    Set Var2 = nVar
  ElseIf IsObject(Var2) Then
    nVar = Var1
    Set Var1 = Var2
    Var2 = nVar
  Else
    nVar = Var1
    Var1 = Var2
    Var2 = nVar
  End If
End Sub

Public Sub SwapI(Var1 As Integer, Var2 As Integer)
  Dim nVar As Integer
  
  nVar = Var1
  Var1 = Var2
  Var2 = nVar
End Sub

Public Sub SwapL(Var1 As Long, Var2 As Long)
  Var2 = InterlockedExchange(Var1, Var2)
End Sub

Public Sub SwapS(Var1 As Single, Var2 As Single)
  Dim nVar As Single
  
  nVar = Var1
  Var1 = Var2
  Var2 = nVar
End Sub

Public Sub SwapD(Var1 As Double, Var2 As Double)
  Dim nVar As Double
  
  nVar = Var1
  Var1 = Var2
  Var2 = nVar
End Sub

Public Sub SwapObj(Var1 As Object, Var2 As Object)
  Dim nVar As Object
  
  Set nVar = Var1
  Set Var1 = Var2
  Set Var2 = nVar
End Sub

Public Sub SwapDate(Var1 As Date, Var2 As Date)
  Dim nVar As Date
  
  nVar = Var1
  Var1 = Var2
  Var2 = nVar
End Sub

Die Prozedur Swap und ihre datentypspezifische Varianten vertauschen den Inhalt zweier Variablen