Question

我是Fortran的新手，所以我想对动态内存的分配有所了解

我阅读了有关动态内存分配的信息，各种资料来源对此主题都有不同的看法。例如，一本书指出，分配的动态内存的每个单个块都必须在程序结尾处重新分配，以避免内存泄漏。但是，其他来源（书籍和各种网页）声称由于编译器（gfortran等）取消分配而无效所有动态对象，数组等都会在程序结束时自动出现。

因此，在我的示例代码中，我不知道是否需要从NN_VOD过程中释放动态数组CALCULATE_DATA_DM。

如果我想避免内存泄漏，并且此代码中是否存在任何内存泄漏，我该如何处理此示例代码？（我的IDE是MinGW编译器6.3.0的Code :: Blocks 17.12）

MODULE DERRIVED_TYPE_TMP

  INTEGER, PUBLIC :: I, J, K, ALLOC_ERR

  TYPE, PUBLIC :: DM_ELEMENT
     CHARACTER( 50 ), PRIVATE :: ELE_NAME
     INTEGER,         PRIVATE :: ELE_NUMBER
   CONTAINS
     PROCEDURE, PUBLIC :: CALCULATE_ELEMENT => CALCULATE_DATA_ELEMENT
  END TYPE DM_ELEMENT

  PRIVATE :: CALCULATE_DATA_ELEMENT

  TYPE, EXTENDS(DM_ELEMENT), PUBLIC :: VOD_DM
     INTEGER, ALLOCATABLE, PRIVATE :: NN_VOD( : )
   CONTAINS

     PROCEDURE, PUBLIC :: CALCULATE_ELEMENT => CALCULATE_DATA_DM
     PROCEDURE, PUBLIC ::           TAKE_DM =>      TAKE_DATA_DM
  END TYPE VOD_DM

  PRIVATE :: CALCULATE_DATA_DM
  PRIVATE :: TAKE_DATA_DM

CONTAINS

  SUBROUTINE CALCULATE_DATA_ELEMENT ( THIS, NUMBER_TMP )
    CLASS( DM_ELEMENT )   :: THIS
    INTEGER, INTENT( IN ) :: NUMBER_TMP
  END SUBROUTINE CALCULATE_DATA_ELEMENT

  SUBROUTINE CALCULATE_DATA_DM( THIS, NUMBER_TMP )
    CLASS( VOD_DM )       :: THIS
    INTEGER, INTENT( IN ) :: NUMBER_TMP

    IF ( .NOT. ALLOCATED( THIS%NN_VOD ) ) ALLOCATE( THIS%NN_VOD( NUMBER_TMP ), STAT = ALLOC_ERR )
    IF ( ALLOC_ERR .NE. 0 )                STOP ( "PROBLEM SA ALOKACIJOM MEMORIJE - THIS%T !!!" )
    DO J = 1, NUMBER_TMP
       THIS%NN_VOD( J ) = J + NUMBER_TMP
    END DO
  END SUBROUTINE CALCULATE_DATA_DM

  FUNCTION TAKE_DATA_DM( THIS, INDX ) RESULT( RESULT_TMP )
    CLASS( VOD_DM )        :: THIS
    INTEGER, INTENT( IN ) :: INDX
    INTEGER               :: RESULT_TMP

    RESULT_TMP = THIS%NN_VOD( INDX )
  END FUNCTION TAKE_DATA_DM

END MODULE DERRIVED_TYPE_TMP

PROGRAM DO_LOOP_ALLOCATION
  USE, NON_INTRINSIC :: DERRIVED_TYPE_TMP
  IMPLICIT NONE

  INTEGER,   PARAMETER :: N_NN_DM = 3
  INTEGER,   PARAMETER :: AN_NN_DM( N_NN_DM ) = [ 2, 3, 4 ]

  TYPE :: NN_VOD
     TYPE( VOD_DM ), ALLOCATABLE :: ID( : )
  END TYPE NN_VOD

  CLASS( DM_ELEMENT ),             POINTER :: P_DM_ELEMENT
  TYPE     ( NN_VOD ), ALLOCATABLE, TARGET ::   PAR_NN_VOD( : )

  IF ( .NOT. ALLOCATED( PAR_NN_VOD ) ) ALLOCATE( PAR_NN_VOD( N_NN_DM ), STAT = ALLOC_ERR )
  IF ( ALLOC_ERR .NE. 0 )              STOP ( "ALLOCATION ERROR - PAR_NN_VOD !!!" )

  DO K = 1, N_NN_DM
     IF ( .NOT. ALLOCATED( PAR_NN_VOD( K )%ID ) ) ALLOCATE( PAR_NN_VOD( K )%ID( AN_NN_DM( K ) ), STAT = ALLOC_ERR )
     IF ( ALLOC_ERR .NE. 0 )                      STOP ( "ALLOCATION ERROR - PAR_NN_VOD%ID !!!")
  END DO

  DO K = 1, N_NN_DM
     DO I = 1, AN_NN_DM( K )
        P_DM_ELEMENT => PAR_NN_VOD( K )%ID( I )
        CALL P_DM_ELEMENT%CALCULATE_ELEMENT( K + I )
     END DO
  END DO

END PROGRAM DO_LOOP_ALLOCATION

Answer 1

从Fortran95开始，对语言进行了设计，以使使用符合标准的编译器在使用可分配数组时不可能发生内存泄漏，因为一旦可分配对象超出范围，它就会被释放。这是可分配数组的一大优点，也是为什么在可能的情况下始终总是优先使用它们的原因之一。现在，当变量超出范围时，很可能会在停止使用该变量之后很长一段时间，因此您可能希望更早地手动进行分配以节省内存，但是没有必要纯粹地进行分配以避免内存泄漏。因此，在您的代码中使用可分配数组，不会发生内存泄漏。

在Fortran 90中，情况并非如此，可分配内存可能会泄漏。但是，这个标准早已被Fortran 95及其它所取代，因此，今天不应该使用Fortran 90和所有更早的标准。

来自派生类型的过程中的动态内存释放

1 个答案: