1. Chapter 4 - Visual Basic Schneider
General Procedures
Chapter 4 - Visual Basic Schneider

2. Chapter 4 - Visual Basic Schneider
Outline & Objective
Sub Procedures
Procedure Parameters
Function Procedures
Chapter 4 - Visual Basic Schneider

3. Chapter 4 - Visual Basic Schneider
What is a procedure?
A general procedure is a set of commands that is given a name so that it can be invoked by another part of the program
Procedures make a program easier to develop, test, and correct
Code written to perform one well-defined subtask is referred to as a Sub procedure or function
A Sub procedure is a part of a program that performs one or more related tasks, has its own name,
To distinguish them from event procedures, Sub procedures and functions are refrred to as a General Procedures
Sub procedures allow us to focus on the tasks and later o how to accomplish each task
Chapter 4 - Visual Basic Schneider

4. Chapter 4 - Visual Basic Schneider
General Procedures
In Visual Basic, there are two types of procedures:
Sub
Function
Note: To distinguish procedures from event procedures, Sub and Function procedures are referred to as general procedures.
As a rule, a Sub procedure should perform only one task, or several closely related tasks, and should be kept relatively small
Chapter 4 - Visual Basic Schneider

5. Sub Procedures Properties:
can be called (invoked) by using
call subProcedureName()
passing data called arguments
Chapter 4 - Visual Basic Schneider

6. Creating Visual Basic Sub Procedure:
Activate the code window
Select Add Procedure from the Tools menu
Type in the name of the Sub procedure
Click on Private in the Scope box
Press the Enter key or click the OK button
Type the statements of the Sub procedure into the code window
Chapter 4 - Visual Basic Schneider

7. Syntax of a Sub Procedure
Private Sub ProcedureName ( )
statement(s)
End Sub
Procedure Name
Example
Statements

8. Components of Sub Procedure:
name: used to identify the Sub procedure
parameters: a Sub procedure accepts values from the caller through its parameters. It may also send values back to the caller through its parameters.
Chapter 4 - Visual Basic Schneider

9. Chapter 4 - Visual Basic Schneider
Sub Procedure's Name
The rules for naming Sub Procedures are the same as naming variables.
In this text, Sub procedure names begin with uppercase letters in order to distinguish them from variable names.
Chapter 4 - Visual Basic Schneider

10. Example

11. Example

12. Passing Arguments
A Sub procedure receives the location of the arguments, and may use and modify the value of the arguments stored at that location.
Example 1.4.2
It provides a vehicle for passing values from a Sub procedure back to the place which the Sub procedure was called
Different names may be used for an arguments and its corresponding parameter
Only one memory location is involved
Example 2.4.2 12 12

13. Passing arguments to parameters
Arguments : Variables or expressions placed in parentheses in a Call statement.
Go over example 4.1.6
Arguments
Chapter 4 - Visual Basic Schneider 13 13

14. Passing arguments to parameters
Parameters : Variables appearing in the sub procedure definition are called paramanters.
Go over example 4.1.6
The second CALL statement uses different variable names for the arguments to show that using the same argument names Is not necessary.
Parameters 14 14

15. Passing Arguments to Parameters
Call Add (x, y )
Private Sub Add ( num1 As Single, num2 As Single)
When the Call Statement is executed , each value of the arguments is assigned to it’s corresponding parameter variable
the value of num1 is assigned to x and the value of num2 is assigned to y
Arguments
Parameters 15 15

16. Passing arguments to parameters
Call Triple(num)
Private Sub Triple (num As Single)
Argument
Go over example 4.1.6
The second CALL statement uses different variable names for the arguments to show that using the same argument names Is not necessary.
Parameter
Chapter 4 - Visual Basic Schneider

17. Chapter 4 - Visual Basic Schneider
Sub Procedure Triple:
Private Sub cmdCompute_Click()
Dim num As Single
num = Val(InputBox("Enter a number:"))
Call Triple(num)
End Sub
cmdCompute Triple
num par/num
Private Sub Triple(num As Single)
' Multiply the value of the number by 3
picResult.Print "The number is"; 3 * num
End Sub
Private Sub Triple(par As Single)
' Multiply the value of the number by 3
picResult.Print "The number is"; 3 * par
End Sub
Chapter 4 - Visual Basic Schneider

