Software Engineering for Students A Programming Approach

14.15 Records (structures) 195
Individual elements of the array are referenced by specifying the array name and an
expression for each subscript, for example, table[2].
The implementation of arrays in programming languages raises the following considerations:
■ what restrictions are placed on the element type? For complete freedom of expression
there should be no restrictions.
■ valid indices should be any subrange of numbers (e.g. 2010 to 2020)
■ at what time must the size of an array be known? The utility of arrays in a programming
language is governed by the time (compile-time or run-time) at which
the size of the array must be known.
■ what operations may be applied to complete arrays? For example, it is very convenient
to be able to carry out array assignment or comparison between compatible arrays
using a single concise statement.
■ are convenient techniques available for the initialization of arrays?
The time at which a size must be specified for an array has implications on how the
array may be used. In Java, as in most languages, the size of an array must be defined
statically – the size and subscript ranges are required to be known at compile-time. This
has the advantage of allowing the compiler to generate code automatically to check for
out-of-range subscripts. However, the disadvantage of this simple scheme is that, to
allow the program to accommodate data sets of differing sizes, we would like to delay
deciding the size of the array until run-time. Most languages provide arrays whose size
is fixed at compile-time, so if variable size is needed, a dynamic data structure is the
answer (see Chapter 15).
SELF-TEST QUESTION
14.5 Argue for and against the language making array subscripts start at 0.
14.15 ● Records (structures)
Data objects in problem domains are not always simply collections of homogeneous
objects (same types). Rather, they are often collections of heterogeneous objects (different
types). Although such collections can be represented using arrays, many programming
languages provide a record data aggregate. Records (or structures as they are
termed in C and C++) are generalizations of arrays where the elements (or fields) may
be of different types and where individual components are referenced by (field) name
rather than by position.
For example, the C++ struct definition shown below describes information relating
to a time. Each object of type Time has three components named hour, minute
and second.