Lesson 8: Array basics
Arrays are useful critters because they can
be used in many ways. For example, a tic-tac-toe
board can be held in an array. Arrays are essentially a way to store many values under the
same
name. You can make an array out of any data-type including structures and classes.
Think about arrays like this:
[][][][][][]
Each of the bracket pairs is a slot(element) in the array, and you can put information
into each
one of them. It is almost like having a group of variables side by side.
Lets look at the syntax for declaring an array.
int examplearray[100]; //This declares an array
This would make an integer array with 100 slots, or places to store values(also called
elements).
To access a specific part element of the array, you merely put the array name and, in
brackets,
an index number. This corresponds to a specific element of the array. The one trick is
that
the first index number, and thus the first element, is zero, and the last is the number of
elements
minus one. 0-99 in a 100 element array, for example.
What can you do with this simple knowledge? Lets say you want to store a string, because
C++ has
no built-in datatype for strings, at least in DOS, you can make an array of characters.
For example:
char astring[100];
will allow you to declare a char array of 100 elements, or slots.
Then you can receive input
into it it from the user, and if the user types in a long string, it will go in the array.
The
neat thing is that it is very easy to work with strings in this way, and there is even a
header
file called string.h. There is another lesson on the uses of string.h, so its not
necessary to
discuss here.
The most useful aspect of arrays is multidimensional arrays.
How I think about multi-dimensional arrays.
[][][][][]
[][][][][]
[][][][][]
[][][][][]
[][][][][]
This is a graphic of what a two-dimensional array looks like when I visualize it.
For example:
int twodimensionalarray[8][8];
declares an array that has two dimensions. Think of it as a
chessboard. You can easily use
this to store information about some kind of game or to write something like tic-tac-toe.
To
access it, all you need are two variables, one that goes in the first slot and one that
goes in
the second slot. You can even make a three dimensional array, though you probably won't
need to.
In fact, you could make a four-hundred dimensional array. It would be confusing to
visualize,
however.
Arrays are treated like any other variable in most ways. You can modify
one value in it by
putting:
arrayname[arrayindexnumber]=whatever;
//or, for two dimensional arrays
arrayname[arrayindexnumber1][arrayindexnumber2]=whatever;
However, you should never attempt to write data past the last element of the array, such
as when
you have a 10 element array, and you try to write to the 11 element. The memory for the
array
that was allocated for it will only be ten locations in memory, but the twelfth could be
anything, which could crash your computer.
You will find lots of useful things to do with arrays, from store information about
certain
things under one name, to making games like tic-tac-toe. One suggestion I have is to use
for
loops when access arrays.
#include <iostream.h>
int main()
{
int x, y, anarray[8][8];//declares an array like a chessboard
for(x=0; x<8; x++)
{
for(y=0; y<8; y++)
{
anarray[x][y]=0;//sets the element to zero, once the loops finish all elements will be 0
}
}
for(x=0; x<8;x++)
{
for(y=0; y<8; y++)
{
cout<<"anarray["<<x<<"]["<<y<<"]="<<anarray[x][y]<<"
";//you'll see
}
}
return 0;
}
Here you see that the loops work well because they increment the variable for you, and you
only
need to increment by one. Its the easiest loop to read, and you access the entire array.
One thing that arrays don't require that other variables do, is a
reference operator when
you want to have a pointer to the string. For example:
char *ptr;
char str[40];
ptr=str; //gives the memory address without a reference operator(&)
//As opposed to
int *ptr;
int num;
ptr=#//Requires & to give the memory address to the ptr