Fortran 90 Pointers, QUB

The Queen's University of Belfast

Parallel Computer Centre

[Next] [Previous] [Top]

Pointers

Topics

What is a pointer
Specifications
Pointer assignment
Pointer status
Dynamic storage
Pointer arguments
Pointer functions
Arrays of pointer
Linked list

What is a pointer?

A pointer variable has the POINTER attribute and may point to:

Another data object of the same type, which has the TARGET attribute, or
An area of dynamically allocated memory

Specifications

type [[,attribute]... ::] list of variables

Where attribute includes:
- POINTER for a pointer variable, or
- TARGET for a target variable
The type, type parameters and rank of a pointer must be the same as the type and rank of any target to which it is pointing
If a pointer is an array pointer, only the rank, not the shape, need be defined

REAL, DIMENSION(20), POINTER :: p ! illegal

 REAL, DIMENSION(:), POINTER :: p          ! legal

Pointer assignment

=>

 REAL, POINTER :: p1, p2

 REAL, TARGET :: t1 = 3.4, t2 = 4.5

 p1 => t1

 PRINT *, t1, p1      ! all 3.4

 p2 => t2

 PRINT *, t2, p2      ! all 4.5

p2 => p1 PRINT *, t1, p1, p2 ! all 3.4

t1 = 5.2 PRINT *, t1, p1, p2 ! all 5.2

Pointer assignment

Vs ordinary assignment

 REAL, POINTER :: p1, p2

 REAL, TARGET :: t1 = 3.4, t2 = 4.5

 p1 => t1

 PRINT *, t1, p1      ! all 3.4

 p2 => t2

 PRINT *, t2, p2      ! all 4.5

p2 = p1 ! Equivalent to t2 = t1 ! So p1 = p2 = t1 = t2 = 3.4 PRINT *, t1, t2, p1, p2 ! all 3.4

Array pointers

 REAL, DIMENSION (:), POINTER :: pv1

 REAL, DIMENSION (-3:5), TARGET :: tv1

 pv1 => tv1     ! pv1 aliased to tv1

pv1 => tv1(:) ! pv1 points to tv1 with ! section subscript

pv1 => tv1(1:5:2) ! pv1 points to a section of ! tv1 with subscript triplet

REAL, DIMENSION (:), POINTER :: pv1 REAL, DIMENSION (:, :), POINTER :: pv2 REAL, DIMENSION (5, 10), TARGET :: tv pv1 => tv(4, :) ! pv1 aliased to the 4th row of tv

pv2 => tv(2:4, 4:8)

Pointer status

Undefined - As at start of program
Null - Not the alias of any data object

Must not reference undefined pointer, so set to null with NULLIFY statement
Associated - The alias of a data object

The status can be tested by ASSOCIATED intrinsic function, for example:

 REAL, POINTER :: p       ! p undefined

 REAL, TARGET :: t       

 PRINT *, ASSOCIATED (p)       ! not valid

 NULLIFY (p)

 PRINT *, ASSOCIATED (p)       ! .FALSE.

 p => t

 PRINT *, ASSOCIATED (p)       ! .TRUE.

Dynamic storage

ALLOCATE and DEALLOCATE

Can allocate storage for a pointer to create an un-named variable or array of specified size with implied target attribute:

 REAL, POINTER :: p

 REAL, DIMENSION (:, :), POINTER :: pv

 INTEGER :: m, n

 ...

 ALLOCATE (p, pv(m, n))

Can release storage when no longer required:

DEALLOCATE (pv) ! pv is in null status

Before assignment like p = 3.4 is made, p must be associated with its target via ALLOCATE, or aliased with target via pointer assignment statement

Danger!

Dangling pointer

 REAL, POINTER :: p1, p2

 ALLOCATE (p1)

 p1 = 3.4

 p2 => p1

 ...

 DEALLOCATE (p1)

Unreferenced storage

 REAL, DIMENSION(:), POINTER :: p

 ...

 ALLOCATE(p(1000))

 ...

 NULLIFY(p)     ! nullify p without first deallocating it

Pointer arguments

