Hi,
I have a problem (getting SEGFAULTS where things should be as
smooth as silk). I have a derived type which has a number of allocatable
arrays (specified as pointers):
type MyType
real :: a, b, c
complex,pointer,dimension(:,:) :: S1, S2, S3
end type MyType
I put some data into my allocated arrays without any problems.
So at this point, S1, S2 and S3 all point to allocated areas of memory
and data sits there quite happily.
I then pass my type to a subroutine:
subroutine MySubroutine(InstanceOfMyType)
type(MyType) :: InstanceOfMyType
type(MyType) :: TemporaryType
In this subroutine, I have a temporary type, which is just a
copy of my argument. What I do is to ALLOCATE some memory for S1, S2 and
S3 in this new temporary type. The copy of the passed argument is done
simply by an equal sign: TemporaryType = InstanceOfMyType. The first
thing I noticed was that the scalar structure members (a, b and c) are
all fine. Because I wanted to change the size of the arrays, I
deallocate S1, S2 and S3 in TemporaryType and allocate them to something
new. I was a bit worried about this, as this is a pointer pointing to a
new area of memory. However, it seems to work. Then I do play around
with that and eventually copy some data to the starting arrays. This all
works fine. Except that the program segfaults returning to the point
where it branched out to the subroutine.
I haven't got a clue why this happens, as everything in the
subroutine works, and the data that is copied into the starting arrays
is copied by value, not just to a pointer or something like that.
Can anyone shed any light?
José
--
José L Gómez Dans PhD student
Tel: +44 114 222 5582 Radar & Communications Group
FAX; +44 870 132 2990 Department of Electronic Engineering
University of Sheffield UK
|