| array | type |
| Syntax | array indexType { , indexType } of typeSpec
|
| Description | An array consists of a number of elements. The typeSpec gives the type of these elements. There is one element for each item in the (combinations of) range(s) of the indexType(s). In the following example, the array called marks consists of 100 elements, each of which is an integer.
|
| Example |
var marks : array 1 .. 100 of int
…
var sum : int := 0
for i : 1 .. 100 % Add up the elements of marks
sum := sum + marks (i)
end for
|
| Execute | |
| Details | In the above example, marks(i) is the i-th element of the marks array. We call i the index or subscript of marks. In Turing, a subscript is surrounded by parentheses, not by square brackets as is the case in the Pascal or C-like languages.
|
| Example | The prices array shows how an array can have more than one dimension. This array has one dimension for the year (1988, 1989 or 1990) and another for the month (1 .. 12). There are 36 elements of the array, one for each month of each year.
var price : array 1988 .. 1990, 1 .. 12 of int
…
var sum : int := 0
for year : 1988 .. 1990 % For each year
for month : 1 .. 12 % For each month
sum := sum + price (year, month)
end for
end for
|
| Execute | |
| Details | Each indexType must contain at least one item. The range 1 .. 0, for example, would not be allowed. Each index type must be a subrange of the integers, characters (the char type), or of an enumerated type, an (entire) enumerated type, the char type, the boolean type, or a named type which is one of these. Arrays can also be declared in the form
var a : array 1 .. * of typeSpec := init (…)The upper bound of a will be computed from the count of the initializing values. Both var and const arrays can be declared this way. An array variable/constant declared with "*" as an upper bound must have an initializing list. Only one dimensional arrays may be declared in this form. Arrays can be assigned as a whole (to arrays of an equivalent type), but they cannot be compared. An array can be initialized in its declaration using init. For details, see var and const declarations.
|
| Example | In this example, the size of the array is not known until run time.
var howMany : int
get howMany
var height : array 1 .. howMany of real
…read in all the elements of this array…
function total (a : array 1 .. * of real) : real
var sum : real := 0
for i : 1 .. upper (a)
sum := sum + a (i)
end for
result sum
end total
put "Sum of the heights is ", total (height)
|
| Execute | |
| Details | The ends of the range of a subscript are called the bounds of the array. If these values are not known until run time, the array is said to be dynamic. In the above example, height is a dynamic array. Dynamic arrays can be declared as variables, as in the case for height. However, dynamic arrays cannot appear inside other types such as records, and cannot be named types. Dynamic arrays cannot be assigned and cannot be initialized using init. In the above example, upper(a) returns the size of a. See also upper and lower. In the declaration of an array parameter, the upper bound can be given as an asterisk (*), as is done in the above example. This means that the upper bound is taken from that of the corresponding actual parameter (from height in this example). You can have arrays of other types, for example arrays of record. If R is an array of records, then R(i).f is the way to access the f field of the i-th element of array R.
|
| Details | Arrays can also be made resizeable. This is done using the flexible keyword. The declaration syntax is:
var name : flexible array indexType { , indexType } of typeSpec
The indices may have compile-time or run-time upper bounds (the lower bound must be compile-time). The upper bounds can be changed by using:
new name , newUpper1 {,newUpper2}
The existing array entries will retain their values, except that any index made smaller will have the corresponding array entries lost. Any index made larger will have the new array entries uninitialized (if applicable).Additionally, the upper bound (both in the declaration and the new statement) can be made one less than the lower bound. This effectively makes an array that contains 0 elements. It can later be increased in size with another new. In the current implementation (2002), with a multi-dimensional array with a non-zero number of total elements, it is a run-time error to change any but the first dimension (unless one of the new upper bounds is one less than the corresponding lower bound, giving 0 elements in the array) as the algorithm to rearrange the element memory locations has not yet been implemented. Currently, only variables can be declared in this form. There is no flexible array parameter type, although a flexible array can be passed to an array parameter with “*” as the upper bound.
|
| Example | In this example, the array is resized to fit the number of elements in the file.
function getLines (fileName : string) : int
var f, numLines : int
var line : string
open : f, fileName, get
numLines := 0
loop
exit when eof (f)
get : f, line : *
numLines += 1
end loop
close : f
result numLines
end getLines
procedure readFile (var lines : array 1 .. * of string, fileName : string)
var f : int
var line : string
open : f, fileName, get
for i : 1 .. upper (lines)
get : f, lines (i) : *
end for
close : f
end readFile
var lines : flexible array 1 .. 0 of string
new lines, getLines ("text.dat")
readFile (lines, "text.dat")
for i : 1 .. upper (lines)
put lines (i)
end for
|
| Execute | |
| See also | init to initialize arrays, flexible to declare resizable arrays and indexType to specify the index of an array.
|