18. Example

19. Example
cmdDisplay Triple
amt num

20. Passing by value
Sometime you want to pass a variable to a sub procedure, but you want to ensure that the variable will retain its original value after the sub procedure terminates.
Such variable is said to be passed by value

21. Passing by value There are two ways to pass the variable by value
1. In the call statements, enclose the variable in an extra pairs of parenthesis
cmdDisplay Triple
amt
num

22. 2. In the private Sub statement, precede the corresponding parameter with the word ByVal
cmdDisplay Triple
amt
num

23. Passing by value
When the variable is passed by value, the variable will retain its original value
cmdDisplay Triple
amt
num

24. ByRef and ByVal Examples
Private Sub cmdCall_Click()
Dim a As Integer
Dim b As Integer
a = 10
b = 15
Print a; b
Call mySub(a, b)
End Sub
Sub mySub(x As Integer, y As Integer)
x = 11
y = 16
Output
10 15
11 16
cmdCall mysub
a x
b y

25. ByRef and ByVal Examples
Private Sub cmdCall_Click()
Dim a As Integer
Dim b As Integer
a = 10
b = 15
Print a; b
Call mySub(a, b)
End Sub
Sub mySub(ByRef x As Integer, ByRef y As Integer)
x = 11
y = 16
Output
10 15
11 16
cmdCall mysub
a x
b y

26. ByRef and ByVal Examples
Private Sub cmdCall_Click()
Dim a As Integer
Dim b As Integer
a = 10
b = 15
Print a; b
Call mySub(a, b)
End Sub
Sub mySub(ByRef x As Integer, ByVal y As Integer)
x = 11
y = 16
Output
10 15
11 15
cmdCall mysub
a x b y

27. ByRef and ByVal Examples
Private Sub cmdCall_Click()
Dim a As Integer
Dim b As Integer
a = 10
b = 15
Print a; b
Call mySub(a, b)
End Sub
Sub mySub(ByVal x As Integer, ByVal y As Integer)
x = 11
y = 16
Output
10 15
cmdCall mysub a b x y

28. ByRef and ByVal Examples
Private Sub cmdCall_Click()
Dim a As Integer
Dim b As Integer
a = 10
b = 15
Print a; b
Call mySub(a, b)
End Sub
Sub mySub(ByRef y As Integer, ByRef x As Integer)
x = 11
y = 16
Output
10 15
16 11
cmdCall mysub
a y
b x

29. Important Rules for Passing Arguments to a Sub
The number of arguments and parameters must match.
The data type of each argument must match its corresponding parameter.
Chapter 4 - Visual Basic Schneider

