
            CHAPTER 6 - Arrays, types, constants, and labels


                                  ARRAYS

             At  the  beginning  of this tutorial  we  said  that  a
        computer   program  is  composed  of  data  and   executable
        statements  to do something with that data.  Having  covered
        nearly  all  of the programming statements, we must  now  go
        back  and fill in some gaps in our data definition and  look
        at the array in particular.

             One  of the most useful Pascal data structures  is  the
        array, which is, in the simplest terms, a group of 2 or more
        identical terms, all having the same type.  Lets go directly
        to  an example to see what an array looks like. Display  the
        Pascal  program ARRAYS and notice line 5 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 5 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 for each element of the array.

             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 well defined numbers.   With  the
        values  stored,  a  header is now printed and  the  list  of
        values  contained in the array is printed.   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.

             Keep in mind that the array is actually composed of  12
        different integer type variables that can be used in any way


                                Page 36









            CHAPTER 6 - Arrays, types, constants, and labels


        that  it  is legal to use any other integer  type  variable.
        Compile and run this program.

                           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  type  integer.    The   variable
        Checkerboard  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 in line 12 of the program.

             After  defining all of those variables, and you  should
        understand that we have defined a total of 128 variables  in
        the  double loop, 64 of Checkerboard and 64 of  Value,  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  code  in  lines 24 to 26 simply  change  three  of  the


                                Page 37









            CHAPTER 6 - Arrays, types, constants, and labels


        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 line 26, 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  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.  The  word  "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 Pascal gives you the ability  to  define
        new types to solve a particular problem.



                                Page 38









            CHAPTER 6 - Arrays, types, constants, and labels


             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 user defined 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 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.

             Be sure to compile and run this program.

                    IS THE CONCEPT OF "TYPES" IMPORTANT?

             If you spend the time to carefully select the types for
        the variables used in the program, the Pascal compiler  will
        do some debugging for you since it is picky about the use of
        variables with different types.  Any aid you can use to help
        find  and remove errors from your program is useful and  you
        should  learn to take advantage of type checking.  The  type
        checking in Pascal is relatively weak compared to some other
        languages such as Modula-2 or Ada, but still very useful.

             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


                                Page 39









            CHAPTER 6 - Arrays, types, constants, and labels


        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 type
        integer  and  some  are type 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.  This program should give  you  a
        good  idea 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 type 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 type variable  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 type variable initialized to  the
        value TRUE.  It is not a constant.

             The typed constants defined in the last paragraph  have
        one  additional  characteristic, they are  initialized  only
        once,  when  the  program is loaded.  Even when  used  in  a
        procedure  or function, they are only initialized  when  the
        program  is loaded, not upon each call to the  procedure  or
        function.   Don't worry too much about this at  this  point,



                                Page 40









            CHAPTER 6 - Arrays, types, constants, and labels


        when  you gain experience with Pascal, you will be  able  to
        use this information very effectively.

                           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.

             When you compile and run this program, the output  will
        look a little better than the program did.

                             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.

            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.  The packed array is
        specifically ignored by either TURBO Pascal compiler.

                      ONE MORE TURBO PASCAL EXTENSION

             Standard Pascal, as defined by Nicklaus Wirth, requires
        that  the  various  fields in the  definition  part  of  the
        program  come in a specific order and each must appear  only
        once.   The specific order is, label, const, type, var,  and
        finally the procedures and functions.  Of course, if any are


                                Page 41









            CHAPTER 6 - Arrays, types, constants, and labels


        not needed, they are simply omitted.  This is a rather rigid
        requirement   but  it  was  required  by  the  pure   Pascal
        definition probably to teach good programming techniques  to
        beginning students.

             All versions of TURBO Pascal are not nearly as rigid as
        the  standard Pascal requirement.  You are permitted to  use
        the  fields in any order and as often as you  wish  provided
        that  you define everything before you use it, which is  the
        unbroken rule of Pascal.  It sometimes makes sense to define
        a few variables immediately after their types are defined to
        keep  them  near their type definitions, then define  a  few
        more types with the variables that are associated with  them
        also.   TURBO Pascal gives you this extra  flexibility  that
        can be used to your advantage.


                           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 42
