CHAPTER 6 - Arrays, types, constants, and labels ARRAYS Having covered nearly all of the programming statements, we must now go back and fill in some gaps in our data definition. One of the most useful data structures is the ARRAY, which is, in the simplest terms, a group of many identical terms. Lets go directly to an example to see what an array looks like. Edit the Pascal program ARRAYS and notice the third line starting with the word "automobiles". The variable "automobiles" is defined as an integer variable but in addition, it is defined to have twelve different integer variables, namely "automobile[1]", "automobile[2]", "automobile[3]", .. "automobile[12]". The square braces are used in Pascal to denote a subscript for an array variable. The array definition given in line 3 is the standard definition for an array, namely a variable name followed by a colon and the reserved word ARRAY, with the range of the array given in square brackets followed by another reserved word OF and finally the type of variable. In using the elements of the array in a program, each of the elements of the array are required to be used in exactly the same manner as any simple variable having the same type. Each time one of the variables is used, it must have the subscript since the subscript is now part of the variable name. The subscript moreover, must be of the type used in the definition and it must be within the range defined or it will be listed as an error. Now consider the program itself. As "index" is varied from 1 to 12, the range of the variable "automobile", the 12 variables are set to the series of values 11 to 22. Any integer values could be used, this was only a convenient way to set the values to some numbers. With the values stored, a header is now printed and finally the list of values contained in the array. Note carefully that, although the subscripts are limited to 1 through 12, the values stored in each of the 12 variables are limited only by the range of integers, namely -32768 to 32767. Review this material and this program as long as needed to fully understand it, as it is very important. DOUBLY INDEXED ARRAYS After understanding the above, load the program ARRAYS2 to see the next level of complexity of arrays. You will see that "checkerboard" is defined as an array from 1 to 8, but instead of it being a simple data type, it is itself another array from 1 to 8 of INTEGER. The variable "checkerboard" Page 27 CHAPTER 6 - Arrays, types, constants, and labels is actually composed of 8 elements, each of which is 8 elements, leading to a total of 64 elements, each of which is a simple INTEGER variable. This is called a doubly subscripted array and it can be envisioned in exactly the same manner as a real checker board, an 8 by 8 matrix. Another way to achieve the same end is to define the double array as in the next line of the program where "value" is defined as a total of 64 elements. To use either of the two variables in a program, we must add two subscripts to the variable name to tell the program which element of the 64 we desire to use. Examining the program will reveal two loops, one nested within the other, and both ranging in value from 1 to 8. The two loop indices can therefore be used as subscripts of the defined array variables. The variable "checkerboard" is subscripted by both of the loop indices and each of the 64 variables is assigned a value as a function of the indices. The assigned value has no real meaning other than to illustrate to you how it is done. Since the value of "checkerboard" is now available, it is used to define some values to be used for the variable "value". After defining all of those variables, and you should understand that we have defined a total of 128 variables in the double loop, they can be printed out. The next section of the program does just that, by using another doubly nested loop, with a WRITE statement in the center. Each time we go through the center of the loop we tell it to print out one of the 64 variables in the "checkerboard" matrix with the indices "index" and "count" defining which of the variables to write each time. Careful study of the loop should reveal its exact operation. After printing out the matrix defined by the variable "checkerboard" we still have the matrix defined by the variable "value" intact (In fact, we still have all of "checkerboard" available because we haven't changed any of it). Before printing out the matrix defined by "value", let's change a few of the elements just to see how it is done. The next three lines simply change three of the variables to illustrate that you can operate on all of the matrix in loops, or on any part of the matrix in simple assignment statements. Notice especially the third line, in which "value[3,6]" (which was just set to the value of 3), is used as a subscript. This is perfectly legal since it is defined as a simple integer variable and is within the range of 1 to 8, which is the requirement for a subscript of the variable "value". The last part of the program simply prints out the 64 values of the variable "value" in the Page 28 CHAPTER 6 - Arrays, types, constants, and labels same manner as above. Notice that when you run the program, the three values are in fact changed as expected. ARRAYS ARE FLEXIBLE A few more words about arrays before we go on. The arrays in the last program were both defined to be square, namely 8 by 8 but that choice was purely arbitrary. The subscripts were chosen to go from 1 to 8 but they could have been chosen to go from 101 to 108 or any other range needed to clearly define the problem at hand. And, as you may have guessed, you are not limited to a doubly subscripted matrix but you can define a variable with as many subscripts as you need to achieve your desired end. There is a practical limit to the number of subscripts because you can very quickly use up all of your available memory with one large subscripted variable. THE TYPE DEFINITION Now that you understand arrays, lets look at a more convenient way to define them by examining the Pascal file TYPES. You will notice a new section at the beginning of the listing with the heading TYPE. TYPE is another reserved word which is used at the beginning of a section used to define "user-defined types". Beginning with the simple predefined TYPES we studied earlier, we can build up as many new types as we need and they can be as complex as we desire. The six names (from "array_def" to "boat") in the TYPE section are not variables, but are defined to be TYPES and can be used in the same manner as can INTEGER, BYTE, REAL, etc. This is a very difficult concept, but a very important one. The Pascal compiler is very picky about the variable types you use in the program, doing lots of checking to insure that you do not use the wrong type anywhere in the program. Because it is picky, you could do very little without the ability to define new types when needed, and that is the reason that you can define new types to solve a particular problem. Some of these types are used in the VAR declaration part of the program. Notice that since "airplane" is an array of "dog_food" and "dog_food" is in turn an array of BOOLEAN, then "airplane" defines a doubly subscripted array, each element being a boolean variable. This does not define any variables, only a TYPE, which can be used in a VAR to define a matrix of boolean variables. This is in fact done in the definition of "puppies", which is an array composed of 72 (6 times 12) boolean variables. In the same manner, "stuff" is Page 29 CHAPTER 6 - Arrays, types, constants, and labels composed of an array of 14 variables, each being an integer variable. The elements of the array are, "stuff[12]", "stuff[13]", .. "stuff[25]". Notice also that "stuff2" is also defined in exactly the same manner and is also composed of 14 variables. Careful inspection will reveal that "kitties" is a variable which has the same definition as "puppies". It would probably be poor programming practice to define them in different manners unless they were in fact totally disassociated. In this example program, it serves to illustrate some of the ways user-defined types can be defined. In a tiny program like this example, the value of the TYPE declaration part cannot be appreciated, but in a large program with many variables, the TYPE declaration can be used to great advantage. This will be illustrated later. THE CONSTANT DECLARATION Examining the Pascal example program CONSTANT will give us an example of a constant definition. The reserved word CONST is the beginning of the section that is used to define constants that can be used anyplace in the program as long as they are consistent with the required data typing limitations. In this example, "max_size" is defined as a constant with the value of 12. This is not a variable and cannot be changed in the program, but is still a very valuable number. For the moment ignore the next two constant definitions. As we inspect the TYPE declarations, we see two user-defined types, both of which are arrays of size 1 to 12 since "max_size" is defined as 12. Then when we get to the VAR declaration part, we find five different variables, all defined as arrays from 1 to 12 (some are INTEGER and some are CHAR). When we come to the program we find that it is one big loop which we go through 12 times because the loop is executed "max_size" times. In the above definition, there seems to be no advantage to using the constant, and there is none, until you find that for some reason you wish to increase the range of all arrays from 12 to 18. In order to do so, you only need to redefine the value of the constant, recompile, and the whole job is done. Without the constant definition, you would have had to change all TYPE declarations and the upper limit of the loop in the program. Of course that would not be too bad in the small example program, but could be a real mess in a 2000 line program, especially if you missed changing one of the 12's to an 18. That would be a good example of data in and garbage out. That should give you a good idea Page 30 CHAPTER 6 - Arrays, types, constants, and labels of what the constant can be used for, and as you develop good programming techniques, you will use the constant declaration to your advantage. THE TURBO PASCAL TYPED CONSTANT We skipped over the second and third constant declaration for a very good reason, they are not constant declarations. TURBO Pascal has defined, as an extension, the "typed constant". Using the syntax shown, "index_start" is defined as an INTEGER variable and is initialized to the value of 49. This is a true variable and can be used as such in the program. The same effect can be achieved by simply defining "index_start" as an INTEGER in the VAR declaration part and setting it to the value of 49 in the program itself. Since it does not really fit the definition of a constant, it's use is discouraged until you gain experience as a Pascal programmer. Until then it will probably only be confusing to you. In like manner, "check_it_out" is a boolean variable initialized to the value "true". It is not a constant. THE LABEL DECLARATION Finally, the example program LABELS will illustrate the use of labels. In the Pascal definition, a LABEL is a number from 0 to 9999 that is used to define a point in the program to which you wish to jump. All labels must be defined in the LABEL definition part of the program before they can be used. Then a new reserved word GOTO is used to jump to that point in the program. The best way to see how the GOTO is used with labels is to examine the program before you. TURBO Pascal has an extension for labels. Any valid identifier, such as used for variables, can be used as a label in addition to the values from 0 to 9999. These are illustrated in the example program. THE PACKED ARRAY When Pascal was first defined in 1971, many of the computers in use at that time used very large words, 60 bits being a typical word size. Memory was very expensive, so large memories were not too common. A Pascal program that used arrays was inefficient because only one variable was stored in each word. Most of the bits in each word were totally wasted, so the PACKED ARRAY was defined in which several variables were stored in each word. This saved storage space but took extra time to unpack each word to use the data. The programmer was given a choice of using a fast scheme that wasted memory, the ARRAY, or a slower scheme that used memory more efficiently, the PACKED ARRAY. Page 31 CHAPTER 6 - Arrays, types, constants, and labels The modern microcomputer has the best of both schemes, a short word, usually 16 bits, and a large memory. The PACKED ARRAY is therefore not even implemented in many compilers and will be ignored during compilation. PROGRAMMING EXERCISES 1. Write a program to store the integers 201 to 212 in an array then display them on the monitor. 2. Write a program to store a 10 by 10 array containing the products of the indices, therefore a multiplication table. Display the matrix on the video monitor. 3. Modify the program in 2 above to include a constant so that by simply changing the constant, the size of the matrix and the range of the table will be changed. Page 32