Zahra Zahid

Visual Basic
Handbook
Zahra Zahid

Contents
Contents.............................................................................................................................. 2  
Introduction to Handbook. ................................................................................................ 4  
Preface ................................................................................................................................ 4  
Common errors: ........................................................................................................................................ 4  
Conventions used in this book: ................................................................................................................. 4  
Introduction to Visual Basic.............................................................................................. 5  
Chapter 1 – Your first program ......................................................................................... 6  
Chapter 2 – Using Variables.............................................................................................. 7  
Variables ................................................................................................................................................... 7  
The Assignment Statement ...................................................................................................................... 8  
The Console.Writeline() Statement ........................................................................................................... 9  
The Console.Readline Statement ............................................................................................................. 9  
Arithmetic Expressions ........................................................................................................................... 12  
Comments .............................................................................................................................................. 12  
Chapter 3 – Data types .................................................................................................... 13  
Integer ..................................................................................................................................................... 13  
Byte ......................................................................................................................................................... 13  
Decimal ................................................................................................................................................... 13  
Single/Double ......................................................................................................................................... 13  
Char ........................................................................................................................................................ 13  
String ...................................................................................................................................................... 14  
Boolean ................................................................................................................................................... 14  
Date ........................................................................................................................................................ 15  
Ordinal data types................................................................................................................................... 16  
Simple types ........................................................................................................................................... 16  
Constants ................................................................................................................................................ 16  
Advantages of using named constants ................................................................................................... 16  
Chapter 4 – Selection....................................................................................................... 18  
If … Then ................................................................................................................................................ 18  
If … Then … Else ................................................................................................................................... 19  
Nested If statements ............................................................................................................................... 19  
Indentation .............................................................................................................................................. 19  
Select Case ............................................................................................................................................ 21  
Chapter 5 – Iteration (repetition)..................................................................................... 23  
For loop ................................................................................................................................................... 23  
Do While ................................................................................................................................................. 25  
Chapter 6 – Arrays ........................................................................................................... 26  
One-Dimensional Arrays ......................................................................................................................... 27  
Two-Dimensional Arrays ......................................................................................................................... 27  
Enumerated Types ................................................................................................................................. 28  
Sets ......................................................................................................................................................... 29  
Chapter 7 – Functions ..................................................................................................... 30  
Built-in Functions .................................................................................................................................... 30  
Random Numbers ................................................................................................................................... 31  
User-defined functions ............................................................................................................................ 32  
Local Variables ....................................................................................................................................... 33  
Zahra Zahid

Chapter 8 – Procedures ................................................................................................... 34  

Worked Example: ................................................................................................................................... 34  
Parameters ............................................................................................................................................. 36  
Value and Variable Parameters .............................................................................................................. 38  
Chapter 9 – Records ........................................................................................................ 39  
Arrays of Records ................................................................................................................................... 40  
Chapter 10 – Files ............................................................................................................ 41  
Text Files ................................................................................................................................................ 41  
Direct Access Files ................................................................................................................................. 42  
Introduction to Programming
Using Visual Basic

Introduction to Handbook.
This is the computing handbook that will guide you through your BO65 Unit.

You will be using a language called Visual Basic which is nice language that has
application in real world systems. We will be using this language to help you understand
the basic concepts of programming. The second half of this handbook contains all your
Visual Basic Chapters and tasks.

Preface
This guide is intended to provide an introduction to the concepts of programming in an
imperative high-level programming language. The book is designed to be worked through
in sequence, each chapter building on the previous one; building up a basic knowledge of
programming concepts that can be applied to every high-level language.

The exercises will be marked by your teacher against the following criteria (all programs
should be pseudo-coded or annotated):
• 5 : Efficient use of code and good coding layout (indentions etc..)
• 4: No help, problem solved.
• 3: Little help, problem solved.
• 2: Problem solved with help.
• 1: Problem not solved.

You will also have a written programming test after the unit of work on the concepts
outlined in this book. Also, as this guide has been prepared against the AQA AS
Computing specification you should ensure you are familiar with all of the content.

Common errors:
• Overcomplicating programs – always look for the simplest solution
• Writing pseudo-code after writing the program – it does help you to solve a problem
use it!
• Asking your teacher for help before you check your own code – there is a useful
checklist of common errors at the back of this book (Appendix A).

Conventions used in this book:

Each major concept is introduced in a new chapter and any code will be highlighted in the
following way:

This is programming code;

Page 4
Introduction to Programming
Using Visual Basic

Introduction to Visual Basic

