如何将动态分配的数组传递给子例程

Question

我需要摆脱一些 Fortran 程序使用的库，所以我必须在程序中使用的库中创建所有子例程。

其中一个子例程是由 C 语言完成的内存分配。

我为分配创建了自己的子程序

MODULE ARRAY_ALLOCATION
  CONTAINS
     SUBROUTINE ARRAY_ALLOCATE (ARR, ARR_SIZE, ARR_IDX, CODE_RET)
            ! DECLARE AN ALLOCATABLE PARAMETER
            INTEGER, ALLOCATABLE, INTENT (INOUT) :: ARR(:)
            INTEGER, INTENT (IN) :: ARR_SIZE,ARR_IDX,CODE_RET
            INTEGER :: IDX_END
            IDX_END = ARR_IDX + ARR_SIZE -1
            ALLOCATE (ARR(ARR_IDX:IDX_END))
            RETURN
     END SUBROUTINE ARRAY_ALLOCATE

     SUBROUTINE ARRAY_DEALLOCATE (ARR)
            INTEGER, ALLOCATABLE, INTENT (INOUT) :: ARR(:)
            DEALLOCATE (ARR)
            RETURN
       END SUBROUTINE ARRAY_DEALLOCATE

END MODULE 

但我需要保留像这样integer alist(1) 没有属性allocatable 的数组声明。

例子

    program test1

USE ARRAY_ALLOCATION
implicit none

integer alist(1)

call ARRAY_ALLOCATE(alist,5,3,1)
CALL Test(ALIST)
CALL ARRAY_DEALLOCATE(alist)

错误

error #7976: An allocatable dummy argument may only be argument associated with an allocatable actual argument

有没有办法在声明后创建我的数组allocatable？ 我正在考虑将其设为allocatable（声明后）在子例程中分配内存，这样就不必更改旧程序中的声明。

Answer 1

您可能不想摆脱这些库，而是让代码在其中工作。

通常是这样的： 在图书馆...

MODULE A_Style   !(_*_)
IMPLICIT NONE
PUBLIC: Aye

  CONTAINS
  SUBROUTINE Aye(A)
  REAL, DIMENSION(:), ALLOCATABLE, INTENT(INOUT) :: A
  !...
  IF(ALLOCATED(A)) THEN
    WRITE(*,*)' I see A as A(',LBOUND(A,1),':',UBOUND(A,1),')'
  ELSE
    WRITE(*,*)' I see A as "UNALLOCATED"'
  ENDIF
  !...
  RETURN
  END SUBROUTINE Aye

  SUBROUTINE MakeAye(A, SizeA)
  REAL, DIMENSION(:), ALLOCATABLE, INTENT(INOUT) :: A
  !...
  IF(ALLOCATED(A)A) DEALLOCATE(A)
  ALLOCATE(A(SizeA))
  !...
  RETURN
  END SUBROUTINE MakeAye

END MODULE A_Style

使用库：

PROGRAM TestA
USE A_Style  !(_*_)
IMPLICIT NONE
REAL, DIMENSION(:), ALLOCATABLE :: A
INTEGER                         :: Size_A = 100
...
CALL Aye(A)
ALLOCATE(A(Size_A))
CALL Aye(A)
...
IF(ALLOCATED(A)) DEALLOCATE(A)
END PROGRAM TestA

有时，有趣的是，子例程需要在模块中才能看到 BOUNDS。 INTENT( OUT) 将看不到，因此需要使用 (INOUT) 或 (IN )。

Answer 2

有没有办法让我的数组在声明后可分配？我正在考虑使其可分配（在声明后）在子例程中分配内存，这样就不必更改旧程序中的声明。

没有。

错误信息非常明确。您不能将不可分配数组作为参数传递给需要可分配数组的函数。

以下声明：

integer alist(1)

正在创建一个大小为 1 的 1 维数组。

如果您希望您的数组是动态分配的，您必须将它们更改为可分配的或使用指针。

编辑

从这里开始：http://web.stanford.edu/class/me200c/tutorial_77/12_arrays2.html

大多数程序员更喜欢使用星号符号来强调“实际数组长度”是未知的。一些旧的 Fortran 77 程序可能会像这样声明可变长度数组：

  real x(1), y(1)

即使数组长度大于一，这也是合法的语法！ 但这是一种糟糕的编程风格，强烈建议不要这样做。

附：此表示法在 INSIDE 子例程中用于定义可变长度数组参数。

编辑 2

以下代码基于您的代码，演示了 allocatable 的使用。

MODULE ARRAY_ALLOCATION
CONTAINS
 SUBROUTINE ARRAY_ALLOCATE (ARR, ARR_SIZE, ARR_IDX, CODE_RET)
        ! DECLARE AN ALLOCATABLE PARAMETER
        INTEGER, ALLOCATABLE, INTENT (INOUT) :: ARR(:)
        INTEGER, INTENT (IN) :: ARR_SIZE,ARR_IDX,CODE_RET
        INTEGER :: IDX_END
        IDX_END = ARR_IDX + ARR_SIZE -1
        ALLOCATE (ARR(ARR_IDX:IDX_END))
        ARR = 1
        RETURN
 END SUBROUTINE ARRAY_ALLOCATE

 SUBROUTINE ARRAY_DEALLOCATE (ARR)
        INTEGER, ALLOCATABLE, INTENT (INOUT) :: ARR(:)
        DEALLOCATE (ARR)
        RETURN
   END SUBROUTINE ARRAY_DEALLOCATE

subroutine Create (arr)
    INTEGER, ALLOCATABLE, INTENT (INOUT) :: ARR(:)
    call ARRAY_ALLOCATE(arr,5,3,1)
end subroutine Create

subroutine Destroy (arr)
    INTEGER, ALLOCATABLE, INTENT (INOUT) :: ARR(:)
    CALL ARRAY_DEALLOCATE(arr)
end subroutine Destroy 

END MODULE 

program Console1

USE ARRAY_ALLOCATION
implicit none

integer, allocatable :: alist(:)
if (allocated(alist)) then
    print *, "is allocated"
else
    print *, "is not allocated"
endif
call Create(alist)
if (allocated(alist)) then
    print *, "is allocated"
else
    print *, "is not allocated"
endif    
print *, alist
CALL Destroy(alist)
if (allocated(alist)) then
    print *, "is allocated"
else
    print *, "is not allocated"
endif
end program Console1

预期的结果是这样的：

is not allocated
is allocated
          1           1           1           1           1
is not allocated

编辑 3

关于可分配数组，关于为什么有人想要解除分配的简单解释可以在这里找到https://www.phy.ornl.gov/csep/pl/node17.html：

可分配数组是那些显式声明的 ALLOCATABLE。可分配数组可以是过程本地的，也可以放置在模块中，对应用程序的所有过程有效。可分配数组使用 ALLOCATE 语句显式分配，并使用 DEALLOCATE 语句显式释放，或者如果它是未指定 SAVE 的本地数组，则在退出过程时自动释放。 （如果指定了 SAVE，局部可分配数组可以从一个过程执行持续到下一个执行 - 它们必须使用 DEALLOCATE 语句显式释放。）全局可分配数组一直存在，直到它被显式释放，这可能发生在一个过程中不同于分配它的那个。

可以看出，在某些情况下，如有必要，必须手动解除分配可分配数组。