[Next] [Previous] [Top]

Pointer Variables

Pointer variables

Topics

• What are pointers.

• Specifications.

• Pointer assignment.

• Pointer status.

• Dynamic storage.

• Array pointers.

• Pointers within derived data types.

• Pointers as arguments.

• Pointer functions.

What are Pointers?

Pointers and targets

• Reference data stored by other variables or areas of dynamically allocated memory (through association).

• Pointers may point to:
  • variables of the same data type with the TARGET attribute,

  • other pointers of the same data type,

  • dynamic memory allocated to the pointer.

• Memory requirements of a pointer are handled dynamically.

Specifications

Form

• The attribute list must include:
  • POINTER for pointer variables, or

  • TARGET for target variables.

• Pointers and targets must have matching types and rank.

• Array pointers (like allocatable arrays) must not be defined with a shape.

• Examples:

INTEGER, POINTER :: first, current, last

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

REAL, TARGET :: a(3), b(6), c(9)

Pointer assignment

= and =>

• = (assignment operator)
  • changes the value of the data pointed to.

• => (pointer assignment operator)
  • changes the pointer's target,

  • allocates storage as required.

• Example:

INTEGER, TARGET :: x=34, y=0

pt => x ! pt points to x

y = pt ! y equals x

pt => y ! pt points to y

pt = 17 ! y equals 17

Example

Dereferencing

• Pointers in expressions are always dereferences:

pt = 17 !target = 17

IF( pt<0 ) THEN !target < 0

...

• I/O always causes a pointer to be dereferenced and its target to be written:

WRITE(6,*) pt !output is y

READ(5,*) pt !input into y

A pointer must be associated with a target to be dereferenced.

Pointer status

• Associated.
  • pointing to a valid target.

• Disassociated.
  • result of a NULLIFY statement.

• Undefined.
  • initial state on declaration,

  • pointing to a target which no longer exists (e.g. target which has been deallocated).

• A pointer becomes disassociated through the NULLIFY statement:

  NULLIFY( pointer )

  Nullified pointers can be thought of as `pointing at nothing'.

• The status of a pointer may be found using:

  ASSOCIATED( pointer [,TARGET] )

• .TRUE. if pointer points to a valid target (or to TARGET, if present),

• .FALSE. if pointer has been nullified (or points to a target other than TARGET, if present).

Example

REAL, TARGET :: t1, t2

...

test = ASSOCIATED( pt ) !illegel

pt => t1

test = ASSOCIATED( pt ) !t

test = ASSOCIATED( pt, t1 ) !t

test = ASSOCIATED( pt, t2 ) !f

...

NULLIFY( pt )

test = ASSOCIATED( pt ) !f

Dynamic storage

ALLOCATE and DEALLOCATE

• Pointers can be allocated storage to create an un-named variable or array of:
  • specified size,

  • implied target attributes.

• Allocated storage can be released when no longer required.

• Example:

...

ALLOCATE( p, pa(100) )

p = 100

pa = 0

...

DEALLOCATE( pa, p) !undefined

Common pointer errors

• Memory leak.

  INTEGER, POINTER :: pt(:)

  ...

  ALLOCATE( pt(25) )

  NULLIFY( pt )

  No way to reference the allocated storage (pt now points elsewhere).

• Leaving pointers `dangling'.

  REAL, POINTER :: p1, p2

  ...

  ALLOCATE( p1 )

  p2 => p1

  DEALLOCATE( p1 )

  p2's target no longer exists (undefined state). Dereferenced data unpredictable!

Array pointers

REAL, TARGET :: grid(10,10)

REAL, POINTER :: centre(:,:), row(:)

centre => grid(4:7,4:7)

row => grid(9,:)

• useful when an array section is referenced frequently, and can save copying data.

• Can be dynamically resized as required.

Derived data types

Pointer components

• Pointers may act as allocatable arrays in a derived data type.

REAL, POINTER :: a(:)

END TYPE data

TYPE(data) :: event(3)

DO i=1, 3

READ(5,*) n

ALLOCATE( event(i)%a(n) )

READ(5,*) event(i)%a

END DO

Linked lists

TYPE list

REAL :: item

TYPE( list ), POINTER :: next

END TYPE list

• A linked list consists of:
  • One or more objects in a derived data type, plus

  • a pointer to the next object in the list.

Note - recursion-like property in declaration allowing the pointer to reference its own data type.

Pointer arguments

• Actual and dummy arguments must have the same data type (and rank).

• Dummy arguments that are pointers or targets require an explicit interface.

• Dummy arguments that are pointers cannot have the INTENT attribute.

• Both arguments (actual and dummy) are pointers:
  • pointer status is passed on reference and return,

  • care must be taken to ensure a target remains valid.

• Actual argument is a pointer while the corresponding dummy argument is not:
  • pointer must be associated with a target,

  • target is passed on call (automatic dereferencing),

  • target takes the value of the dummy argument on return.

• Actual argument is non-pointer while corresponding dummy argument is a pointer - not allowed.

Example

SUBROUTINE suba( a )

REAL, POINTER :: a(:)

END SUBROUTINE suba

END INTERFACE

REAL, POINTER :: pt(:)

REAL, TARGET :: data(100)

...

pt => data

CALL suba( pt )

CALL subb( pt )

...

SUBROUTINE subb( b ) !internal

REAL :: b(:) !size=100

...

SUBROUTINE suba( a ) !external

REAL, POINTER :: a(:)

...

Pointer functions

• Useful where the size of the result depends on the function's calculation.

• The result must have the POINTER attribute.

• Care must be taken to ensure the result is associated with either:
  • a valid target (i.e. one that is not local to the function), or

  • has been nullified.

Example

FUNCTION max_row ( a )

REAl, TARGET :: a(:,:)

REAL, POINTER :: max_row(:)

END FUNCTION max_row

END INTERFACE

REAL, TARGET :: a(3,3)

REAL, POINTER :: p(:)

...

p => max_row ( a )

...

FUNCTION max_row ( a )

REAL, TARGET :: a(:,:)

REAL, POINTER :: max_row(:)

INTEGER :: location(2)

location = MAXLOC( a )

max_row => a(location(1),:)

END FUNCTION max_row