|
Declaring a Static Variable |
|
To declare a static variable, type the Static keyword
on the left of the Dim keyword. You should always initialize a static variable before
using it. To make the local variables of our
Starter() function static, we can declare them as follows:
Public Module Exercise
Private Sub Starter(ByVal y As Integer)
Static Dim a As Double = 112.5
Static Dim b As Double = 175.25
Dim Result As String
a = a / y
b = b + 2
Result = "y = " & vbTab & CStr(y) & vbCrLf & _
"a = " & vbTab & CStr(a) & vbCrLf & _
"b = " & vbTab & CStr(b) & vbCrLf & _
"b/a = " & vbTab & CStr(b / a)
MsgBox(Result)
End Sub
Public Function Main() As Integer
Starter(2)
Starter(2)
Starter(2)
Starter(2)
Return 0
End Function
End Module
This time, when executing the program, it would
produce:
Notice that, this time, each local variable keeps its
newly changed value when the function exits.
If you create a procedure that takes one or more
arguments, whenever you call that procedure, you must provide a value for the argument(s). Otherwise,, you would receive an error.
If such an argument is passed with the same value over and over again, you
may be tempted to remove the argument altogether. In some cases, although
a certain argument is passed with the same value most of the time, you
still have situations in which you want the user to decide whether to pass
a value or not for the argument, you can declare the value optional. In
other words, you can create the argument with a default value so that the
user can call the procedure without passing a value for the argument, thus
passing a value only when necessary. Such an argument is called default or
optional.
Imagine you write a procedure that will be used to
calculate the final price of an item after discount. The procedure would
need the discount rate in order to perform the calculation. Such a
procedure could look like this:
Function CalculateNetPrice#(ByVal DiscountRate As Double)
Dim OrigPrice#
OrigPrice = InputBox("Please enter the original price:")
Return OrigPrice - (OrigPrice * DiscountRate / 100)
End Function
Since this procedure expects an argument, if you do not
supply it, the following program would not compile:
Public Module Exercise
Function CalculateNetPrice#(ByVal DiscountRate As Double)
Dim OrigPrice#
OrigPrice = InputBox("Please enter the original price:")
Return OrigPrice - (OrigPrice * DiscountRate / 100)
End Function
Public Function Main() As Integer
Dim FinalPrice#
Dim Discount# = 15 ' That is 25% = 25
FinalPrice = CalculateNetPrice(Discount)
MsgBox("Final Price = " & FinalPrice)
Return 0
End Function
End Module
Here is an example of running the program:
Most of the time, a procedure such as ours would use
the same discount rate over and over again. Therefore, instead of
supplying an argument all the time, you can define an argument
whose value would be used whenever the function is not provided with the
argument.
|
Passing an Optional Argument |
|
To specify that an argument is optional, when creating
its procedure, type the Optional keyword to the left of the
argument's name and assign it the default value. Here is an example:
Public Module Exercise
Function CalculateNetPrice#(Optional ByVal DiscountRate As Double = 20)
Dim OrigPrice#
OrigPrice = InputBox("Please enter the original price:")
Return OrigPrice - (OrigPrice * DiscountRate / 100)
End Function
Public Function Main() As Integer
Dim FinalPrice#
Dim Discount# = 15 ' That is 25% = 25
FinalPrice = CalculateNetPrice()
MsgBox("Final Price = " & FinalPrice)
Return 0
End Function
End Module
Here is an example of running the program:
|
A Procedure With Many Optional Arguments |
|
If a procedure takes more than one argument, you can
provide a default argument for each and select which ones would have
default values. If you want all arguments to have default values, when
defining the procedure , provide the Optional keyword for each and assign
it the desired default value. Here is an example:
Public Module Exercise
Function CalculateNetPrice#(Optional ByVal Tax As Double = 5.75, _
Optional ByVal Discount As Double = 25, _
Optional ByVal OrigPrice As Double = 245.55)
Dim DiscountValue As Double = OrigPrice * Discount / 100
Dim TaxValue As Double = Tax / 100
Dim NetPrice As Double = OrigPrice - DiscountValue + TaxValue
Dim Result As String
Result = "Original Price: " & vbTab & CStr(OrigPrice) & vbCrLf & _
"Discount Rate: " & vbTab & CStr(Discount) & "%" & vbCrLf & _
"Tax Amount: " & vbTab & CStr(Tax)
MsgBox(Result)
Return NetPrice
End Function
Public Function Main() As Integer
Dim FinalPrice As Double
FinalPrice = CalculateNetPrice()
MsgBox("Final Price: " & CStr(FinalPrice))
Return 0
End Function
End Module
This would produce:
If a procedure takes more than one argument as above,
remember that some arguments can be specified as optional. In this case,
when calling the procedure, any argument that does not have a default value
must be passed with a value. When creating a procedure that takes more
than one argument, the argument(s) that has(have) default value(s) must be
the last in the procedure. This means that:
- If a procedure takes two
arguments and one argument has a default value, this optional argument
must be the second
- If a procedure is taking three or more arguments and
two or more arguments have default values, these optional arguments must
by placed to the right of the non-optional argument(s).
Because of this,
when calling any procedure in the Visual Basic language, you must know what, if any, argument
is optional and which one is not.
If a procedure takes two arguments and one argument
has a default value, when calling this procedure, you can pass only one
value. In this case, the passed value would be applied on the first
argument. If a procedure takes more than two arguments and two or more
arguments have a default value, when calling this procedure, you can
provide only the value(s) of the argument that is (are) not optional. If
you want to provide the value of one of the arguments but that argument is
not the first optional, you can leave empty the position(s) of the other
argument(s) but remember to type a comma to indicate that the position is
that of an argument that has a default value. Here is an example:
Public Module Exercise
Function CalculateNetPrice(ByVal AcquiredPrice As Double, _
ByVal MarkedPrice As Double, _
Optional ByVal TaxRate As Double = 5.75, _
Optional ByVal DiscountRate As Double = 25) As Double
Dim DiscountAmount As Double = MarkedPrice * DiscountRate / 100
Dim TaxAmount As Double = MarkedPrice * TaxRate / 100
Dim NetPrice As Double = MarkedPrice - DiscountAmount + TaxAmount
Dim Result As String
Result = "Price Acquired: " & vbTab & CStr(AcquiredPrice) & vbCrLf & _
"Marked Price: " & vbTab & CStr(MarkedPrice) & vbCrLf & _
"Discount Rate: " & vbTab & CStr(DiscountRate) & "%" & vbCrLf & _
"Discount Amt: " & vbTab & CStr(DiscountAmount) & vbCrLf & _
"Tax Rate: " & vbTab & CStr(TaxRate) & "%" & vbCrLf & _
"Tax Amount: " & vbTab & CStr(TaxAmount)
MsgBox(Result)
Return NetPrice
End Function
Public Function Main() As Integer
Dim FinalPrice As Double
FinalPrice = CalculateNetPrice(225.55, 150.55, , 40)
MsgBox("Final Price: " & CStr(FinalPrice))
Return 0
End Function
End Module
This would produce:
|
Practical
Learning: Overloading a Procedure
