[Next] [Previous] [Top]

Dynamic arrays

Dynamic arrays

Topics

• Static variables.

• Dynamic arrays.

• Automatic arrays.

• Allocatable arrays.
  • definitions,

  • allocating and deallocating storage,

  • array status,

  • restrictions.

• Memory leaks.

Static arrays

Recall

INTEGER, DIMENSION(10) :: x

• Memory requirement:
  • is fulfilled when the procedure begins,

  • is fixed in size, no more than 10 elements can be used and using less than 10 elements is wasteful,

  • exists for as long as that part of the program runs.

    Changing the size of this type of array requires re-compilation.

Variable sized arrays

• Tailoring the size of an array to the data in question can be important when:
  • Storage is at a premium and the memory available to the whole program is restricted.

    and is useful when:

  • Very large arrays are used infrequently.

  • The program is to be used on differing sizes of data.

  • The size of the data is only known at run-time.

• There are several ways of handling variable sized arrays:
  • assumed shape arrays,

  • automatic arrays,

  • allocatable (dynamic) arrays.

Assumed shape and automatic arrays

Recall

SUBROUTINE sub( a )

REAL, DIMENSION(:) :: a !assumed

REAL :: b( SIZE(a) ) !automatic

• Assumed shape arrays:
  • can only be used inside procedures,

  • must match the rank of the actual argument,

  • require an explicit interface.

• Automatic arrays:
  • are local to a procedure and cannot have the SAVE attribute.

Allocatable Arrays

Specification

• May appear in the main program as well as in procedures.
  • but not as a component in a derived data type.

• Have no storage requirements until allocated.

• Examples:

INTEGER, ALLOCATABLE :: b(:,:)

REAL, ALLOCATABLE, DIMENSION(:) :: c

Allocating & deallocating storage

• Allocate storage to an array which already has no associated storage:

• If successful name has the requested size (and STAT=0 if present).

• If unsuccessful - the program stops (or STAT>0 if present).

• Deallocate storage for an array which has associated storage:

  DEALLOCATE( name [, STAT] )

• If successful name has zero size (and STAT=0 if present).

• If unsuccessful the program stops (or STAT>0 if present).

Example

INTEGER, ALLOCATABLE :: b(:,:)

REAL, ALLOCATABLE :: c(:)

INTEGER :: n=10

ALLOCATE( a(100) )

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

...

DEALLOCATE ( a, b )

DEALLOCATE ( c, STAT=test )

IF (test .NE. 0) THEN

STOP `deallocation error'

ENDIF

Each of the above allocation statements give the array in question 100 elements.

Status

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

• `Not currently allocated' - while an array has no associated storage (initial state).

ALLOCATED( name )

• .TRUE. if the status of name is `allocated'.

• .FALSE. if name is `not currently allocated'.

• Example:

Memory leaks

`Undefined' storage

• Recall that local static, assumed and automatic variables:
  • are created and allocated storage when a procedure begins execution,

  • and destroyed when the procedure exits.

    No record of variable names are retained and storage is deallocated automatically.

• The ALLOCATE statement over-rides a program's own management of memory.

  Recover allocated storage via:

• the DEALLOCATE statement.

• the program finishing.

• Allocated storage is not recovered automatically when a procedure exits, even though no record of the variable name is kept.
  • No way to reference stored data.

  • No way to deallocate storage.

• Example:

REAL, DIMENSION(:) :: a, b

REAL, ALLOCATABLE :: work(:)

ALLOCATE( work(SIZE(a)) )

work = a

a = b

b = work

DEALLOCATE( work ) !necessary

END SUBROUTINE swap