6. Code

6.1 Variables

y= mx + c

For example, the value of the variable "intN" is calculated by adding the values of the variable "intX" and a constant, 150:

IntN = intX + 150

6.1.1 Declaring Variables
It is necessary to declare a variable before it is used. This tells Visual Basic that you intend to use the variable's symbol to reference some data. Even if you do not explicitly declare a variable before use, Visual Basic will make a judgement about the variable when it compiles you program code and attempt to declare it itself.

Occasionally, Visual Basic may declare a variable incorrectly because it uses your program code in context to 'predict' what Type the variable should be. If this happens, you may get strange conversion errors occurring, so it is advised that all variables are expressly declared.

To make sure that Visual Basic doesn't try to declare variables itself (say, if you've mis-spelled a variable which Visual Basic thinks is a new one), type "Option Explicit" at the top of the code window in each module (see later).

6.1.1.1 Standard Types
When declaring and using variables in Visual Basic, you must specify what Data Type you want them to be. A variable must be declared so that Visual Basic can decide how much memory to allocate for storage of the variable's data. A Boolean type (Yes/No) variable only requires 1 bit, whereas an Integer (-32768 to 32767) requires 2 bytes.

Even if you don't explicitly say what type you want the variable to be, Visual Basic defaults to a Variant type - so you have implicitly declared it as a Variant. A Variant is a special data type that is capable of storing all other kinds of data. Unfortunately, in order to do this, it must be allocated a large area of memory.

There are several standard Data Types in Visual Basic, but you can also create custom Data Types. The standard Data Types are:

Dim MyVariable As DataType
e.g.        Dim strName As String
e.g.        Dim blnFound As Boolean

Scope Type NewTypeName
    TypeVariable1 As Type
    --etc--
    TypeVariableN As Type
End Type

e.g.	
Private Type Co_Employee
    Name As String
    JobTitle As String
    Pay As Single
End Type

Private Type Co_Employee
    Name As String
    JobTitle As String
    Pay As Single
End Type

Dim Dave As Co_Employee
Dim Cedric As Co_Employee

Private Sub Form_Load()
    Dave.Name = "Dave Smith"
    Dave.JobTitle = "Internal Affairs"
    Dave.Pay = 2015.12

    Cedric.Name = "Cedric Jones"
    Cedric.JobTitle = "Accounts"
    Cedric.Pay = 1756.52
End Sub

For example:
Dim lngVals(10) As Long
Dim lngUnit() as Long

ReDim lngUnit(0 to 15) As Long

ReDim Preserve lngUnit(0 to 20) As Long

6.1.2.2 Multiple dimensions
A variable array can have several (up to 60) dimensions. For example, if you were developing a simple Chess game, you might want to store the board layout in a two-dimensional array of strings. Each string is either blank (indicating there is no piece on that square) or contains the name of a chess piece:

Dim strBoard (8, 8) As String

strBoard(1, 1) = "White Rook"
strBoard(1, 2) = "White Knight"
--etc--
strBoard(8, 8) = "Black Rook"

strUser(4) = "Bob"

For lngBrdY = 1 To 8
    For lngBrdX = 1 To 8
        lngSquareNumber = (lngBrdY - 1) * 8 + lngBrdX
        Label1(lngSquareNumber).Caption = strBoard(lngBrdX, lngBrdY)
    Next lngBrdX
Next lngBrdX

6.1.3 Collections
A collection in Visual Basic works in a similar way to an array, except that a collection does not exist as a variable - it is an object. When you define a collection, remember that you are creating an object and therefore you can't simply assign a value to it, as you can with a variable. You have to use the object's methods and/or properties to manipulate the contents of the collection.

One of the main uses of collections is as a means of passing lists of data between methods. For example returning a list of names from a function.

6.1.3.1 Dimensioning the Collection
A collection is declared in a similar way to a variable; there is the "Dim" keyword, an identifier and a type assignment. One difference, however, is that a collection object is declared as an instance of the original object and as such has to be set to reference that original object. There are two ways of doing this:

1. Declare the identifier, then set the identifier to reference a new instance (copy of) of the collection object:

Dim colNames As Collection
Set colNames = New Collection

Dim colNames As New Collection

