In the previous lesson, we saw that you could declare
a global variable outside of any procedure. When using various procedures
in a code file, one of the characteristics of a global variable is that it
is automatically accessible to other procedures. Still, a global variable
can use access modifiers that would control its access:

Private: A private global variable can be accessed by any
procedure of the same module. No procedure of another module, even of
the same program, can access it

Friend: A friendly global variable can be accessed by any
procedure of any module of the same project. A procedure of another
program cannot access that variable

Public: A public global variable can be accessed by any
procedure of its project and procedures of other projects

Based on this characteristic of the procedures of a
module having access to global variables of the same program, you can
declare such variables and initialize or modify them in any procedure of the
same code file.

To execute the program, on the Standard toolbar, click the Start
Debugging button

Enter the length as 32.08 and the with as
24.84

Close the message box and return to your programming environment

Introduction to Arguments

So far, to use a value in a procedure, we had to declare
it. In some cases, a procedure may need an external value in order to carry
its assignment. A value that is supplied to a procedure is called an
argument.

When creating a procedure that will use an external
value, declare the argument that represents that value between the
parentheses of the procedure. For a procedure, the syntax you use would be:

SubProcedureName(Argument)
End Sub

If you are creating a function, the syntax would be:

FunctionProcedureName(Argument) As DataTypeFunction Sub

The argument must be declared as a normal variable,
omitting the Dim keyword. Here is an example that creates a function
that takes a string as argument:

Function CalculatePayroll(strName As String) As Double
Function Sub

A certain procedure can take more than one argument. In
this case, in the parentheses of the procedure, separate the arguments with
a comma. Here is an example of a procedure that takes two arguments:

Sub EvaluateInvoice(EmplName As String, HourlySalary As Currency)
End Sub

In the body of a procedure that takes one or more
arguments, use the argument(s) as you see fit as if they were locally
declared variables. For example, you can involve them with values inside of
the procedure. You can also exclusively use the values of the arguments to
perform the assignment.

Calling a Procedure With Argument

To call a procedure that takes an argument, type its
name and a space, followed by a value for each argument between parentheses.
The value provided for an argument is also called a parameter. If there is
more than one argument, separate them with a comma. Here is an example:

As mentioned previously, you can also use the Call
keyword to call a procedure.

When you call a procedure that takes more than one
argument, you must provide the values of the arguments in the exact order
they are listed inside of the parentheses of the function. Fortunately, you
don't have to. If you know the names of the arguments, you can type them in
any order and provide a value for each. To do that, on the right side of
each argument, type the := operator followed by the desired value for the
argument. Here are examples:

To pass arguments to a function, change the file as follows (when
you type the argument, Microsoft Visual Studio, actually the Visual
Basic language parser, will add the ByVal keywords; in the next
sections, we will learn what that keyword means; for now, keep it but
ignore it):

To execute the program, on the main menu, click Debug -> Start
Debugging

Enter the length as 44.14 and the with as
30.76

Close the message box and return to your programming environment

Techniques of Passing Arguments

Passing an Argument By Value

When calling a procedure that takes
an argument, we were supplying a value for that argument. When this is done,
the procedure that is called makes a copy of the value of the argument and
makes that copy available to the calling procedure. That way, the argument
itself is not accessed. This is referred to as passing an argument by value.
This can be reinforced by typing the ByVal keyword on the left side
of the argument. Here is an example:

Private Sub Welcome(ByVal strLanguage As String)
MsgBox("Welcome to the wonderful world of " & strLanguage)
End Sub

If you create a procedure that takes an argument by
value and you have used the ByVal keyword on the argument, when
calling the procedure, you don't need to use the ByVal keyword; just
the name of the argument is enough, as done in the examples on arguments so
far. Here is an example:

Public Module Exercise
Public Function Main() As Integer
Dim ComputerLanguage As String = "Visual Basic"
Welcome(ComputerLanguage)
Return 0
End Function
Private Sub Welcome(ByVal strLanguage As String)
MsgBox("Welcome to the wonderful world of " & strLanguage)
End Sub
End Module

This would produce:

Passing an Argument By
Reference

An alternative to passing an argument as done so far is
to pass the address of the argument to the procedure. When this is done, the
procedure doesn't receive a simple copy of the value of the argument: the
argument is accessed by its address. That is, at its memory address. With
this technique, any action carried on the argument will be kept. If the
value of the argument is modified, the argument would now have the new
value, dismissing or losing the original value it had. This technique is
referred to as passing an argument by reference. Consider the following
program:

Notice that, although the values of the arguments were
changed in the Addition() procedure, at the end of the procedure, they lose
the value they got in the function. If you want a procedure to change the
value of an argument, you can pass the argument by reference.

To pass an argument by reference, on its left, type the
ByRef keyword. This is done only when defining the procedure. When
the procedure finishes with the argument, the argument would keep
whatever modification was made on its value. Now consider the same program
as above but with arguments passed by reference:

Using this technique, you can pass as many arguments by
reference and as many arguments by value as you want. As you may guess
already, this technique is also used to make a procedure return a value,
which a regular procedure cannot do. Furthermore, passing arguments by
reference allows a procedure to return as many values as possible while a
regular function can return only one value.

To execute the program, on the Standard toolbar, click the Start
Debugging button

Enter the length as 24.55 and the width as
22.85

Close the message box and return to your programming environment

Other Techniques of Passing Arguments

Optional Arguments

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:

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.

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:

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:

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:

A program involves a great deal of names that represent
variables and procedures of various kinds. The compiler does not allow two
variables to have the same name in the same procedure (or in the same
scope). Although two procedures should have unique names in the same
program, you are allowed to use the same name for different procedures of
the same program following certain rules.

The ability to have various procedures with the same
name in the same program is referred to as overloading. The most important
rule about procedure overloading is to make sure that each one of these
procedures has a different number or different type(s) of arguments.

Practical
Learning: Overloading a Procedure

The moment of inertia is the ability of a beam to resist
bending. It is calculated with regard to the cross section of the beam.
Because it depends on the type of section of the beam, its calculation also
depends on the type of section of the beam. In this exercise, we will review
different formulas used to calculate the moment of inertia. Since this
exercise is for demonstration purposes, you do not need to be a Science
Engineering major to understand it.

To start a new project, on the main menu, click File -> New
Project...

In the middle list, click Console Application

Change the Name to MomentOfInertia1

Click OK

In the Solution Explorer, right-click Module1.vb and click Rename

Type MomentOfInertia.vb and press Enter

To calculate the moment of inertia of a rectangle, change the file
as follows:

To execute the program, on the main menu, click Debug -> Start
Debugging

Enter the base as 3.25

Enter the height as 2.85

Close the DOS window and return to your programming environment

Here are the formulas to calculate the moment of inertia for a
semi-circle:

A circle, and thus a semi-circle, requires
only a radius. Since the other version of the MomentOfInertia()
function requires two arguments, we can overload it by providing
only one argument, the radius.

To calculate the moment of inertia of a rectangle, change the file as
follows: