从派生类型在过程中动态释放内存

Question

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

我读过关于动态内存分配的文章，各种来源对这个主题有不同的看法。例如，一本书指出，必须在程序结束时释放每个分配的动态内存块，以避免内存泄漏。但是，其他来源(书籍和各种网页(声称作为编译器(gfortran等(释放无效 所有动态对象、数组等在程序结束时自动运行。

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

如果我想避免内存泄漏，我需要如何处理此示例代码，并且此代码中是否存在任何内存泄漏？(我的IDE是代码：：块17.12与MinGW编译器6.3.0(

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和所有早期的标准今天不应该被使用。