VISUAL BASIC is a high level programming language which evolved from the earlier
DOS version called BASIC. BASIC means Beginners' All-purpose Symbolic Instruction
Code. It is a very easy programming language to learn. The code look a lot like English
Language. Different software companies produced different versions of BASIC, such as
Microsoft QBASIC, QUICKBASIC, GWBASIC ,IBM BASICA and so on. However, people
prefer to use Microsoft Visual Basic today, as it is a well developed programming language
and supporting resources are available everywhere. Now, there are many versions of VB
exist in the market, the most popular one and still widely used by many VB programmers is
none other than Visual Basic 6. We also have VB.net, VB2005, VB2008 and the latest
VB2010. Both Vb2008 and VB2010 are fully object oriented programming (OOP)
language. (source - http://www.vbtutor.net/lesson1.html)

Page 5
Introduction to Programming
Using Visual Basic

Chapter 1 – Your first program

The environment which we will be using to learn Visual Basic is Microsoft Visual Basic
2010 Express. For the purpose of teaching programming basics we will be using a
console application project although towards the end we will look at the event driven visual
side of VB Programming.

When you create a new Console Application project – you should see the following in the
code editor.

Module  Module1  
 
       Sub  Main()  
 
       End  Sub  
 
End  Module  

Hello World!
Type the code below into the window between the Main() and End Sub statements.

Console.Write("Hello  World")  
Console.Read()  

This code writes the text “Hello World” to the screen, and the “Read” keeps the window
open.

To make your program work, first of all save your work by pressing the following icon

Then debug your program by pressing the play icon on the top bar.

You have written your first computer program!

Similar to Console.Write there is Console.WriteLine which inserts a carriage return. See

how that works…

Page 6
Introduction to Programming
Using Visual Basic

Chapter 2 – Using Variables

Computer programs normally use (process) data in some way to produce results. This
normally relies on an INPUT from the program or user, which is PROCESSED by the
program then displayed in the console window, OUTPUT.

INPUT PROCESS OUTPUT

The input to the program is often supplied by the user whilst the program is running.

Variables
In a computer program, variables can be imagined as labelled boxes that store data for
use in the program. You tell the computer what will be stored in the variable when you
‘declare’ it.

Using the example of a program that adds two numbers together and displays the sum: 3
variables are required as below:

Number1 Number2 Sum

You can imagine the variables as boxes like this, but in reality they are locations in the
computer’s main memory.

The ‘Box labels’ are known as identifiers. As a programmer you must choose an
appropriate identifier for each variable you use in your program. A valid identifier must
start with a letter and can consist of any combination of letters, numerals and the
underscore character (_), but not spaces.

For ease of understanding by other programmers, (your teacher!) or yourself later on, you
should choose an identifier that explains the purpose of your variable. This is good
practice and very useful when your programs get more complicated. E.g.
NumberOfEntries rather than n5 or number.

NB: Visual Basic is not case-sensitive, so that Number, number, nUMBER, NUMBER are
all equivalent.

Visual requires you to declare what type of data you are going to store in your chosen
variables. Therefore if we want to store whole numbers we need to declare them as
Page 7
Introduction to Programming
Using Visual Basic
integers at the beginning of our program code. VB doesn’t require you to declare at the
beginning of a module, program or function – but it is good practice to do so.

Module  Module1  
 
       Sub  Main()  
 
               Dim  Number1,  Number2,  sum  As  Integer  
 
 
       End  Sub  
 
End  Module  

Note the use of the keyword DIM at the beginning. Then it is the variable names followed
by AS then the type itself.

The Assignment Statement

To store something in a variable you need to use an assignment statement. For example:
Number1 = 8;
This stores the value 8 to the variable Number 1.

The ‘=’ is the assignment operator; the value to the right is what is stored in the variable
that is identified on the left of the assignment operator. It can be read as “becomes equal
to” or “takes the value”.

An assignment statement can also contain an expression on the right side of the ‘=’, which
will be calculated when that statement is executed.

Number1  =  8  
Number2  =  15  
sum  =  Number1  +  Number2  
 

The above statements will result in putting the value 23 into the variable Sum.

Page 8
Introduction to Programming
Using Visual Basic

The Console.Writeline() Statement

If you want to display the contents of a variable, you need to use the Console.Writeline
statement and provide the variable identifier in brackets:
 
Console.WriteLine(Number1)  

Note the difference between displaying the contents of Number1 and displaying the text
string ‘Number1’.

Console.WriteLine("Number1")  

You can combine several variable identifiers and/or messages in one statement. For
example:
 
Console.WriteLine(Number1  &  "  +  "  &  Number2  &  "  =  "  &  sum)  

Note that spaces also need to be added inside the quotes.

The Console.Readline Statement

If you want the user to be able to type in values that are used in the program is running,
you need to use the Console.Readline statement. To store the value typed by the user in
a variable use the Console.Readline statement with the variable identifier before the call:

Number1  =  Console.ReadLine()  
 
To display the sum of two numbers that the user types in, we can write:

Module  Module1  
 
       Sub  Main()  
 
               Dim  Number1,  Number2,  sum  As  Integer  
 
               Number1  =  Console.ReadLine  
               Number2  =  Console.ReadLine  
 
               sum  =  Number1  +  Number2  
 
               Console.WriteLine(sum)  
               Console.Read()  
 
       End  Sub  
 
End  Module  

Page 9
Introduction to Programming
Using Visual Basic

Save the file and run the program. This will produce the required result. However, it is not
very user-friendly: we need to prompt the user for what to do. Add some lines to your
program as follows:

Module  Module1  
 
       Sub  Main()  
 
               Dim  Number1,  Number2,  sum  As  Integer  
 
               Console.Write("Please  enter  in  a  number:  ")  
               Number1  =  Console.ReadLine  
               Console.Write("Please  enter  in  another  number:  ")  
               Number2  =  Console.ReadLine  
 
               sum  =  Number1  +  Number2  
 
               Console.WriteLine(Number1  &  "  +  "  &  Number2  &  "  =  "  &  sum)  
               Console.Read()  
 
       End  Sub  
 
End  Module  

This will produce the following output:

NB:
Writeline without the brackets (parameters) will just output a new line.
Write rather than Writeline will stay on the same line.

The statement
 
Console.WriteLine(Number1  &  "  +  "  &  Number2  &  "  =  "  &  sum)  

Produces the same result as

Page 10
Introduction to Programming
Using Visual Basic

Console.Write(Number1)  
Console.Write("  +  ")  
Console.Write(Number2)  
Console.Write("  =  ")  
Console.Write(sum)  

Although the Read statement exists, its use is very specific as it leaves the Enter character
in the input buffer. If you try it, your program may not operate as you expect.

Page 11
Introduction to Programming
Using Visual Basic

Arithmetic Expressions
We can write more complicated arithmetic expressions, using the following symbols:

Arithmetic Operation Operand data Result data type Example

Operator types
+ Addition Integer, real Integer, real X+Y
- Subtraction Integer, real Integer, real Result – 1
* Multiplication Integer, real Integer, real P * InterestRate
/ Real Division Integer, real Real X/2
DIV Integer division Integer Integer Total DIV UnitSize
MOD Remainder Integer Integer Y MOD 6

NB:
Division using / will produce a result that may not be a whole number. We need to declare
a variable receiving such a result as a Real data type, so that it may have a decimal point
and a fractional part. For more data types, see the next chapter.

Comments
For all of the programs from now onwards you are expected to pseudo-code your work.
This means writing what the code will do in ‘plain English’ rather than writing in Pascal
code straight away.

Pseudo-code/comments also help other people understand the program, and allow you to
add useful notes to aid development of the code and provide basic documentation. The
compiler ignores these, so your application will not take up more space because of
comments.

The structure for comments is as follows – Note the apostrophe at the beginning.

'this  is  a  comment  that  goes  on  for  one  line.  

Page 12
Introduction to Programming
Using Visual Basic

Chapter 3 – Data types

All variables have to be declared before they can be used. The compiler will allocate
memory to each variable depending on what type it is. Visual Basic provides many built-in
types, some of which are listed below. You can also define your own data types, you will
learn about this later.

Variable Declarations - Global

Global variables are variables declared at the beginning of the program and accessible
from anywhere in the program. It is not always desirable to use a global variable as its
values may get changed accidentally if you have multiple functions in your program

Local variables
Rather than declaring variables globally, it is good programming style to declare variables
locally within the block where the variable is going to be used

When you start writing programs with routines – procedures or functions – you should
declare local variables within the routines. Any variable value that is required by another
routine should be passed as a parameter. A routine or subroutine is a subprogram.

Below are some data type declarations.

Integer
This data type supports positive and negative whole numbers. Memory allocated 4
bytes. Range: -2147483648 to 2147483647. Whenever possible you should use Integer
variables rather than Real variables, because they use less memory and the store values
more accurately.

Byte
This data type supports unsigned integers in the range 0 to 255. Memory allocated: 1
byte

Decimal
This data type supports signed numbers with a decimal point and fractional part.
Memory allocated: 16 Bytes. This is a good type to use for currency.

Single/Double
This data type supports floating point numbers. This is similar to decimal but allows
storage of larger fractions.

Char
This is a single character. Memory allocated: 1 byte. You can assign a single character to
a Char variable:

Page 13
Introduction to Programming
Using Visual Basic

Letter1 = “A”;

String
A string is a sequence of characters. A string variable can store up to 231 characters.
However a string constant is limited to 255 characters (more on this later).

“Hello World” Examples of string literals

“012 34£$%^”

“He said If you want to include the quotes in a string literal you need
“”hello” to type two quotes

“ “ This string literal contains a space

“” This string is known as a null string

You can assign a string literal to a string variable:

FirstName = “Thomas”

You can concatenate strings (join one string to the end of another) using the string
operator +

Message = “Hello “ + “World” ‘note the space left after hello

FullName = FirstName + Surname

Boolean
This data type supports just two values: True and False. For example:

Found = False
Finished = True

Memory allocated: 1 byte. Visual Basic represents True as 1 and False as 0 in memory.
Boolean operators are mainly used for selection and iteration in a programming context
(you will learn more about these in the next 2 chapters).

The following Boolean operators can be used in expressions with Boolean variables:

Boolean Logical Explanation Example assuming Value of

Operator operation Found = True example
Finished = False

Page 14
Introduction to Programming
Using Visual Basic
Not Inversion Turns True to Not Finished True
False and vice
versa
And AND Both values Found and False
must be true for finished
the result to be
true
Or Inclusive OR Either or both Found or not True
values must be Finished
true for the result
to be true
Xor Exclusive OR Only one value Found xor False
must be true for not Finished
the result to be
true
The results of a Boolean expression can be assigned to a Boolean variable. For example:
Searching = not Found or not Finished
GiveUp = not Found and Finished

Date
This data type supports dates. Visual Basic stores the date as a real number. The
integral part of the value is the number of days that have passed since 01/01/0001. The
fractional part of the value is the fraction of a (24-hour) day that has elapsed.

You can perform calculations with date variables. If ‘Today’ has today’s DateTime value
stored:

         Dim  Today,  Tomorrow,  Yesterday  As  Date  

 
Today  =  Now()  
Tomorrow  =  Today.AddDays(1)  
 
      Console.WriteLine(Today)  
          Console.WriteLine(Tomorrow)  
 

Page 15
Introduction to Programming
Using Visual Basic

Ordinal data types

Ordinal types include integer, byte, character and Boolean. An ordinal type defines an
ordered set of values. These types are important in later chapters.

Simple types
Simple types include ordinal types, double and Decimal. Later on you will lean about
types that are not simple types, known as structured types. An example of a structured
type is the String data type.

Constants
If you want to use values that will not change throughout the program, we can declare
them as constants rather than variables at the beginning of the program in the const
section, where you also initialise them.

Constants are declared

Module  Module1  
  before variables.
       Const  VatRate  =  0.175  
 
       Sub  Main()   Rounds to 2 decimal places –
  indicated by “N2”
               Dim  cost,  tax  As  Decimal  
 
               Console.WriteLine("Enter  the  cost  of  goods:  ")  
               cost  =  Console.ReadLine  
               tax  =  cost  *  VatRate  
               Console.WriteLine("The  VAT  is  "  &  tax.ToString("N2"))  
               Console.Read()  
 
       End  Sub  
 
End  Module  

Advantages of using named constants

…Rather than variables:
• The value of a constant cannot be accidentally changed during the running of the
program.
• The program runs faster because all references to the constant are replaced by its
value at compile time, whereas a variable’s value has to be retrieved from main
memory at run time.

…Rather than the actual value:

• If the value needs to be changed at a later date, such as the VAT rate changes,
only the constant declaration needs to be changed.

Page 16
Introduction to Programming
Using Visual Basic
• Expressions using the value are much easier to understand if a carefully chosen
identifier represents the value.

Page 17
Introduction to Programming
Using Visual Basic

Chapter 4 – Selection
When you are writing programs, you will often want a computer to take different routes
through the program depending on various conditions. For this you can use one of the
following structured statements Visual Basic provides:

If ... then
If ... then ... else
Select case

(structured statements are built from other statements, they are normally made when you
want to execute other statements sequentially, conditionally, or repeatedly.)

If … Then
When you want a program to execute a statement only if a certain condition is met, you
use:

If BooleanExpression then statement

A Boolean expression returns a Boolean value True or False (See last chapter for
Boolean data type). If the BooleanExpression is true the statement after then is executed.

Examples of Boolean expressions:

Age > 18
(Number > 10) and (Number <=25)

You can use the following comparison operators:

= equal to
<> not equal to
> greater than
< less than
>= greater than or equal to
<= less than or equal to

Page 18
Introduction to Programming
Using Visual Basic

Example of an if … then statement:

Dim  number,  sum  As  Integer  

 
          number  =  1  
 
          If  number  >  0  Then  
                sum  =  sum  +  number  
           End  If  

If … Then … Else
When you want your program to do one statement if a certain condition is met, and
another statement if the condition is not met, you need to use:

If BooleanExpression Then statement1 else statement2

Example of an if … then … else statement:

 
         If  number  <  0  Then  
                       Console.WriteLine("This  is  a  negative  number")  
           Else  
                       Console.WriteLine("This  is  a  positive  number")  
           End  If  

Nested If statements
The statement in a then and/or else part of an if statement can itself be an if statement.

Example:
If  (letter  >=  "A"  And  letter  <=  "Z")  Or  (letter  >=  "a"  And  letter  <=  "z")  
Then  
Console.WriteLine("Letter")  
Else  
If  (letter  >=  "0"  And  letter  <=  "9")  Then  
            Console.WriteLine("numeral")  
        Else  
            Console.WriteLine("special  character")  
          End  If  
End  If  

Indentation
With the introduction of structured statements, you need to take care over the layout of
your code, to keep it easy to find possible errors. Visual Basic does not mind where you

Page 19
Introduction to Programming
Using Visual Basic
put white space (spaces, indents, new lines). However, to follow the code, especially
during error-finding sessions you will appreciate clearly laid out code. Also, to get full
marks from your teacher, you are expected to lay your code out using the following
convention:

• Every statement on a new line.

• An IF always must be matched by an End If.

Because of the nature of the Visual Express IDE however it automatically indents code for
you – but even if it doesn’t make sure you are indenting your work after each IF statement.

Page 20
Introduction to Programming
Using Visual Basic

• Split if statements and indent in this way:

If BooleanExpression Note that there must be
Then statement1 no semicolon here. This
Else statement2 is a common syntax error.

End If

Select Case
Nested if statements can get very complicated and sometimes it is easier to use a case
statement:

Select Case OrdinalExpression

Case <item or list>
Statement1
...
Case <itemn or listn>
Statementn
Case else
Statement
End Select

The value of the ordinal expression (see Chapter 3, Ordinal Type) will determine which
statement is executed. Each Case must be a constant, a list of constants or a subrange.
Each value in the case must be unique in the case statement, and subranges and lists
must not overlap. See examples below.

If Month is an integer variable:

Select  Case  month  

                       Case  1,  3,  5,  7,  8,  10,  12  
                               NoOfDays  =  31  
                       Case  4,  6,  9,  11  
                               NoOfDays  =  30  
                       Case  2  
                               NoOfDays  =  28  
                       Case  Else  
                               Console.WriteLine("Not  a  month")  
        End  Select  

Page 21
Introduction to Programming
Using Visual Basic
If Ch is of type Char:

               Select  Case  letter  

                       Case  "A"  To  "Z",  "a"  To  "z"  
                               Console.WriteLine("Letter")  
                       Case  "0"  To  "9"  
                               Console.WriteLine("Number")  
                       Case  Else  
                               Console.WriteLine("Special  Character")  
               End  Select  

Page 22
Introduction to Programming
Using Visual Basic

Chapter 5 – Iteration (repetition)

We often want computers to repeat some process several times. This is called iteration.
In Visual Basic there are 3 different structures to repeat a set of statements:

Definite Iteration (when you know before entering the loop how often you want to repeat)
For loop

Indefinite Iteration ( when you do not know beforehand how often you want to repeat)
Do Until loop
Do While loop

For loop

For Counter = StartValue to EndValue step StepAmount

Statement;
Next Counter

Counter is called the control variable and must be declared as an ordinal type, often
integer (see chapter 3).
StartValue & EndValue must be expressions of the same type as Counter.

Examples:

For  i  =  Counter  To  10  Step  1  

                       Console.WriteLine("This  is  a  line")  
           Next  Counter  
 
        For  Counter  =  10  To  1  Step  -­‐1  
                       Console.WriteLine(Counter)  
        Next  Counter  

Do Loop

Do Until BooleanExpression
Statement1;
Statement2;
:
:
Loop;

Page 23
Introduction to Programming
Using Visual Basic
The statements enclosed by repeat and until are executed again and again until the
BooleanExpression is True.

Note: The statement sequence is executed at least once, even if BooleanExpression is

already True.

Example:

               Do  Until  name  =  "XXX"  

                       Console.Write("Enter  a  name  -­‐  XXX  to  finish:  ")  
                       name  =  Console.ReadLine()  
               Loop  

You may wish to know how many times the loop was repeated:

               Do  Until  number  =  0  

                       Console.Write("Enter  a  number  -­‐  0  to  finish:  ")  
                       number  =  Console.ReadLine()  
                       count  =  count  +  1  
               Loop  

If we want to add up all the numbers the user types in, we need to keep a running total:
 
               count  =  0      'Make  sure  you  initialise  variables  before  using  them  
               Runningtotal  =  0  
 
               Do  Until  number  =  0  
                       Console.Write("Enter  a  number  -­‐  0  to  finish:  ")  
                       number  =  Console.ReadLine()  
                       count  =  count  +  1  
                       Runningtotal  =  Runningtotal  +  number  
               Loop  
 
You can also change the format of the above slightly to have the control condition being
checked at the end of the loop – for example

Do    
          Console.Write("Enter  a  number  -­‐  0  to  finish:  ")  
              number  =  Console.ReadLine()  
                count  =  count  +  1  
                     Runningtotal  =  Runningtotal  +  number  
        Loop  Until  number  =  0  
 
The difference here is that putting the check at the end of the statement means that the
loop will execute at least once.

Page 24
Introduction to Programming
Using Visual Basic

Do While

The Do While loop is exactly the same as the Do Until loop except that the former checks
that a condition is positive to continue looping – while the latter checks that a condition is
negative to continue looping

Page 25
Introduction to Programming
Using Visual Basic

Chapter 6 – Arrays
High-level languages provide programmers with a variety of ways of organising data.
There are not only simple data types, but also data structures.

A data structure is a data type composed of a number of elements of one or more data
types. A data structure allows a variable to be declared of that type so that a number of
data items can be stored and processed as a single set.

An array is an ordered set of data items of the same type grouped together using a single
identifier. Arrays may have many dimensions but higher dimensions can get difficult to
imagine and are not needed for AS or A-level. It is sufficient to be able to use one-
dimensional arrays (also known as linear lists) and two-dimensional arrays (also known as
tables).

The array’s identifier and an index (or subscript) for each of the array’s dimensions are
used to refer to each of the array’s data items.

Without data structures, if we want to store several values in separate variables and
process them in a similar manner, this could result in very repetitive code. For example, to
store 5 student’s names would mean declaring 5 string variables for their names:

Dim Name1, Name2, Name3, Name4, Name5 As String;

Name1 Fred Name2 Jack Name3 Anna Name4 Sue Name5 Roy

This is still manageable but what if we needed to store several hundred students’ names?

Page 26
Introduction to Programming
Using Visual Basic

One-Dimensional Arrays
If we declare an array:
All elements of
Dim  Name(0  To  4)  As  String   an array are of
the same type
Name(0) Fred
Array Range of
Name(1) Jack
identifier index
Name(2) Anna
Name(3) Sue
Name(4) Roy
We can refer to a particular element of this array: Array Index or
identifier subscript
Console.WriteLine(Name(2))  

Would display the name Anna. In general, to refer to the ith element you write Name(i)

This is particularly powerful when combined with iteration statements:

To read in five names into the array we can write:

               For  i  =  0  To  4  Step  1  

                       Console.Write("Please  Enter  in  a  location  "  &  i  &  ":  ")  
                       Location(i)  =  Console.ReadLine()  
               Next  

We can easily display these in reverse order:

               For  i  =  4  To  0  Step  -­‐1  

                       Console.WriteLine(Location(i))  
               Next  

In general, we declare a one-dimensional array using the format:

Dim identifier (range) As of DataType

Range must be of ordinal type (see chapter 3).

Two-Dimensional Arrays
Suppose we want to store a student’s timetable:

Monday Tuesday Wednesday Thursday Friday

Lesson 1 Maths Physics Computing Electronics Maths
Lesson 2 Physics Physics Electronics Maths Physics
Lesson 3 Lunch Lunch Lunch Lunch Lunch
Lesson 4 Computing Electronics Maths Computing Computing

Page 27
Introduction to Programming
Using Visual Basic

We can declare a two-dimensional array:

Dim  timtable(0  To  3,  0  To  4)  As  String  

The dimensions of an array are neutral. They do not represent anything until we decide
what each dimension will represent, declaring an appropriate range in the corresponding
index. To refer to the 4th lesson on a Tuesday, we could therefore write:
Timetable(4,2)
To display all lessons for a Wednesday (the 3rd day of the week):

               day  =  2  
               For  lesson  =  0  To  3  Step  1  
                       Console.WriteLine(timetable(lesson,  day))  
               Next  lesson  

To display the whole timetable:

               For  lesson  =  0  To  3  Step  1  

                       For  day  =  0  To  4  Step  1  
                               Console.WriteLine(timetable(lesson,  day))  
                       Next  
               Next  

Enumerated Types
An enumerated type defines an ordered set of values. Each value is given an ordinal
value, starting at zero. Members of an enumerated type can be used as loop control
variables, in case statements and as array subscripts.

Module  Module1  
 
       Dim  x,  y  As  Integer  
       Enum  Days  
               Sun  
               Mon  
               Tue  
               Wed  
               Thu  
               Fri  
               Sat  
       End  Enum  
 
       Sub  Main()  
               x  =  Days.Wed  
               y  =  Days.Sun  

Page 28
Introduction to Programming
Using Visual Basic
               Console.WriteLine("Wednesday  =  {0}",  x)  
               Console.WriteLine("Sunday  =  {0}",  y)  
               Console.ReadLine()  
       End  Sub  
 
End  Module  

Sets
A set is a collection of values of the same ordinal type. The values of a set have no
associated order

Module  Module1  
 
       Sub  Main()  
               Dim  Set1,  Set2,  Set3  As  New  ArrayList  
               Dim  InitialSet()  =  {3,  4,  5}  
               Set1.AddRange(InitialSet)  
               Set1.Add(2)  
               Set1.Add(7)  
 
               If  Set1.Contains(7)  Then  
                       Console.WriteLine("Set  contains  7")  
               End  If  
 
               Console.ReadLine()  
 
 
       End  Sub  
 
End  Module  

Page 29
Introduction to Programming
Using Visual Basic

Chapter 7 – Functions
Built-in Functions
A function is a routine, a self-contained statement block that returns a value when it
executes. Pascal provides many ready-to-use functions. Here are just a few:

Function Parameter(s) Result type Description

identifier (arguments)
Math.Round X: Decimal / Integer Returns the value of X Rounded to the
double nearest whole number
Math.Truncate X: Decimal / Integer Truncates a real number to an integer
Double
ChrW X: byte Char Returns the character for a specified ASCII
code value X
Asc X: any Integer Returns the ordinal value of an ordinal type
ordinal type expression such as the ASCII code for a
character
Len S: String Integer Returns the number of characters in string
S
InStr S: String Integer Returns the index value of the first
Sub: String character in substring Sub that occurs in
the string S
UCase S: String String Returns a copy of string S in upper case
LCase S: String String Converts string S to lower case
Now - Date Returns the current local date as a Date
value
CStr Date String Returns the string equivalent of D
CDate S: String Date If S contains only two numbers, it is
e.g. 12/2/03 interpreted as a date in the current year.
Left S: String String Returns the substring of length L that
L: Integer appears at the start of string S
Right S: String String Returns the substring of length L that
L: Integer appears at the end of string S

To use any of these functions you use its identifier and provide the necessary arguments
in brackets. This is called the function call. A function call returns a value, which can be
used in expressions in assignments and comparison operations.

Page 30
Introduction to Programming
Using Visual Basic
For example, to assign the square root of a number to Square:
Example
length = Len (astring)
You must make sure that you provide the correct data types.
Function calls cannot appear on the left side of an assignment statement.

Random Numbers
We often want to simulate events where random numbers occur, such as throwing a die.
Computers can only follow programs, that means sequences of predetermined statements,
so they cannot produce truly random numbers. Pascal, like most high-level languages,
provides us with a pseudo-random number generator to get over this problem:

R = Int(Rnd() * 100) + 1
Returns an integer between 0 and 100

When you initialise the random number generator it uses an integer obtained from the
system clock, so you are highly likely to obtain the same sequence of numbers on any two
runs. To prevent this from happening (the compiler will use a different value each time),
add the statement Randomize() before you want to use the random function:

Page 31
Introduction to Programming
Using Visual Basic
Module  Module1  
 
       Sub  Main()  
               Dim  number  As  Integer  
 
               Randomize()          'should  only  be  executed  once  to  initiate  random  
                                             number  generator  
 
               number  =  Int(Rnd()  *  6)  'generates  random  number  0-­‐5  
               number  =  number  +  1          '  add  1  to  get  anumber  1-­‐6  
 
               Console.WriteLine(number)  
               Console.ReadLine()  
 
       End  Sub  
 
End  Module  

User-defined functions
Dev-Pascal may not provide you with all the functions you may wish to use. You can
declare your own functions and then call them in expressions just like built-in functions.
They are known as user-defined, but in this case the user is the programmer using the
programming language, not the end-user of the program.

Module  Module1  
 
       Function  Initial(ByVal  s  As  String)  As  String  
               Dim  ret  As  String  
  Declaration of the parameter S,
               ret  =  Left(s,  1)   an internal variable to receive the
               ret  =  UCase(ret)  
value passed to the function
  Data type of
               Return  ret   return value
 
       End  Function  
  In Visual Basic
  Functions can be
       Sub  Main()   declared anywhere
  although it is good
               Dim  name  As  String   practice to declare
 
them before the main
               Console.Write("Type  in  a  name:  ")  
               name  =  Console.ReadLine()   program.
 
               Console.WriteLine("Initial  =  "  &  Initial(name))  
 
               Console.ReadLine()  

Page 32
Introduction to Programming
Using Visual Basic
 
       End  Sub  
 
End  Module  

Local Variables
Sometimes you need variables to store values temporarily. Rather than declaring
variables that are available throughout the program (global variables), it is good
programming style and less error-prone to declare variables locally. They can only be
used in the function in which they are declared and we say that they have local scope.

Module  Module1  
  Global Variable
       Dim  number  As  Integer  
 
       Function  Factorial(ByVal  N  As  Integer)  As  Integer  
 
               Dim  count,  product  As  Integer  
  It is good practice
               product  =  1   to declare local
 
               For  count  =  1  To  N  Step  1   variables after the
                       product  =  product  *  count   function heading.
               Next  count  
 
               Return  product  
 
       End  Function  
 
 
       Sub  Main()  
 
               Console.Write("Type  in  a  number  between  1  and  10:  ")  
               number  =  Console.ReadLine()  
               Console.WriteLine("return  from  function:  "  &  Factorial(number))  
               Console.ReadLine()  
 
       End  Sub  
 
 
End  Module  
Page 33
Introduction to Programming
Using Visual Basic

Chapter 8 – Procedures
A routine is a self-contained statement block that can be called from different locations in a
program. A function is a routine that returns a value in its name when it executes, and so
a function call is used as part of an expression. A procedure is a routine that does not
return a value in this way and a procedure call is treated like a statement. Dev-Pascal
provides many built-in procedures, for example Readln and Writeln. However, we can
also write our own procedures.

A good procedure declaration has the form

Sub ProcedureName(ParameterList)
LocalDeclarations;
Statements
End Sub {of procedure}

During the development of a programmed solution to a problem we may write down an

algorithm or stepwise strategy. Each step can be used as a procedure call, and the
detailed processing of the solution is performed in the procedure. This makes the main
program body easy to understand as the procedure calls reflect the algorithm.

Worked Example:
Write a program which would display a pyramid of ‘*’:
*
***
*****
*******
*********
***********

The solution to this problem can be broken down into the following steps:
Initialize number of spaces and stars
Repeat
Output leading spaces
Output line of stars
Adjust number of spaces and stars
Until number of stars is the number required

Page 34
Introduction to Programming
Using Visual Basic
Module  Module1  
 
       Dim  MaxNoOfStars,  NoOfStars,  NoOfSpaces  As  Integer  
 
       Sub  InitialiseNoOfSpacesAndStars()  
 
               Console.Write("How  many  stars  should  be  at  the  base?  ")  
               MaxNoOfStars  =  Console.ReadLine()  
               NoOfSpaces  =  MaxNoOfStars  /  2      'enough  space  to  accomodate  base  
               NoOfStars  =  1                                      '  Tip  has  one  star  
 
       End  Sub  
 
       Sub  OutputLeadingSpaces()  
 
               Dim  count  As  Integer  
 
               For  count  =  1  To  NoOfSpaces  Step  1  
                       Console.Write("  ")                    '  No  new  line  required  
               Next  count  
 
       End  Sub  
 
       Sub  OutputLineOfStars()  
 
               Dim  count  As  Integer  
 
               For  count  =  1  To  NoOfStars  Step  1  
                       Console.Write("*")  
               Next  count  
               Console.WriteLine()                          '  Move  to  next  line  
 
       End  Sub  
 
       Sub  AdjustNoOfSpacesAndStars()  
 
               NoOfSpaces  =  NoOfSpaces  -­‐  1  
               NoOfStars  =  NoOfStars  +  2  
 
       End  Sub  
 
       '  Main  program  starts  here  
 
       Sub  Main()  
 
               InitialiseNoOfSpacesAndStars()  
 
               Do  
                       OutputLeadingSpaces()  
                       OutputLineOfStars()  
                       AdjustNoOfSpacesAndStars()  

Page 35
Introduction to Programming
Using Visual Basic
 
               Loop  Until  NoOfStars  >  MaxNoOfStars  
 
               Console.ReadLine()  
 
       End  Sub  
 
End  Module  

Parameters
Those routines that do not rely on global variables are self-contained and easily reused in
other programs. They also make it easier to find programming errors (logic errors) as
each routine can be tested separately and will not interfere with other routines. Values
required by routines are best passed to the routine by means of parameters. Routines can
have any number of parameters, but the order must be the same in the routine declaration
and the routine call.

The worked example from overleaf could be written:

Module  Module1  
 
       Dim  MaxNoOfStars,  NoOfStars,  NoOfSpaces  As  Integer  
 
       Sub  Initialise(ByRef  Spaces  As  Integer,  ByRef  Stars  As  Integer,  
                                     ByRef  Max  As  Integer)  
 
               Console.Write("How  many  stars  should  be  at  the  base?  ")  
               Max  =  Console.ReadLine()  
               Spaces  =  MaxNoOfStars  /  2      'enough  space  to  accomodate  base  
               Stars  =  1                                      '  Tip  has  one  star  
 
       End  Sub  
 
       Sub  OutputLeadingSpaces(ByVal  Spaces  As  Integer)  
 
               Dim  count  As  Integer  
 
               For  count  =  1  To  Spaces  Step  1  
                       Console.Write("  ")                    '  No  new  line  required  
               Next  count  
 
       End  Sub  
 
       Sub  OutputLineOfStars(ByVal  Stars  As  Integer)  
 
               Dim  count  As  Integer  
 
               For  count  =  1  To  Stars  Step  1  

Page 36
Introduction to Programming
Using Visual Basic
                       Console.Write("*")  
               Next  count  
               Console.WriteLine()                          '  Move  to  next  line  
 
       End  Sub  
 
       Sub  Adjust(ByRef  Spaces  As  Integer,  ByRef  Stars  As  Integer)  
 
               Spaces  =  Spaces  -­‐  1  
               Stars  =  Stars  +  2  
 
       End  Sub  
 
       '  Main  program  starts  here  
 
       Sub  Main()  
 
               InitialiseNoOfSpacesAndStars(NoOfSpaces,  NoOfStars,  MaxNoOfStars)  
 
               Do  
                       OutputLeadingSpaces(NoOfSpaces)  
                       OutputLineOfStars(NoOfStars)  
                       AdjustNoOfSpacesAndStars(NoOfSpaces,  NoOfStars)  
 
               Loop  Until  NoOfStars  >  MaxNoOfStars  
 
               Console.ReadLine()  
 
       End  Sub  
 
End  Module  
 
 
 
With careful choice of identifiers the main program body is easy to understand. The
routines are now self-contained and could even be put into a separate unit.

Look at the procedure headings again:

       Sub  Initialise(ByRef  Spaces  As  Integer,  ByRef  Stars  As  Integer,  

                                     ByRef  Max  As  Integer)  
Sub  OutputLeadingSpaces(ByVal  Spaces  As  Integer)  
Sub  OutputLineOfStars(ByVal  Stars  As  Integer)  
Sub  Adjust(ByRef  Spaces  As  Integer,  ByRef  Stars  As  Integer)  

Procedures Initialise and Adjust differ from OutputLeadingSpaces and OutputLineOfStars.

Parameters that pass a value back to the main program from the procedure must be
declared as variable parameters with the keyword ByRef in front of them, whereas those
parameters that only pass a value into the procedure are known as value parameters and
have ByVal in front of them.

Page 37
Introduction to Programming
Using Visual Basic

Value and Variable Parameters

Value parameters are passed by value, while variable parameters are passed by
reference.

If you pass a variable as a value parameter, the procedure or function copies the value of
the calling program’s variable to the procedure’s parameter. Changes made to the copy
have no effect on the original variable and are lost when program execution returns to the
calling program.

If a parameter is passed as a variable parameter, a pointer referring to the address in

main memory of the original variable is passed. Changes made to the parameter within
the body of the routine are made to the original variable, so in effect the new value is
passed back to the program where the routine was called.

Page 38
Introduction to Programming
Using Visual Basic

Chapter 9 – Records
A record data type is a structured type. A record is a collection of variables, which need
not all be of the same type and with no associated ordering. The variables can be
regarded as fields of the record. Before we can use records we need to define what type
of record we want, that is, what fields our record is going to have and what type of data we
are going to store in them.

The syntax of a record type declaration is:

Structure Identifier = record

Dim Fieldlist1 As type1;
Dim Fieldlist2 As type2;
.. ..
Dim fildlistn As typen
End Structure {of record type declaration}

It is good practice to declare Type declarations global declarations. Once the type is
declared we can declare variables of this new type just as we declared variables using
types from chapter 3. A useful naming convention is to prefix a type with T, so a record
type to store student details would be called TStudent:

       Structure  TStudent  
               Dim  FirstName  As  String  
               Dim  Surname  As  String  
               Dim  DepositPaid  As  Decimal  
               Dim  DateOfBirth  As  Date  
       End  Structure  

Declare record variables of type Tstudent:

Dim Student1, Student2 As TStudent

Now we can access individual fields of this record variable:

Record variable name Field name

Student1.FirstName = “Fred”
Or Student1.Surname = Console.ReadLine()

Page 39
Introduction to Programming
Using Visual Basic
Arrays of Records
Just as with standard variables, when we want to work with a large collection it is better to
access them by a collective name. Rather than declaring separate variables Student1,
Student2, Student3, ... we can declare an array of student records, using the record type
previously defined

Dim  Student(0  To  100)  As  TStudent  

To assign a value to the first name of the 5th student in the array:

Student(5).FirstName = “Jack”

Array Record Field

name subscript name

Now we can use a for loop to access all the students’ details:

               For  ptr  =  0  To  99  Step  1  

                       Console.WriteLine(Student(ptr).FirstName,Student(ptr).Surname  
               Next  ptr  
 

Page 40
Introduction to Programming
Using Visual Basic

Chapter 10 – Files
So far, we have lost any data the user typed in during the running of the program. If we
want to keep data from one time of running a program to the next, we need to save it in a
computer file. A file is a sequence of elements of the same type.

Steps to use a file:

• Open file for reading FileOpen (<num>,<path>,<OpenMode>)
• Read from the file: line = LineInput(<num>)
• Or write to the file: PrintLine (<num>, <string>)
• Close the file: FileClose (<num>)

Text Files
A text file represents a file containing a sequence of characters formatted into lines, where
each line is terminated by an end-of-line marker. A text file can be opened and read in a
text editor.

To create and write to a text file ‘Test.txt’ To read from the text file ‘Test.txt’
path  =  "d:\computing   path  =  "d:\computing  
resources\visual  basic\test.txt"   resources\visual  basic\test.txt"  
                   
FileOpen(1,  path,  OpenMode.Output)   FileOpen(1,  path,  OpenMode.Input)  
line  =  "How  are  you"    
PrintLine(1,  line)   Do  While  Not  EOF(1)  
FileClose(1)            line  =  LineInput(1)  
         Console.WriteLine(line)  
Loop  
 
FileClose(1)  

Note: You cannot just delete a record in a serial or sequential file. You need to copy all
records to a new file, omitting the specified record.

Note: you cannot insert a record in a serial or sequential file. You need to copy records
from the original file to a new file, inserting the new record in the correct place

Page 41
Introduction to Programming
Using Visual Basic
Direct Access Files
The disadvantages with serial and sequential files are that you must start a search for a
record from the beginning of the file, and adding or deleting records means writing all the
records to a new file.

Direct access files (also known as random access files) do not store records one after the
other but each record is stored at an address (or position relative to the start of the file)
calculated from the value of its key field. This means a record can be independently
accessed using its address. Since Pascal only allows fixed-length records, we can update
in situ (overwrite an existing record with an updated record) without disrupting the file.

For example, if we wish to store details about stock items and these each have a unique
item code (or primary key) between 0 and 1000, and then this item code could be used
directly as the unique record address.

Module  Module1  
 
       Structure  TStockItem  
               Dim  StockItemCode  As  Integer  
               <VBFixedString(20)>  Dim  Description  As  String  
               Dim  UnitPrice  As  Decimal  
               Dim  NoInStock  As  Integer  
       End  Structure  
 
       Sub  Main()  
 
               Dim  StockItem  As  TStockItem  
               Dim  path  As  String  
               Dim  Position  As  Integer  
 
               path  =  "d:\computing  resources\Visual  Basic\stock.dat"  
 
               FileOpen(1,  path,  OpenMode.Random,  OpenAccess.Default,  
                                 OpenShare.Default,  Len(StockItem))  
 
               Console.Write("Enter  in  a  Description:  (X  to  finish)  ")  
               StockItem.Description  =  Console.ReadLine()  
 
               Do  While  StockItem.Description  <>  "X"  
                       Console.Write("Enter  Stock  item  code  (0  to  1000):  ")  
                       Do  
                               StockItem.StockItemCode  =  Console.ReadLine()  
                       Loop  Until  StockItem.StockItemCode  >=  0  
 
                       Console.Write("Enter  Unit  Price:  ")  
                       StockItem.UnitPrice  =  Console.ReadLine()  
                       Console.Write("Enter  Number  of  items  in  stock:  ")  
                       StockItem.NoInStock  =  Console.ReadLine()  

Page 42
Introduction to Programming
Using Visual Basic
                       Position  =  StockItem.StockItemCode  
 
                       'Seek(1,  Position)  
                       FilePut(1,  StockItem,  Position)  
 
                       Console.Write("Enter  in  a  Description:  (X  to  finish)  ")  
                       StockItem.Description  =  Console.ReadLine()  
               Loop  
 
               FileClose(1)  
 
       End  Sub  
 
End  Module  
 

Often, the primary key for a set of records may be in a range not directly suitable as record
addresses. For example, if the stock item codes were in the range 1000 to 9999, the first
999 record spaces in the file would never be used, so wasting a lot of disk space. In such
a case, the primary key could be used in a calculation to produce a more suitable address.
Such a calculation is called a hashing algorithm or hashing function. The primary key
may not be numerical, again making it necessary to produce an address through some
calculation on the primary key. It is important to design a hashing algorithm in such a way
that it will produce the required range of record addresses, gives a good spread of
addresses and minimises the number of different record keys that will produce the same
record address (known as a collision or synonym). If we know that there will at most be
900 different stock items and the stock item codes are in the range 1000 to 9999, we might
wish to generate addresses in the range 0 to 999. This could be done by taking the
remainder after dividing the stock item code by 1000. Below is the function that could be
called to give Position a valid address:

       Function  Hash(ByVal  code  As  Integer)  As  Integer  

               Return  code  Mod  1000  
       End  Function  

We can also read an existing record by calculating its address using the same hashing
function.

If a hashing function might produce synonyms, the program needs to check that the record
space is vacant before writing a record at a given address. Similarly, when reading a
record from a given address, the program needs to check that it is the required record.
Provision can be made for synonyms by storing subsequent records that hash to the same
address in the next free record space, wrapping to the beginning of the file when the end
of the file has been reached.

Page 43