forums.silverfrost.com

[dpannhorst]

How can I pass a dynamically allocated array to a subroutine and get the actual bounds of this array?

I tried this:

[PaulLaidler]

[dpannhorst]

Hi Paul,

thank you very much; this is working.

But the next stage for my code is to resize this array. Therefore I tried:

[PaulLaidler]

I am not sure if you can do what you are aiming to do.

My Fortran is a bit rusty in this area.

I think that you can ALLOCATE in a subroutine and pass a pointer back but maybe the reverse is not sensible.

Do you have to DEALLOCATE at a lower subroutine level?

[mecej4]

[PaulLaidler]

If the extension is in the 2003 Standard then maybe it can be added to FTN95.

In the mean time the following works. It just means that you have to pass your own flag to say whether or not the array has been allocated...

[davidb]

Allocatable dummy array arguments are only available in Fortran 2003 and Fortran 2008 (as Paul has guessed).

You can get almost exactly the same functionality in Fortran 95 using pointers. The following code gives a simple example of how to do it.

Here I create the array to be of size 10 in the subroutine, but you can use a variable and make it variable size.

[dpannhorst]

Thanks for all the help. The workaround with POINTER is very useful.

This code is working in my intention:

[JohnCampbell]

Another solution might be to define the allocatable array in a module then access the module via USE. With this approach, you can resize the array.
I'm not sure if this is what you want, but you can resize the array, by:
-allocate a temporary array the same as the old size,
-store the old values (assuming that you need them)
-deallocate the array
-allocate the array for the new size
-define the new array from the values in the temporary array
-deallocate the temporaty array.

This approach requires storage for 2-3 x the array size, which can be a significant problem. You can always write the array to disk !! (32-bit solution), or resort to LOC and CORE4.

I use this approach if I have to increase the size of a key database array, such as the list of node coordinates or the node list index.
By having these allocatable arrays in a MODULE, this approach avoids the use of pointers.
Allocatable arrays defined in a module provide a very flexible approach to adjusting problem size.

John

[davidb]

Detlef,

What does ITEMP do in your latest code?

This is John's algorithm to make an array bigger using your POINTER dummy argument approach.

[JohnCampbell]

Another point for this post, is that I use the ALLOCATABLE status only associated with where the array is origionally defined and sized. I then restrict my use of the array in any argument list to having flexible dimension, such as:
integer, dimension(:) :: array
or
integer array(*)

Both declarations work well for me, but might not be utilising some capability of fortran you are searching for.
I only ever change the allocatable array at the top of the scope where it is used. ( I'm not sure you can change it lower down where it is being supplied via an argument list)

John

[davidb]