An array is a set of values that are logically related to each other, such as the
number of students in each grade in a grammar school.
An array allows you to refer to these related values by the same name and to use a
number, called an index or subscript, to tell them apart. The individual values are
called the elements of the array. They are contiguous from index 0 through the
highest index value.
Example
The following example declares an array variable to hold the number of students in
each grade in a grammar school.
The array students in the preceding example contains 7 elements. The indexes of the
elements range from 0 through 6. Having this array is simpler than declaring 7
different variables.
The following illustration shows the array students. For each element of the array:
You can refer to the array as a whole by using just the array variable name without
indexes.
Array Dimensions
The array students in the preceding example uses one index and is said to be one-
dimensional. An array that uses more than one index or subscript is
calledmultidimensional. For more information, see Array Dimensions in Visual Basic.
Another kind of array is one which holds other arrays as elements. This is known as
an array of arrays or a jagged array. A jagged array can be either one-dimensional or
multidimensional, and so can its elements. Sometimes the data structure in your
application is two-dimensional but not rectangular. For example, you might have an
array of months, each element of which is an array of days. Since different months
have different numbers of days, the elements do not form a rectangular two-
dimensional array. In such a case, you can use a jagged array instead of a
multidimensional array.
Declaring an Array
You declare an array variable the same way as any other variable, by using
the Dim statement. You follow the variable name with one or more pairs of
parentheses to indicate that it is to hold an array rather than a scalar (a variable that
contains a single value).
To declare a one-dimensional array variable, add one pair of parentheses after the
variable name.
To declare a multidimensional array variable, add one pair of parentheses after the
variable name and place commas inside the parentheses to separate the dimensions.
The preceding examples declare array variables but do not assign arrays to them.
You must still create an array, initialize it, and assign it to the variable.
Zero-Length Arrays
You might need to create a zero-length array under the following circumstances:
Creating an Array
An array can be created two ways. You can supply the size of an array when it is
declared, or, because an array is an object, so you create it with a New Operator
(Visual Basic) clause and assign it to the array variable. You can do this as part of the
array declaration, or in a subsequent assignment statement as shown in the following
example.
Note
The New clause must specify the type name, followed by parentheses, followed by braces ({}). The parenthe
array constructor. Instead, they indicate that the object type is an array type. You can supply initialization val
requires the braces even if you are not supplying any values. Therefore, the New clause must include both the
both contain no values. If you exclude the braces, the complier assumes that you are calling the constructor fo
You can define the size of an array several different ways. You can supply the size
when the array is declared, as shown in the following example.
You can also supply the size of an array when it is created by using a New clause, as
shown in the following example.
If you have an existing array, you can redefine its size by using the Redim statement.
You can specify that the Redim statement keep the values that are currently stored
in the array, or you can specify that it create a new, empty array. The following
example shows different uses of the Redim statement to modify the size of an
existing array.
VB
C#
C++
' Assign a new array size and retain the current element values.
ReDim Preserve cargoWeights(20)
' Assign a new array size and retain only the first five element values.
ReDim Preserve cargoWeights(4)
' Assign a new array size and discard all current element values.
ReDim cargoWeights(15)
For more information, see ReDim Statement (Visual Basic).
You can create an array that contains an initial set of values by using an array literal.
An array literal consists of a list of comma-separated values that are enclosed in
braces ({}).
When you create an array by using an array literal, you can either supply the array
type or use type inference to determine the array type. Both options are shown in the
following code.
When you use type inference, the type of the array is determined by the dominant
type in the list of values that is supplied for the array literal. The dominant type is a
unique type that all other types in the array literal can widen to. If this unique type
cannot be determined, the dominant type is the unique type that all other types in
the array can narrow to. If neither of these unique types can be determined, the
dominant type is Object. For example, if the list of values supplied to the array literal
contains values of type Integer, Long, and Double, the resulting array is of
type Double. Both Integer and Long widen to Double and only Double.
Therefore,Double is the dominant type. For more information, see Widening and
Narrowing Conversions (Visual Basic). These inference rules apply to types inferred
for arrays that are local variables defined in a class member. Although you can use
array literals when you create class-level variables, you cannot use type inference at
the class level. As a result, array literals that are specified at the class level infer the
values supplied for the array literal as type Object.
You can explicitly specify the type of the elements in an array that is created by
using an array literal. In this case, the values in the array literal must widen to the
type of the elements of the array. The following code example creates an array of
type Double from a list of integers.
You can create a multidimensional array by using nested array literals. Nested array
literals must have a dimension and number of dimensions, or rank, that is consistent
with the resulting array. The following code example creates a two-dimensional array
of integers by using an array literal.
Dim grid = {{1, 2}, {3, 4}}
In the previous example, an error would occur if the number of elements in the
nested array literals did not match. An error would also occur if the array variable
was explicitly declared other than two-dimensional.
Note
You can avoid an error when you supply nested array literals of different dimensions by enclosing the inner a
parentheses force the array literal expression to be evaluated, and the resulting values are used with the outer
following code.
When you create a multidimensional array by using nested array literals, you can use
type inference. When you use type inference, the inferred type is the dominant type
for all the values in all the array literals for a nesting level. The following code
example creates a two-dimensional array of type Double from values that are of
type Integer and Double.
For additional examples, see How to: Initialize Array Variables in Visual Basic.
You can access each location in an array by using an index of type Integer. You can
store and retrieve values in an array by referencing each array location by using its
index enclosed in parentheses. Indexes for multi-dimensional arrays are separated by
commas (,).You need one index for each array dimension. The following example
shows some statements that store values in arrays.
Dim i = 4
Dim j = 2
numbers(i + 1) = 0
matrix(3, j * 2) = j
The following example shows some statements that get values from arrays.
Dim v = 2
Dim i = 1
Dim j = 1
Dim k = 1
Dim wTotal As Double = 0.0
Dim sortedValues(5), rawValues(5), estimates(2, 2, 2) As Double
Dim lowestValue = sortedValues(0)
wTotal += (rawValues(v) ^ 2)
Dim firstGuess = estimates(i, j, k)
For each array dimension, the GetUpperBound method returns the highest value the
index can have. The lowest index value is always 0.
Array Size
The size of an array is the product of the lengths of all its dimensions. It represents
the total number of elements currently contained in the array.
You can find the size of an array by using the Length property. You can find the
length of each dimension of a multi-dimensional array by using
the GetLengthmethod.
You can resize an array variable by assigning a new array object to it or by using
the ReDim statement.
There are several things to keep in mind when dealing with the size of an array.
n The index of each dimension is 0-based, which means it ranges from 0 through its upper bound. Therefore, the length of
dimension is greater by 1 than the declared upper bound for that dimension.
mits The length of every dimension of an array is limited to the maximum value of the Integer data type, which is (2 ^ 31) - 1
However, the total size of an array is also limited by the memory available on your system. If you attempt to initialize an
that exceeds the amount of available RAM, the common language runtime throws an OutOfMemoryException exception
An array's size is independent of the data type of its elements. The size always represents the total number of elements, n
Size number of bytes that they consume in storage.
It is not safe to make any assumptions regarding how an array is stored in memory. Storage varies on platforms of differ
tion widths, so the same array can consume more memory on a 64-bit system than on a 32-bit system. Depending on system
configuration when you initialize an array, the common language runtime (CLR) can assign storage either to pack eleme
close together as possible, or to align them all on natural hardware boundaries. Also, an array requires a storage overhead
control information, and this overhead increases with each added dimension.
Array Types and Other Types
Data Types
Every array has a data type, but it differs from the data type of its elements. There is
no single data type for all arrays. Instead, the data type of an array is determined by
the number of dimensions, or rank, of the array, and the data type of the elements in
the array. Two array variables are considered to be of the same data type only when
they have the same rank and their elements have the same data type. The lengths of
the dimensions in an array do not influence the array data type.
Every array inherits from the System.Array class, and you can declare a variable to
be of type Array, but you cannot create an array of type Array. Also, the ReDim
Statement (Visual Basic) cannot operate on a variable declared as type Array. For
these reasons, and for type safety, it is advisable to declare every array as a specific
type, such as Integer in the preceding example.
You can find out the data type of either an array or its elements in several ways.
The following example calls the TypeName function to determine the type of the
array and the type of the elements in the array. The array type is Integer(,) and the
elements in the array are of type Integer.
If you need to change the size of an array, you must use the ReDim Statement
(Visual Basic). When you do this, Visual Basic creates a new array and releases the
previous array for disposal. This takes execution time. Therefore, if the number of
items you are working with changes frequently, or you cannot predict the maximum
number of items you need, you might obtain better performance using a collection.
A collection, which does not have to create a new object or copy existing elements,
can handle resizing in less execution time than an array, which has to use ReDim. But
if the size does not change, or changes only rarely, an array is likely to be more
efficient. As always, performance is highly dependent on the individual application. It
is often worth your time to try both an array and a collection.
Specialized Collections
The .NET Framework also provides a variety of classes, interfaces, and structures for
general and special collections.
The System.Collections andSystem.Collections.Specialized namespaces contain
definitions and implementations that include dictionaries, lists, queues, and stacks.
TheSystem.Collections.Generic namespace provides many of these in generic
versions, which take one or more type arguments.
If your collection is to hold elements of only one specific data type, a generic
collection has the advantage of enforcing type safety. For more information on
generics, see Generic Types in Visual Basic (Visual Basic).
Specialized Collections
The .NET Framework also provides a variety of classes, interfaces, and structures for
general and special collections.
The System.Collections andSystem.Collections.Specialized namespaces contain
definitions and implementations that include dictionaries, lists, queues, and stacks.
TheSystem.Collections.Generic namespace provides many of these in generic
versions, which take one or more type arguments.
If your collection is to hold elements of only one specific data type, a generic
collection has the advantage of enforcing type safety. For more information on
generics, see Generic Types in Visual Basic (Visual Basic).
Example
The declaration of the CustomerFile collection specifies that it can contain elements
only of type Customer. It also provides for an initial capacity of 200 elements. The
procedure AddNewCustomer checks the new element for validity and then adds it to
the collection. The procedure PrintCustomers uses a For Each loop to traverse the
collection and display its elements.
In general terms, a collection is an object used for grouping and managing related
objects. For example, every Form has a collection of controls. (You can access this
collection through the form's Controls property.) This collection is an object that
represents all the controls on that form. It allows you to retrieve a control in the
collection by its index, and to loop through the elements of the collection using a For
Each...Next Statement (Visual Basic).
However, there are several kinds of collections, and they differ from each other in
several ways.
localControls = Me.Controls()
The collections are incompatible because the Controls collection is a .NET Framework
collection, while the variable localControls is a Visual Basic Collection. The two kinds
of collections are implemented from different classes. Their methods are similar but
not identical, and their indexing schemes are different.
One-based collections can be more intuitive to Visual Basic users, because the index
ranges from 1 through the value of the Count property, which returns the number of
items in a collection. The index of a zero-based collection, by contrast, ranges from 0
through one less than the value of the Count property. This can be appropriate when
the index values are offsets from a base value or correspond to members of a zero-
based enumeration.
.NET Framework collections are zero-based for the purpose of standardization. The
Visual Basic Collection class is one-based for the purpose of compatibility with
previous versions.
just getting started with Visual Basic. Regardless of your background, one of the most
fundamental concepts you'll need to understand to write programs in Visual Basic is the idea
"Main") and from that point onward has complete responsibility for everything that happens. It
must handle keyboad input, mouse input, output to the screen, etc. With Visual Basic (and
Windows in general), you no longer need to worry about low level input handling. Windows
and Visual Basic take care of the details for you, allowing you to concentrate on what the
Lets say for example that you want a program to display a message when the user clicks on a
button. With a DOS based program, you would need to track the mouse position, display a
cursor, detect the mouse click, redraw the button when its clicked, and display the message.
Visual Basic and Windows greatly simplify this process. To accomplish the same task, you
simply draw a command button on a form, and write a procedure to handle the click event. VB
and Windows will take care of the mouse and fire the event when the user clicks on the
button. All you need to do is attach the code to the button's click event and write the code
To add an event procedure and attach it a form or control, just pick the form or control from
the "Object" combo box in the code window and choose the event from the "Proc" combo box.
VB will create the event procedure for you in the code window. All that's left for you to do is to
add the code that you wish to run when the event is fired by VB. Here's the result of our
2.
4.
5. End Sub
When the user clicks on the button "cmd", the message box will be displayed. That's all there
is to it. Once you understand this simple - but not entirely obvious - concept, you're ready to
Form Events
Visual Basic forms and controls can trigger dozens of events in your applications. Forms,
controls, and classes all have events. Let's look at some of the events for forms, and examine
To demonstrate form events, I created a new form and placed code like this in the event
2. Debug.Print "Load"
3. End Sub
For each event, the name of the event was sent to the debug window. Here was the output:
1. Initialize
2. Load
3. Resize
4. Activate
5. Paint
7. QueryUnload
8. Unload
9. Terminate
There are other form events also, such as the click event, etc., but those must be triggered by
user actions or other code. These are the events that are always triggered for forms and the
• Initialize
This event occurs as the form is being loaded, but before the Load event. It gives you the
opportunity to initialize data that must be available when the form is loading.
• Load
Load is the event most often used to initialize any dynamic components of the form, such as
private data, control arrays, or any other element of the design that needs to be setup at run
• Resize
This event occurs whenever the window state (windowed, minimized, or maximized) changes
or whenever the form window is resized by the user. Here is where you place code that is
dependent on the form size or window state. If, for example, you are building a text editor,
you might resize a text box to the internal size of the form in the Resize event.
• Activate
This event occurs whenever the form window gets the input focus. If you have code that
tracks the active form in the application, you might use this event for that code.
• Paint
This is where VB actually draw the form on the screen. If you are drawing directly on the
• QueryUnload
This event is fired when the form is closed. You can use the event to determine the way the
form is being closed (through your own code, by the user, or by Windows) and can also
cancel the event and prevent the form from being closed.
• Unload
• Terminate
There is often some confusion over the three events that occur when a form is being
destroyed - the QueryUnload, Unload, and Terminate events. Of the three, the QueryUnload
event is the only one which can be cancelled. The key to remember is that a form isn't
completely removed from memory until after the Terminate event has finished. Compare the
1. Unload Form1
The first statement will cause the QueryUnload and the Unload events to fire, but only by
using the second statement can you force the Terminate event to fire. If you have form level
variables, the values will not be reset after the Unload event has fired. They are only reset
after the Terminate event fires and the form is completely removed from memory.
Control Events
Controls also have events, but the events which occur vary by the type of control. Most
controls will have a full set of keyboard and mouse events, including KeyUp, KeyDown,
KeyPress, MouseUp, MouseDown, MouseMove, Click, and DblClick. The nature of the events is
exactly what you would expect given the name of the event. There are also events to support
Some other common control events are Change, which occurs when the data in a control is
changed, GotFocus and LostFocus, which occur when the user enters or leaves the control
using the mouse or keyboard, and the Link... events, which are used for DDE operations.
Among all the control events, the one which is used most often in applications is the click
the things you'll find missing are the various BeforeUpdate and AfterUpdate events for forms
and controls. If you're used to using these events, you're going to have to find some other
means of doing whatever you were doing there. While there is a Change event for controls,
the event is fired after every change - meaning after every keystroke while the user is typing.
On the other hand, if you've ever had to write a form level keyboard handler in Access, you'll
find the Visual Basic KeyPreview property for forms will greatly simplify your efforts.
• Printer Friendly
• 22481 reads
Comments
Sat, 10/25/2008 - 17:05 — Anonymous (not verified)
ok, im programming a blackjack game and i'm really confused. im a grade 11 student and was
only introduced to the VB6 IDE like 1.5 mths ago. i really need help. in the 'hitMe' procedure, i
want to show the computer's cards if im bust, but i dont want to type it all again (dont say
copy and paste.) is there anyway i can like make a separate piece of code that triggers when
im bust. I would like to do that with all pieces of code concerning showing the cards on the