Visual Basic Concepts

Article
01/04/2007

Passing Arguments to Procedures

Usually the code in a procedure needs some information about the state of the program to do its job. This information consists of variables passed to the procedure when it is called. When a variable is passed to a procedure, it is called an argument.

Argument Data Types

The arguments for procedures you write have the Variant data type by default. However, you can declare other data types for arguments. For example, the following function accepts a string and an integer:

Function WhatsForLunch(WeekDay As String, Hour _
As Integer) As String
   ' Returns a lunch menu based on the day and time.
   If WeekDay = "Friday" then
      WhatsForLunch = "Fish"
   Else
      WhatsForLunch = "Chicken"
   End If
   If Hour > 4 Then WhatsForLunch = "Too late"
End Function

For More Information Details on Visual Basic data types are presented earlier in this chapter. You can also see the Language Reference for specific data types.

Passing Arguments By Value

Only a copy of a variable is passed when an argument is passed by value. If the procedure changes the value, the change affects only the copy and not the variable itself. Use the ByVal keyword to indicate an argument passed by value.

For example:

Sub PostAccounts(ByVal intAcctNum as Integer)
   .
   . ' Place statements here.
   .
End Sub

Passing Arguments By Reference

Passing arguments by reference gives the procedure access to the actual variable contents in its memory address location. As a result, the variable's value can be permanently changed by the procedure to which it is passed. Passing by reference is the default in Visual Basic.

If you specify a data type for an argument passed by reference, you must pass a value of that type for the argument. You can work around this by passing an expression, rather than a data type, for an argument. Visual Basic evaluates an expression and passes it as the required type if it can.

The simplest way to turn a variable into an expression is to enclose it in parentheses. For example, to pass a variable declared as an integer to a procedure expecting a string as an argument, you would do the following:

Sub CallingProcedure()
   Dim intX As Integer
   intX = 12 * 3
   Foo(intX)
End Sub

Sub Foo(Bar As String)
   MsgBox Bar   'The value of Bar is the string "36".
End Sub

Using Optional Arguments

You can specify arguments to a procedure as optional by placing the Optional keyword in the argument list. If you specify an optional argument, all subsequent arguments in the argument list must also be optional and declared with the Optional keyword. The two pieces of sample code below assume there is a form with a command button and list box.

For example, this code provides all optional arguments:

Dim strName As String
Dim strAddress As String

Sub ListText(Optional x As String, Optional y _
As String)
   List1.AddItem x
   List1.AddItem y
End Sub

Private Sub Command1_Click()
   strName = "yourname"
   strAddress = 12345   ' Both arguments are provided.
   Call ListText(strName, strAddress)
End Sub

This code, however, does not provide all optional arguments:

Dim strName As String
Dim varAddress As Variant

Sub ListText(x As String, Optional y As Variant)
   List1.AddItem x
   If Not IsMissing(y) Then
      List1.AddItem y
   End If
End Sub

Private Sub Command1_Click()
   strName = "yourname"   ' Second argument is not
                        ' provided.
   Call ListText(strName)
End Sub

In the case where an optional argument is not provided, the argument is actually assigned as a variant with the value of Empty. The example above shows how to test for missing optional arguments using the IsMissing function.

Providing a Default for an Optional Argument

It's also possible to specify a default value for an optional argument. The following example returns a default value if the optional argument isn't passed to the function procedure:

Sub ListText(x As String, Optional y As _
Integer = 12345)
   List1.AddItem x
   List1.AddItem y
End Sub

Private Sub Command1_Click()
   strName = "yourname"   ' Second argument is not
                        ' provided.
   Call ListText(strName)   ' Adds "yourname" and
                           ' "12345".
End Sub

Using an Indefinite Number of Arguments

Generally, the number of arguments in the procedure call must be the same as in the procedure specification. Using the ParamArray keyword allows you to specify that a procedure will accept an arbitrary number of arguments. This allows you to write functions like Sum:

Dim x As Integer
Dim y As Integer
Dim intSum As Integer

Sub Sum(ParamArray intNums())
   For Each x In intNums
      y = y + x
   Next x
   intSum = y
End Sub

Private Sub Command1_Click()
   Sum 1, 3, 5, 7, 8
   List1.AddItem intSum
End Sub

Creating Simpler Statements with Named Arguments

For many built-in functions, statements, and methods, Visual Basic provides the option of using named arguments as a shortcut for typing argument values. With named arguments, you can provide any or all of the arguments, in any order, by assigning a value to the named argument. You do this by typing the argument name plus a colon followed by an equal sign and the value ( MyArgument:= "SomeValue") and placing that assignment in any sequence delimited by commas. Notice that the arguments in the following example are in the reverse order of the expected arguments:

Function ListText(strName As String, Optional strAddress As String)
   List1.AddItem strName
   List2.AddItem strAddress
End Sub

Private Sub Command1_Click()
   ListText strAddress:="12345", strName:="Your Name"
End Sub

This is especially useful if your procedures have several optional arguments that you do not always need to specify.

Determining Support for Named Arguments

To determine which functions, statements, and methods support named arguments, use the AutoQuickInfo feature in the Code window, check the Object Browser, or see the Language Reference. Consider the following when working with named arguments:

Named arguments are not supported by methods on objects in the Visual Basic (VB) object library. They are supported by all language keywords in the Visual Basic for applications (VBA) object library.
In syntax, named arguments are shown as bold and italic. All other arguments are shown in italic only.

Important You cannot use named arguments to avoid entering required arguments. You can omit only the optional arguments. For Visual Basic (VB) and Visual Basic for applications (VBA) object libraries, the Object Browser encloses optional arguments with square brackets [ ].

For More Information See "ByVal*,"**"ByRef,"**"Optional,*"and"ParamArray" in the Language Reference.

Share via