Question

有没有办法让派生类型有一个接口，以便为泛型派生类型调用特定的模块过程？我可能没有正确解释这个问题，但这里是我想做的简短示例代码：

  module test_mod
  implicit none

  private
  public :: type_AB ! This is what I'd like to do...
  public :: init,apply,delete

  interface type_AB ! This is what I'd like to do...
  module type type_AB
  end interface

  interface init;    module procedure init_A;      end interface
  interface init;    module procedure init_B;      end interface
  interface apply;   module procedure apply_A;     end interface
  interface apply;   module procedure apply_B;     end interface

  type type_A
    integer :: x
  end type

  type type_B
    integer,dimension(3) :: x
  end type

  contains

  subroutine init_A(AB,x)
    implicit none
    type(type_A),intent(inout) :: AB
    integer,intent(in) :: x
    AB%x = x
  end subroutine

  subroutine init_B(AB,x)
    implicit none
    type(type_B),intent(inout) :: AB
    integer,dimension(3),intent(in) :: x
    AB%x = 2
  end subroutine

  subroutine apply_A(AB,x)
    implicit none
    type(type_A),intent(inout) :: AB
    integer,intent(in) :: x
    AB%x = AB%x + x
  end subroutine

  subroutine apply_B(AB,x)
    implicit none
    type(type_B),intent(inout) :: AB
    integer,dimension(3),intent(in) :: x
    AB%x = AB%x + x
  end subroutine

  end module

当我使用test_mod时，我可以简单地使用type_AB而不是指定type_A或type_B。我知道我可以指定两个对象，但它们基本上是相同的，除了排名，所以有一种组合/多态对象会很好，但我宁愿不嵌入第二个派生输入一个。例如：

 type type_AB
   type(type_A) :: A
   type(type_B) :: B
 end type

因为它会使类文件更混乱（如果AB的类型为type_AB，则引用x变为，例如AB％A％x而不是AB％x）。如果这是唯一的方法，那么我想我可以做到，但我想知道是否还有其他选择。此外，如果使用type_A，使用组合/多态方法会增加需要在type_B内释放任何内容的烦恼，反之亦然。

我想其他人可能会以更好的方式提出这个问题，但是当我查看示例时，大多数人似乎都使用了f2003标准，我对此并不熟悉。非常感谢您回答或改进问题，谢谢。

更新

我尝试按照建议实现类型扩展，但这是我能够得到的。

module type_AB_mod
implicit none
private
public :: type_AB ! This is what I'd like to do...
public :: init
interface init;    module procedure init_A;      end interface
interface init;    module procedure init_B;      end interface
type type_AB
  logical :: L
end type
type, extends(type_AB) :: type_A
  integer :: x
end type
type, extends(type_AB) :: type_B
  integer,dimension(3) :: x
end type
contains
subroutine init_A(AB,x)
  implicit none
  type(type_A),intent(inout) :: AB
  integer,intent(in) :: x
  AB%x = x
  write(*,*) 'Init A'
end subroutine
subroutine init_B(AB,x)
  implicit none
  type(type_B),intent(inout) :: AB
  integer,dimension(3),intent(in) :: x
  AB%x = 2
  write(*,*) 'Init B'
end subroutine
end module
program test
use type_AB_mod
implicit none
type(type_AB) :: AB
integer :: i
integer,dimension(3) :: j
call init(AB,i)
call init(AB,j)
end program

我收到两个错误，两个错误都是：

 There is no specific subroutine for the generic 'init'

参考call init(AB,i)和call init(AB,j)

更新2：

我已调整示例以包含提供的答案：

  module type_AB_mod
  implicit none
  private
  public :: type_AB ! This is what I'd like to do...
  public :: init
  interface init;    module procedure init_A;      end interface
  interface init;    module procedure init_B;      end interface
  type type_AB
  end type
  type, extends(type_AB) :: type_A
    integer :: x
  end type
  type, extends(type_AB) :: type_B
    integer,dimension(3) :: x
  end type
  contains
  subroutine init_A(AB,x)
    implicit none
    type(type_AB),allocatable,intent(inout) :: AB
    integer,intent(in) :: x
    allocate(AB, source=type_A(x=x))
    write(*,*) 'Init A'
  end subroutine
  subroutine init_B(AB,x)
    implicit none
    type(type_AB),allocatable,intent(inout) :: AB
    integer,dimension(3),intent(in) :: x
    allocate(AB, source=type_B(x=x))
    write(*,*) 'Init B'
  end subroutine
  end module
  program test
  use type_AB_mod
  implicit none
  class(type_AB),allocatable :: AB
  integer :: i
  integer,dimension(3) :: j
  call init(AB,i)
  deallocate(AB)
  call init(AB,j)
  deallocate(AB)
  end program

但我仍然遇到编译器错误：

  allocate(AB, source=type_B(x=x))
           1          2
  Error: Type of entity at (1) is type incompatible with source-expr at (2):
  allocate(AB, source=type_A(x=x))
           1          2
  Error: Type of entity at (1) is type incompatible with source-expr at (2):

Answer 1

AB属于type_AB类型，您对通用init的具体流程适用于type_A和type_B类型。所以确实没有匹配。

您表示您希望了解对此的多态方法，以便所有内容都基于主程序中的type_AB。

对于多态，变量具有声明的和动态类型。可以是type_A或type_B的变量将声明类型type_AB和动态类型，以适合当时的情况。

我们声明这样的变量已经通过

声明了类型type_AB

class(type_AB), allocatable :: AB    ! Or POINTER

我们可以将其设置为

的动态类型type_A

allocate (type_A :: AB)

（type_B 经过必要的变更）。

这导致了通用解决方案。我们仍然消除了参数x的等级的歧义，但是两个特定的过程都声明了类型type_AB（毕竟，你想根据另一个参数设置变量的动态类型，所以它不能用来消除歧义。）

subroutine init_A(AB,x)
  class(type_AB), allocatable, intent(out) :: AB
  integer, intent(in) :: x
end subroutine

subroutine init_B(AB,x)
  class(type_AB), allocatable, intent(out) :: AB
  integer, intent(in) :: x(3)
end subroutine

这些并不含糊。剩下的就是在每个子例程中建立参数AB的动态类型和值。

为了清楚起见，我假设type_AB没有组件L。您可以稍后进行必要的修改。

在每个子程序中使用内部赋值，例如

 AB = type_A(x=x)

和

 AB = type_B(x=x)

将处理动态类型和值。

但是，目前所有编译器都不支持此功能，因此您还有其他选项

 allocate(AB, source=type_A(x=x))

或

 allocate(type_A :: AB)
 ! ... setting the component AB%x is not trivial, but outside scope of answer

在调用相应的特定子例程后，程序中AB的动态类型与预期一致。

它使用上面type_A和type_B的构造函数，其中使用了删除组件L的简化。这是在更一般的情况下应该注意的地方。

最后，在我说'{34}}或type_A＆＃34;的情况下，声明类型为type_B的变量也可以包含动态类型type_AB。使这种抽象类型消除了这种可能性。

Fortran通过程序调用选择派生类型

1 个答案: