Styjun

Basically, I have an abstract class a wrapper class and a base class which are defined in the Base Module. The abbstract class holds an allocatable array and a subroutine. In the constructor I want to allocate this array but that does not work.

The allocation does work for Base but I guess that is not what I want as the Child Class does not know anything from Base. How would I do this allocation?

Here's what I have:

Base Module

module BaseClass

 implicit none

 ! ------------------------
 ! ABSTRACT CLASS
 ! ------------------------
 type, abstract :: AbsBaseHelper
 real, allocatable :: A(:) !! <-- this makes problems
 contains
 procedure :: construct
 procedure(help_int), deferred :: help
 end type

 ! ------------------------
 ! WRAPPER CLASS
 ! ------------------------
 type :: BaseWrap
 integer :: cI
 class(AbsBaseHelper), pointer :: p
 contains
 procedure :: do_something
 end type

 ! ------------------------
 ! INTERFACE
 ! ------------------------
 interface
 subroutine help_int(this)
 import AbsBaseHelper
 implicit none
 class(AbsBaseHelper), intent(inout) :: this
 end subroutine help_int
 end interface

 ! ------------------------
 ! BASE CLASS
 ! ------------------------
 type(BaseWrap) :: Base(2)

contains

 ! ------------------------
 ! CONSTRUCTOR
 ! ------------------------
 subroutine construct(this, id)

 implicit none
 class(AbsBaseHelper), intent(in), target :: this
 integer, intent(in) :: id

 Base(id)%cI = id
 ! allocate( this%A(2) ) !! <-- does not work because this is only intent(in)
 Base(id)%p => this
 allocate( Base(id)%p%A(2) ) !! <-- does not work because it gives segmentation fault in 'help'

 end subroutine construct

 ! ------------------------
 ! THE MAIN SUBROUTINE
 ! ------------------------
 subroutine do_something(this)

 implicit none

 class(BaseWrap), intent(inout) :: this

 print*, "Base Index : ", this%cI
 call this%p%help()
 print*, "Result 1 : ", this%p%A(1)
 print*, "Result 2 : ", this%p%A(2)

 end subroutine do_something

end module BaseClass

Child Module

module ChildClass1

 use BaseClass

 implicit none

 type, extends(AbsBaseHelper) :: Child1
 contains
 procedure :: help
 end type

contains

 subroutine help(this)
 implicit none
 class(Child1), intent(inout) :: this

 this%A(1) = 1 !! <-- produces segmentation fault
 this%A(2) = 2
 end subroutine

end module ChildClass1

The Program

program test

 use BaseClass

 implicit none

 call init
 call Base(1)%do_something()

contains

 ! ------------------------
 ! INITIALIZE
 ! ------------------------
 subroutine init

 use ChildClass1

 implicit none

 type(Child1), target :: c1

 call c1%construct(1)

 end subroutine init

end program test