Pointers, whether allocated or not, are allowed to be procedure arguments (allocatable arrays can not be dummy arguments and only allocated allocatable arrays can be actual argument)
If a procedure has a pointer or target dummy argument, the interface to the procedure must be explicit
If a dummy argument is a pointer, then the actual argument must be a pointer with the same type, type parameter and rank
A pointer dummy argument can not have the intent attribute
If the actual argument is a pointer but the dummy argument is not, the dummy argument becomes associated with the target of the pointer

Example

 ...      ! calling program unit

 INTERFACE      ! do not forget interface

  SUBROUTINE sub2(b)     

   REAL, DIMENSION(:, :), POINTER :: b

  END SUBROUTINE sub2

 END INTERFACE

 REAL, DIMENSION(:, :), POINTER :: p

 ...

 ALLOCATE (p(50, 50))

 CALL sub1(p)      ! both sub1 and sub2

 CALL sub2(p)      ! are external procedures

 ...



   SUBROUTINE sub1(a)      ! a is not a pointer

  REAL, DIMENSION(:, :) :: a

  ...

 END SUBROUTINE sub1

  

 SUBROUTINE sub2(b)      ! b is a pointer

  REAL, DIMENSION(:, :), POINTER :: b

  ...

 END SUBROUTINE sub2

Pointer functions

A function result may also have the POINTER attribute
Useful if the result size depends on calculations performed in the function
The result can be used in an expression, but must be associated with a defined target
The interface to a pointer function must be explicit

Example

...

IMPLICIT NONE

INTEGER, DIMENSION(100) :: x

INTEGER, DIMENSION(:), POINTER :: p

...

p => gtzero(x)

...

CONTAINS

 ! function to get all values .gt. 0 from a

 FUNCTION gtzero(a)

  INTEGER, DIMENSION(:), POINTER :: gtzero

  INTEGER, DIMENSION(:) :: a

  INTEGER :: n

  ...  ! find the number of values .gt. 0, n

  ALLOCATE (gtzero(n))

  ...  ! put the found values into gtzero

 END FUNCTION gtzero

 ...

END

Arrays of pointers

An array of pointers can not be declared directly:

REAL, DIMENSION(20), POINTER :: p ! illegal

An array of pointers can be simulated by means of a derived type having a pointer component:

 TYPE real_pointer

  REAL, DIMENSION(:), POINTER :: p

 END TYPE real_pointer

 TYPE(real_pointer), DIMENSION(100) :: a

 INTEGER :: i

 ...

 ! possible to refer to the ith pointer by a(i)%p

 DO i = 1, 100     

  ALLOCATE (a(i)%p(i)) 

 END DO

Linked list

A pointer component of a derived type can point at an object of the same type; this enables a linked list to be created

 TYPE node

  INTEGER :: value       ! data field

  TYPE (node), POINTER :: next       ! pointer field

 END TYPE node

A linked list typically consists of objects of a derived type containing fields for the data plus a field that is a pointer to the next object of the same type in the list
In a linked list, the connected objects
- Are not necessarily stored contiguously
- Can be created dynamically at execution time
- May be inserted at any position in the list
- May be removed dynamically
The size of a list may grow to an arbitrary size as a program is executing
Trees or other dynamic data structures can be constructed in a similar way

Example

 ...

 TYPE node

  INTEGER :: value       ! data field

  TYPE (node), POINTER :: next       ! pointer field

 END TYPE node



 INTEGER :: num

 TYPE (node), POINTER :: list, current

NULLIFY(list) ! initially nullify list (empty)

 DO    

  READ *, num    ! read num from keyboard 

  IF (num == 0) EXIT     ! until 0 is entered

  ALLOCATE(current)     ! create new node

  current%value = num    

  current%next => list     ! point to previous one

  list => current     ! update head of list

 END DO

 ...

If, for example, the values 1, 2, 3 are entered in that order, the list looks like (progressively):

After NULLIFY(list)

After the first num is read

After all 3 numbers are read

[Next] [Previous] [Top]

All documents are the responsibility of, and copyright, © their authors and do not represent the views of The Parallel Computer Centre, nor of The Queen's University of Belfast.
Maintained by Alan Rea, email A.Rea@qub.ac.uk

Generated with CERN WebMaker