Pascal-Programming.info

A step-by-step Pascal tutorial for beginners.

What are Arrays?

An array is a highly useful data structure that stores variable data having the samedata type. It is just like a small fixed number of boxes linked together one after the other storing things that are related to each other. An array is said to be a static data structure because, once declared, its original size that is specified by the programmer will remain the same throughout the whole program and cannot be changed.

Up until now, we have used single variables only as a tool to store data. Now we will be using the array data structure and here is how it is declared:

Var

<arrayName> : Array[n..m] of <Data Type>;

myArray : Array[1..20] of Integer;

An array data structure defines the size of the array and the data type that it will use for storing data. In the above example, the array stores up to 20 integers however I may have used 30 integers or more. This size depends on your program requirements.

Arrays are used just like ordinary variables. They are used to store typed data just like the ordinary variables. You will now learn how to assign data to arrays and read data from arrays.

In the example above, I have declared 20 integers and I should be able to access each and one of them and here is how I do it.

To assign values to a particular integer of an array, we do it like this:

myArray[5] := 10;
myArray[1] := 25;
<arrayName>[index] := <value>;

You just take the array in subject, specify the index of the variable of the array and assign it a value relevant to the data type of the array itself.

Reading a value from an array is done as follows:

Var
	myVar : Integer;
	myArray : Array[1..5] of Integer;
	
Begin
	myArray[2] := 25;
	myVar := myArray[2];
End.

Just like ordinary variables, arrays can be initialised with any value you want, otherwise they will be assigned with their default value. If we want to intialise 2 entire integer and boolean arrays of size 20 to 1 and true respectively, we do it like this:

Var
	i : Integer;
	myIntArray : Array[1..20] of Integer;
	myBoolArray : Array[1..20] of Boolean;

Begin
	For i := 1 to Length(myIntArray) do
	Begin
		myIntArray[i] := 1;
		myBoolArray[i] := True;
	End;
End.

Note that if these are arrays were not initialised, integer array elements would be assigned to 0 and false to boolean arrays.

An interesting function which has been just introduced in the code above is the Length function. This function very much co-operates with collections, meaning can be both used with arrays and even Strings! The Length function returns the size of the number of items which was allocated for a collection. For example, in the code above it will return 20 and therefore the loop will iterate through every item in the array.

When working with Strings, the Length function will simply return the length of the string (that is, number of characters).

Back To Top ⇧

Introducing User-Defined Data Types

Now that we have used various built-in data types, we have arrived at a point were we might want to use our defined data types. Built-in data types are those which come part and parcel with the programming language, such as Integer, Boolean and String. Now you should learn how to specify our own customised data types and here is the syntax:

Type
<myDataType> = <particularDataType>;

The "Type" keyword is a Pascal reserved word used to define our own data types. So you start defining your own data types by using this keyword, specify a name for your data type and then create a customized data type. After defining your own data types, you may start using them just like the other built-in data types as follows:

Var
<myVar> : <myDataType>;

Now lets define a new simple data type and note how it will be used in the program below:

Type
	nameType = String[50];
	ageType  = 0..150; { age range: from 0 to 150 }

Var
	name : nameType;
	age  : ageType;

Begin
	Write('Enter your name: ');
	Readln(name);
	Write('Enter your age: ');
	Readln(age);
	Writeln;
	Writeln('Your name:', name);
	Writeln('Your age :', age);
	Readln;
End.

In the above example we defined a String[50] and a 0..150 data type. The nameType only stores strings up to 50 characters long and the ageType stores numbers only from 0 to 150.

We can define more complex user-defined data types. Here is an example of more complex user-defined data types:

Type
	i = 1..5;
	myArrayDataType = Array[1..5] of Byte;
	byteFile        = File of Byte; { binary file }

Var
	myArrayVar : myArrayDataType;
	myFile     : byteFile;

Begin
	Writeln('Please enter 5 numbers from (0..255): ');
	
	For i := 1 to Length(myArrayVar) do
		Readln(myArrayVar[i]);
	
	Writeln('You have entered the following numbers: ');
	
	For i := 1 to Length(myArrayVar)do
		Writeln('Number ',i,': ',myArrayVar[i]);
	
	Writeln('Now writing them to file...');   {store the numbers in a file}
	Assign(myFile, 'example.dat');
	ReWrite(byteFile);
	Write(myFile, myArrayVar[i]);
	Close(myFile);
	Writeln('Done, you may exit..');
	Readln;
End.

In the above example I showed you how to incorporate arrays as user-defined data types. Note that you may use user-defined data types more than once.

Back To Top ⇧

2 Dimensional and Multi-Dimensional Arrays

2 Dimensional arrays and multi-dimensional are arrays which store variables in a second or nth dimension having n*m storage locations. Mutli dimensional arrays including the 2 dimensional array, are declared by using multiple square brackets placed near each other or using commas with one sqaure brackets as an alternative.

Here is how multi-dimensional are declared:

my2DArray : Array[i..j, k..l] of <DataType>;
myMultiDimArray : Array[m..n, o..p, q..r, s..t]... of <DataType>;

Let us have the 2 dimensional array defined first. Think of a grid where each box is located by using horizontal and vertical coordinates just in the example below:

1 2 3 4 5
2        
3     3,4  
4        
5   5,3    

Let us declare an array having 3 by 5 dimensions, assign a value to a particular variable in the array and illustrate this on a grid just like the one above:


Var
	my2DArray : Array[1..3, 1..5] of Byte;

Begin
	my2DArray[2][4] := 10;
End.

Having the vertical axis as the 1st dimension and the horizontal one as the 2nd dimension, the above example can be illustrated as follows:

1 2 3 4 5
2    
10
  
3        

Multi-dimensional arrays are rare and are not important. The single and 2D dimensional arrays are the 2 most frequent dimensions.

The following example is a bit more complex example than the previous examples and it also uses a 2 dimensional array to illustrate their use.

Uses Crt;
Type
	myRange      = 1..5;
	arrayIntType = Array[myRange] of Integer;
	myFileType   = File of arrayIntType;

Var
	i        : myRange;
	myFile   : myFileType; { the next array is 2 dimensional }
	arrayInt : Array[1..2] of arrayIntType;
 
Begin
	Clrscr;
	Randomize;
	
	For i := 1 to 5 do { or we can use Length(arrayInt[1][i]) }
	Begin
		arrayInt[1][i] := Random(1000);
		Writeln('rand num: ',arrayInt[1][i]);
	End;

	Assign(myFile, 'test.dat');
	ReWrite(myFile);
	Write(myFile, arrayInt[1]);
	Close(myFile);
	ReSet(myFile);
	Read(myFile, arrayInt[2]);
	Close(myFile);

	For i := 1 to 5 do
		Writeln(i,': ', arrayInt[2][i]);

	Readln;
End.

This concludes the arrays lesson. In the next lesson we will learn about Record data structures, their uses and we will also learn how to use binary files used record data structures.

Back To Top ⇧

Spread The Word!

Have Your Say

Back To Top ⇧