抽象类型子例程数组 - Fortran

Question

关于我将如何（或可以）在 Fortran 中使用类型，我可能有一个奇怪的问题。

基本上，到目前为止我所拥有的是一个 抽象类型 AbsBase 与 han 接口。我现在可以通过定义 Child types 多次扩展此类型，其中我对 sub 有不同的定义，就像这样

工作示例

---

基础模块

module BaseClass

    implicit none

    type, abstract :: AbsBase
    contains
        procedure(subInt), nopass, deferred :: sub
    end type

    interface
        subroutine subInt
            implicit none
        end subroutine subInt
    end interface

end module BaseClass

儿童莫鲁德 1

module ChildClass1

    use BaseClass 

    implicit noone

    type, extends(AbsBase) :: Child1
    contains
        procedure, nopass :: sub
    end type

contains

    subroutine sub
        implicit none
        print*, "Do something ..."
    end sub

end module ChildClass1

Child Molude 2

module ChildClass2

    use BaseClass 

    implicit noone

    type, extends(AbsBase) :: Child2
    contains
        procedure, nopass :: sub
    end type

contains

    subroutine sub
        implicit none
        print*, "Do something else ..."
    end sub

end module ChildClass2

计划

program test

    use ChhildClass1
    use ChhildClass2

    implicit none

    type(Child1) :: c1
    type(Child2) :: c2


    call c1%sub    ! <-- prints "Do something ...      "
    call c2%sub    ! <-- prints "Do somethhing else ..."

end program test

到目前为止一切都很好，但是如果我想定义一个类型的 array 而不是拥有 2 个不同的 Child 类型怎么办？我已经尝试了以下

无效示例（我尝试做的）

---

基础模块

module BaseClass

    implicit none

    type, abstract :: AbsBase
    contains
        procedure(subInt), nopass, deferred :: sub
    end type

    interface
        subroutine subInt
            implicit none
        end subroutine subInt
    end interface

    type :: BaseWrap
        class(AbsBase), pointer :: p
    end type

end module BaseClass

计划

program test

    use BaseClass

    implicit none

    type(BaseWrap) :: Child(2) 

    call Child(1)%p%sub   ! <--- This should produce "Do something ..."
    call Child(2)%p%sub   ! <--- This should produce "Do something else ..."

contains

    ! Where to I define the subroutines and how would I do this?

end module ChildClass

它实际上可以编译（这对我来说非常令人惊讶），但显然会导致 分段错误，因为我没有在任何地方定义子例程。如果我理解正确，那么我得到了type(BaseWrap) :: Child(2) 一个指针数组，它指向抽象类型AbsBase 的接口。我现在如何定义 工作示例 中的两个子例程？这可能吗？

谢谢！

Answer 1

好吧，您创建的类足以具有您似乎正在寻找的多态行为。你可以这样测试：

program test
  use :: BaseClass
  implicit none

  type(Child1), target :: c1
  type(Child2), target :: c2
  type(BaseWrap) :: child(2)

  child(1)%p => c1
  child(2)%p => c2

  call child(1)%p%sub    ! <-- prints "Do something ...      "
  call child(2)%p%sub    ! <-- prints "Do somethhing else ..."
end

但是使用allocatable 元素而不是pointer 将消除target 属性的必要性以及其他优点。

Answer 2

当这些子程序以某种方式与类型、我们的数据等紧密相关时，您的设计是好的。您只需要像 Rodrigo 所示的那样定义指针。如果这些子例程实际上不依赖于任何外部类型，并且子类型实际上只是为了各自保存不同的过程，那么您不需要如此复杂的构造。您可以只将过程指针存储在单一类型中。

module subs
  implicit none

contains

    subroutine sub1
        print*, "Do something ..."
    end subroutine
    subroutine sub2
        print*, "Do something else ..."
    end subroutine
end module

  use subs

  type sub_wrap
    procedure(sub1), pointer, nopass :: sub
  end type

  type(sub_wrap) :: a(2)

  !one way
  a = [sub_wrap(sub1), sub_wrap(sub2)]

  !another way
!   a(1)%sub => sub1
!   a(2)%sub => sub2

  call a(1)%sub()
  call a(2)%sub()
end