如何模塊

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模塊測試）。例如，我想要做一些像數組（3，：）=數組（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