the actual argument (note: the target may be undefined!), it may not have the INTENT attribute (it would be ambiguous), it requires an interface block. If the dummy argument is not a pointer, it becomes associated with the target of the actual argument: REAL, POINTER :: a (:,:) : ALLOCATE (a(80, 80)) : CALL sub(a) : SUBROUTINE sub(c) REAL c(:, :) Pointer functions Function results may also have the POINTER attribute; this is useful if the result size depends on calculations performed in the function, as in USE data_handler REAL x(100) REAL, POINTER :: y(:) : y => compact(x) where the module data_handler contains FUNCTION compact(x) REAL, POINTER :: compact(:) REAL x(:) ! A procedure to remove duplicates from the array x INTEGER n : ! Find the number of distinct values, n ALLOCATE(compact(n)) : ! Copy the distinct values into compact END FUNCTION compact The result can be used in an expression (but must be associated with a defined target). Arrays of pointers These do not exist as such: given TYPE(entry) :: rows(n) then rows%next ! illegal would be such an object, but with an irregular storage pattern. For this reason they are not allowed. However, we can achieve the same effect by defining a derived data type with a pointer as its sole component: TYPE row REAL, POINTER :: r(:) END TYPE and then defining arrays of this data type TYPE(row) :: s(n), t(n) where the storage for the rows can be allocated by, for instance, DO i = 1, n ALLOCATE (t(i)%r(1:i)) ! Allocate row i of length i END DO The array assignment s = tis then equivalent to the pointer assignments s(i)%r => t(i)%r for all components. Pointers as dynamic aliases Given an array REAL, TARGET :: table(100,100) that is frequently referenced with the fixed subscripts table(m:n, p:q) these references may be replaced by REAL, DIMENSION(:, :), POINTER :: window : window => table(m:n, p:q) The subscripts of window are 1:n-m+1, 1:q-p+1. Similarly, for tar%u (as defined in already), we can use, say, taru => tar%u to point at all the u components of tar, and subscript it as taru(1, 2) The subscripts are as those of tar itself. (This replaces yet more of EQUIVALENCE.) In the pointer association pointer => array_expression the lower bounds for pointer are determined as if lbound was applied to array_expression. Thus, when a pointer is assigned to a whole