如何从模块中的所有变量创建数组数组

Question

我在一个模块中声明了许多变量，例如

module test

use othermod, only: n

integer, dimension(n) :: var0
real, dimension(n) :: var1
real, dimension(n) :: var2
..... 
real, dimension(n) :: var1000

end module test

然后我有一个用值填充这些变量的子程序。 此时我想创建一个包含在模块测试中声明的所有变量的数组数组，以便我可以轻松地同时复制或打印特定（n）的所有变量，例如维度（n，allvariablesin module test） .例如，我想做一些类似 array(3,:)=array(2,:) 的事情。 因为这段代码是一个非常大的程序的一部分，所以我不能真正修改太多，而是我需要从这个模块中的所有变量创建一个数组数组，而不需要输入所有变量。 如何轻松地将这种更改集成到当前代码中？

Answer 1

我敦促您遵循@Vladimir F 的建议，并将您的变量封装在派生数据类型中。您可以使用 associate 构造来调用期望 var0, var1, .., 等的旧代码。最后，我们可以重载类型的名称以在下面的代码中获取 Java 样式构造函数

module type_MyArray

  implicit none
  private

  type, public :: MyArray
     ! type-components
     real, dimension(:), allocatable :: var0, var1, var2
   contains
     ! type-bound procedures
     procedure :: create => create_my_array
     procedure :: destroy => destroy_my_array
  end type MyArray

  interface MyArray
     module procedure my_array_constructor
  end interface MyArray

contains

  pure function my_array_constructor(n) result (return_value)
    ! Dummy arguments
    integer, intent (in) :: n
    type (MyArray)       :: return_value

    call return_value%create(n)

  end function my_array_constructor


  pure subroutine create_my_array(self, n)
    ! Dummy arguments
    class(MyArray), intent(in out) :: self
    integer,        intent(in)     :: n

    allocate( self%var0(n) )
    allocate( self%var1(n) )
    allocate( self%var2(n) )

  end subroutine create_my_array


  pure subroutine destroy_my_array(self)
    ! Dummy arguments
    class(MyArray), intent(in out) :: self

    if (allocated(self%var0)) deallocate( self%var0 )
    if (allocated(self%var1)) deallocate( self%var1 )
    if (allocated(self%var2)) deallocate( self%var2 )

  end subroutine destroy_my_array

end module type_MyArray

program main

  use type_MyArray, only: MyArray
  use old_code,     only: do_something

  implicit none

  type (MyArray) :: foo, bar

  ! Allocate memory
  foo = MyArray(42)
  bar = MyArray(4200)

  associate( var0 => foo%var0, var1 => bar%var1 )

    ! Call old code using var0 and var1
    call do_something(var0, var1)

  end associate

  ! Release memory
  call foo%destroy()
  call bar%destroy()

end program main