30. Chapter 4 - Visual Basic Schneider
Local Variables:
A variable that is used only in a specific procedure (Sub or Function).
The scope of the local variable is the Sub or Function in which that variable has been defined.
When the same variable name appears in two different Sub procedure , Visual Basic gives the variables separate identity and treats them as two different variables.
Also each time a Sub procedure is called, all declared variables that are not parameters assume their default values.
Example (the value of num is set to default value)
Example (x is treated as different variable
Chapter 4 - Visual Basic Schneider

31. Chapter 4 - Visual Basic Schneider
Local Variables:
Declared within a procedure definition
Private to a procedure definition
Variables in different procedures are totally independent
Different procedures can have variables with the same names; however, each variable will have its own memory location
Chapter 4 - Visual Basic Schneider

32. Advantages of Local Variables
Extremely useful for team programming
Protects against accidental side effects (change of the value of the variable in one procedure that causes an error in another)
Chapter 4 - Visual Basic Schneider

33. Example
cmdDisplay pr1 x y
The variables x and y are local for the procedure cmdDisplay_Click
The variables x and y are local for the procedure pr1

34. Any change of the value of parameters (x and y) will affect only on the value of its corresponding arguments (a and b) in the caller procedure
cmdCall mysub
a x
b y x y z
Local variables

35. Chapter 4 - Visual Basic Schneider
Form-Level Variables
Form-level variables are visible to every procedure.
Form-level variables appear at the top of the code window.
Making a variable visible to every procedure in a form’s code without being passed.
When a form-level variable is assigned a value by a procedure, it retains its value when the procedure is exited
Chapter 4 - Visual Basic Schneider

36. How to create Form-Level Variables?
Activate the code window
Click on the down arrow to the right of the object list box
Click on General
Click on Declaration in the procedure list box
Type in Dim statements for form-level variables
Example 4.2.6
Delete Dim statements in Declaration section of General and show the resut
The sum of 2 and 3 is 5
num1 = 2
num2 = 3
Chapter 4 - Visual Basic Schneider

37. The variables x and y are Form-Level variables (Global)
cmdCall mysub
X Global X Global
y Global y Global
Note: The values of Form-level variables are visible to all procedures in the program

38. If the procedure has a local variables with the same name of the form-level variables, the procedure uses its local variable instead of the global variable x y 7 6
Form_level Variables x 5
Local y
The procedure uses the global variable if it has no local variable 8
Local

39. Examples

40. Form_load
In some situation we want to assign the value immediately to the Form-level variable
Visual basic has a special event procedure called Form_Load that is executed as soon as the program is run.

41. Example
Command pro1
X Global X Global
y Global y Global / b
x a

42. Chapter 4 - Visual Basic Schneider
What is a function?
Similar to a Sub, performs a specific task
Unlike a Sub, returns a single value to the calling program
Chapter 4 - Visual Basic Schneider

43. Types of Functions Standard functions (built-in)
VBasic has many bulit-in functions (Predefined functions).
E.g. (Left, Right, Len, Sqr, Round, …)
User-defined functions: In addition to using bulit-in functions, we can define functions of our own. These new function are called function procedures or user-defined functions

44. Built-in Functions Print Len(“Hello”)  5
Print Left(“Hello”,3)  “Hel”
Print Sqr(9)  3
For example, the function Len returns the number of characters in the string. It has One parameter of type String and returns only one value of type Single

45. User-Defined Function
A function returns a single value
The value is returned by assigning a value to the name of the function
The values of the parameters of a function should not be used for returning values from a function
It returns a single value
This value is returned in the function itself, not as an argument
A function is called by using its name in an
A function is called by using its name in an expression
the arguments of a function should not be altered in the function
If a procedure needs to return more than one value, a SUB procedure should be used instead.
Chapter 4 - Visual Basic Schneider

46. Chapter 4 - Visual Basic Schneider
The Function Syntax
Private Function FunctionName(parameter-list) As dataType
Statement(s)……
…..
FunctionName = value
End Function
Note: value must be of the type dataType specified in the function declaration
Chapter 4 - Visual Basic Schneider

47. Rules for Defining and Calling a Function
User-defined function must include a statement that assigns the function name a value.
User-defined functions are called in the same way that built-in functions are called.
A user-defined function may be called in an expression.
Chapter 4 - Visual Basic Schneider

48. Example of a Function The function Max has 2 parameters of type single
What is the data type of the returned value?

49. Chapter 4 - Visual Basic Schneider
Example of a Function
Private Sub cmdDetermine_Click()
Dim nom As String
nom = FirstName(txtFullName.Text)
picFirstName.Print "The first name is “; nom
End Sub
Private Function FirstName(nom As String) As String
Dim firstSpace As Integer
firstSpace = InStr(nom, " ")
FirstName = Left(nom, firstSpace - 1)
End Function
Chapter 4 - Visual Basic Schneider

50. Chapter 4 - Visual Basic Schneider
Another Example
Private Sub cmdDisplay_Click()
Dim num As Single
num = 5
picOutput.Print Triple (num)
picOutput.Print num
End Sub
Private Function Triple(x As Single) As Single
num = 3
Triple = num * x
End Function
Output: 15 5
Chapter 4 - Visual Basic Schneider

51. 18 Example Private sub com_click() x=fun(3) + fun( 5) Print x End sub
Private function fun(a)
fun= a
a=a+1
fun=fun + a
End function 18

52. Example Private sub com_click() x=fun(3, fun(2, 1)) Print x End sub
Private function fun(a,b) as integer
a=a+b
End function

53. Difference between calling sub-procedure and functions
To call a sub-procedure
Type the word Call followed by the procedure name, with the arguments (if any) in parentheses
Call pro1(5,3)
After the procedure statements are executed, the execution continues with the line following the call statements.

54. Difference between calling sub-procedure and functions
To call a sub-procedure

55. Difference between calling sub-procedure and functions
To call a function procedure
Use its name, with the arguments (if any) in parentheses EX: Fun(5,3)
A function is called in an expression.
Expression may be part of an assignment statement or an output statement
Print Fun(5,6)
X = 2*Fun(10,3)+3
Print Fun(x,y)+Fun(x+1,x+2)

56. After the function procedure statements are executed, the execution returns back to the calling point. And the function call statement (Max(10,2)) is substituted by the returned-value (10). 10

57. Any function can be rewritten as a sub and vise versa

58. Chapter 4 - Visual Basic Schneider
Common Errors
Passing incorrect data types
Not specifying the data type of the returned value
Not assigning a value to the Function name inside the Function definition
Misspelling of the Function name
Chapter 4 - Visual Basic Schneider

59. Arithmetic Operations
The VBasic arithmetic operations are addition, subtraction, multiplication, division and Exponentiation
Operator Operation Basic expression
^ Exponentiation A ^ B
* Multiplication A * B
/ Division A / B
Addition A + B
Subtraction A - B
hhhhhhh 59

60. More Arithmetic Operators
In VB, there are many other arithmetic operators such as:
Integer division (Uses the backslash, \)
(num1 \ num2) is the Quotient of num1 divided by num2 (the integer part of the result of dividing two integers )
Remainder: (num1 Mod num2) is the whole number remainder of num1 divided by num2
17 / 2 = 8.5
17 \ 2 = 8
17 Mod 2 = 1
16 / 2 = 8
16\ 2 =8
16 Mod 2 = 0
34/7=
34 \ 7 = 4
34 Mod 7 = 6

61. Chapter 4 - Visual Basic Schneider
Mod Rules
The whole number remainder
If the numbers are single they are rounded first
If one or both of a and b are negative the result of the Mod will have the sign of “a”
num1 Mod 1 = 0
num1 Mod num1 = 0
Num Mod 0 Division by zero
Result of Mod should be less than num2
Chapter 4 - Visual Basic Schneider

62. Chapter 4 - Visual Basic Schneider
Mod Examples
25 mod 7
= 4
3 mod 1
= 0
18.7mod 3.2
= 1
-3 mod 1
= 0
-35 mod 4
= -3
-35 mod -4
= -3
35 mod -4
= 3
-18.7 mod 3.2
= -1
-18.7 mod -3.2
= -1
18.7 mod -3.2
= 1
3 mod 3
= 0
3 mod -3
= 0
-3 mod 3
= 0
-3 mod -3
= 0
Chapter 4 - Visual Basic Schneider

63. Order of Precedence All operations inside of () are evaluated first
^ is evaluated next
* and /are at the same level of precedence and are evaluated next
\ (integer division) is evaluated next
Mod is evaluated next
+ and – have the same level of precedence and are evaluated last

64. Order of Precedence When operators are on the same level
Performed from left to right

65. What is the output of the following expression?
2+3^2+(2+5*2)/3 Mod 3 + 3
2+3^2+(2+10)/3 Mod 3 + 3
2+3^2+12/3 Mod 3 + 3
2+9+12/3 Mod 3 + 3
2+9+4 Mod 3 + 3 15
There are 3 arithmetic operators (+ , / and Mod).
Which operator has the highest priority?

66. Chapter 4 - Visual Basic Schneider1
Private Sub cmd_Click() Dim a As Integer Dim b As Integer a = 14 b = 5 picOutput.Print a / b \ b End Sub Output: Infinity /Illegal Division
Chapter 4 - Visual Basic Schneider

67. Chapter 4 - Visual Basic Schneider2.
Private Sub cmd_Click() Dim a As Integer Dim b As Integer a = 14 b = 5 picOutput.Print a mod b \ b End Sub Output: Infinity /Illegal Division
Chapter 4 - Visual Basic Schneider

68. Chapter 4 - Visual Basic Schneider
More Examples
Private Sub cmd_Click()
Dim a As Integer
Dim b As Integer
a = 14
b = 5
Print a / b
Print a \ b
Print a Mod b
End Sub
Output:
2.8 2 4
Chapter 4 - Visual Basic Schneider