Private Function GetNames() As Collection   ' Cannot use "New"
    Dim colN As New Collection                  ' Use a local collection to make a new instance of collection object
    colN.Add "John"                             ' Add a name to the "colN" collection
    colN.Add "Paul"                             ' Add a name to the "colN" collection
    colN.Add "George"                           ' Add a name to the "colN" collection
    colN.Add "Ringo"                            ' Add a name to the "colN" collection
    Set GetNames = colN                         ' Set the returned collection to the local collection
                                                ' This forces the same instance to exist as both "colN" and "GetNames"
End Function

In order to use this function, you would need a collection for the returned data to be stored in:

Dim colC As New Collection
Set colC = GetNames()

6.1.3.3 Adding to and Clearing a Collection
As mentioned earlier, a collection is an object. It therefore has properties and methods that you can call. Once a collection has been initialised (by declaring it), it can then have entries added to it. This is done by invoking the "Add" method with a parameter as follows:

colC.Add "My new item"

' Format is: MyCollection.Add Item, Key, BeforeKey, AfterKey
colC.Add "First Entry", "#1"               ' Key is "#1"
colC.Add "Third Entry", "#3", ,  "#1"      ' Key is "#3", inserted after the item with key "#1"
colC.Add "Second Entry", "#2", "#3"        ' Key is "#2", inserted before the item with key "#3"

colC.Clear

6.1.3.4 Referencing Items in a Collection
Once you have your collection, items within it can be referenced by their index or their key. The index is equivalent to their numerical position within the collection and the key is the text String that you specified when the item was added to the collection:

strName = colC.Item(5)       ' Get the 6th item in the collection (items start at 0!)
strName = colC.Item("#1")    ' Get the item whose key is "#1"

For n = 0 to colC.Count - 1
    If colC.Item(n) = "" Then strEmpty = "Empty entry found"
Next n

6.1.4.1 Procedure Level
When a variable is only required for the duration of a Method (such as a Sub or Function) it can be declared inside the Method. This variable is then only visible within this Method. Any attempt to access it in the rest of the code will either give an error or cause a new (and totally different) variable to be created, depending on your project settings (see "Option Explicit").

Example:

Private Sub Command1_Click()
    Dim strName As String
    strName = "Dave"
End Sub

Private Sub Command2_Click()
    Label1.Caption = strName
End Sub

Note that if "Command2" had declared a variable called "strName", this would be a totally different variable to the one in "Command1" and would still have been initialised as a blank string.

6.1.4.2 Module Level
In order for this code to work as intended, the Variable declaration for "strName" should be moved outside of any procedures, to the top of the code (in the Code View Window, this appears as "(General)" "(Declarations)" in the combo boxes at the top). This is now a Module-Level declaration. The variable is visible to all Methods within the same Module (a Module can be the code behind a Form or the code in a Code Module, Class Module etc). The code should now look like this:

Dim strName As String

Private Sub Command1_Click()
    strName = "Dave"
End Sub

Private Sub Command2_Click()
    Label1.Caption = strName
End Sub

Public strName As String

Private Sub Command1_Click()
    strName = "Dave"
End Sub

Private Sub Command2_Click()
    Label1.Caption = strName
End Sub

If the variable is declared within a standard code module, it is always available and since the code module itself is not an object the variable can be referenced directly.

In a standard Code Module:

Public g_strPath As String

Private Sub Command1_Click()
    Text1.Text = g_strPath
End Sub

Example:

Dim lngA As Long
Dim strA As String
lngA = 250*5
strA = lngA

Dim lngA As Long
Dim strA As String
lngA = 250*5
strA = CStr(lngA)

Dim strA As String
Dim strB As String
strA = Text1.Text      ' eg Text1 = "25"
strB = Text2.Text      ' eg Text2 = "13"
MsgBox strA + strB     ' displays "2513"

MsgBox CLng(strA) + CLng(strB)			' displays "38"

The system of "Hungarian" notation is one that has been widely accepted as being the most suitable. This system consists of a lower-case prefix indicating the Data Type followed by the variable name with capitalised initial letters.

For example, an integer type that is used to store the count for a loop of code might be called:

intLoopCount

g_intLoopCount

One of the options available with every module of code in Visual Basic is the Option Explicit option. When this is enabled, every variable used in your code must be declared before using it. If it is not, a "Variable not defined" error will occur during compilation, giving you the chance to correct the problem. During development of exercises on this course and on all future Visual Basic development, it is strongly recommended that the Option Explicit option be used.

To enable this option, simply type Option Explicit at the very top of the Code View window prior to any other lines of code.