[Next] [Previous] [Top]

10 Dynamic arrays

• an array is dimensioned to the largest possible size that will be required, or

• an array is given a new extent, and the program re-complied every time it is run.

10.1 Allocatable arrays

10.1.1 Specification

type, ALLOCATABLE [,attribute] :: name

They must include the ALLOCATABLE attribute and the rank of the array, but cannot specify the extend in any dimension or the shape in general. Instead a colon (:) is used for each dimension. For example:

INTEGER, DIMENSION(:), ALLOCATABLE :: a !rank 1

INTEGER, ALLOCATABLE :: b(:,:) !rank 2

REAL, DIMENSION(:), ALLOCATABLE :: c !rank 1

On declaration, allocatable arrays have no associated storage and cannot be referenced until storage has been explicitly allocated.

10.1.2 Allocating and deallocating storage

ALLOCATE( name(bounds) [,STAT] )

• if successful name has the requested bounds (if present STAT=0).

• if unsuccessful program execution stops (or will continue with STAT>0 if present).

n=10

ALLOCATE( a(100) )

ALLOCATE( b(n,n), c(-10:89) ).

The storage used by an allocatable array may be released at any time using the DEALLOCATE statement:

DEALLOCATE( name [,STAT] )

• If successful arrayname no longer has any associated storage (if present STAT=0)

• If unsuccessful execution stops (or will continue with STAT>0 if present).

The following statements deallocate the storage from the previous example:

DEALLOCATE ( a, b )

DEALLOCATE ( c, STAT=test )

IF (test .NE. 0) THEN

STOP `deallocation error'

ENDIF

It is good programming practice to deallocate any storage that has been reserved through the ALLOCATE statement. Beware, any data stored in a deallocated array is lost permanently!

10.1.3 Status of allocatable arrays

• `allocated' - while an array has associated storage.

• `not currently allocated' - while an array has no associated storage.

AllOCATED( name )

which returns the value:

• .TRUE. if name has associated storage, or

• .FALSE. otherwise.

IF( ALLOCATED(x) ) DEALLOCATE( x )

or:

IF( .NOT. ALLOCATED( x ) ) ALLOCATE( x(1:10) )

On declaration an allocatable array's status is `not currently allocated' and will become `allocated' only after a successful ALLOCATE statement. As the program continues and the storage used by a particular array is deallocated, so the status of the array returns to `not currently allocated'. It is possible to repeat this cycle of allocating and deallocating storage to an array (possibly with different sizes and extents each time) any number of times in the same program.

10.2 Memory leaks

Statements like ALLOCATE and DEALLOCATE are very powerful. Storage allocated through the ALLOCATE statement may only be recovered by:

• a corresponding DEALLOCATE statement, or

• the program terminating.

SUBROUTINE swap(a, b)

REAL, DIMENSION(:) :: a, b

REAL, ALLOCATABLE :: work(:)

ALLOCATE( work(SIZE(a)) )

work = a

a = b

b = work

DEALLOCATE( work ) !necessary

END SUBROUTINE swap

The automatic arrays a and b are static variables, the program allocates the required storage when swap is called, and deallocates the storage on exiting the procedure. The storage allocated to the allocatable array work must be explicitly deallocated to prevent a memory leak.

Memory leaks are cumulative, repeated use of a procedure which contains a memory leak will increase the size of the allocated, but unusable, memory. Memory leaks can be difficult errors to detect but may be avoided by remembering to allocate and deallocate storage in the same procedure.

10.3 Exercises

1. Write a declaration statement for each of the following allocatable arrays:

   (a) Rank 1 integer array.

   (b) A real array of rank 4.

   (c) Two integer arrays one of rank 2 the other of rank 3.

   (d) A rank one real array with lower and upper bound of -n and n respectively.

2. Write allocation statements for the arrays declared in question 1, so that

   (a) The array in 1 (a) has 2000 elements

   (b) The array in 1 (b) has 16 elements in total.

   (c) In 1 (c) the rank two array has 10 by 10 elements, each index starting at element 0; and the rank three array has 5 by 5 by 10 elements, each index starting at element -5.

   (d) The array in 1 (d) is allocated as required.

3. Write deallocation statement(s) for the arrays allocated in 2.

4. Write a program to calculate the mean and the variance of a variable amount of data. The number of values to be read into a real, dynamic array x is n. The program should use a subroutine to calculate the mean and variance of the data held in x. The mean and variance are given by:

   

5. Write a module called tmp_space to handle the allocation and deallocation of an allocatable work array called tmp. The module should contain two subroutines, the first (make_tmp) to deal with allocation, the second (unmake_tmp) to deal with deallocation. These subroutines should check the status of tmp and report any error encountered. Write a program that tests this module.

   The idea behind such a module is that once developed it may be used in other programs which require a temporary work array.