Make your own free website on Tripod.com

Visual Basic Tutorial Part 3

myitcareer.org-Your IT Career Partner For Life. Please Bookmark It.
Homework Help | Buy Book | Buy Phone | Top Web Hosts | Hire Web Designer
Home | Interview Questions And Answers | Hosting Charges | Online Tuition
Top Domain Registrars | Hire Freelancer | Employee Provident Fund | Hindi News

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



22. How does VB Pass arguments to a function by
default?

By Ref
23. Can a subroutine pass back values? How?

Yes By passing the values BYREF

Next topic
Previous topic