我的代码是否具有派生类型指针泄漏内存

Question

我的IDE是code :: blocks 17.2 with Compiler gfortran 6.3.1

所有代码是：

PROGRAM EES_TEST
USE , NON_INTRINSIC :: DERIVED_TYPE
IMPLICIT NONE
INTEGER :: I , ALLOC_ERR , DEALLOC_ERR
LOGICAL :: GLOBAL_ERR
CLASS ( TRONA ) , POINTER :: P_TRA
TYPE ( TRONA ) , ALLOCATABLE , TARGET :: TRAN(:)
IF ( .NOT. ALLOCATED ( TRAN ) ) ALLOCATE ( TRAN ( 2 ) , STAT = ALLOC_ERR )
IF ( ALLOC_ERR .NE. 0 ) STOP ("PROBLEM WITH MEMORY ALLOCATION - TRAN!!!")
OPEN ( UNIT = 15 , FILE = 'INPUT.TXT' , ACTION = 'READ' )
  DO I = 1 , 2
     P_TRA => TRAN ( I )
     GLOBAL_ERR = P_TRA%UCI()
     IF ( GLOBAL_ERR .EQV. .TRUE. ) STOP ("ERROR WITH READING FROM OUTPUT.TXT!")
  END DO
CLOSE ( 15 )
IF ( ALLOCATED ( TRAN ) ) DEALLOCATE ( TRAN , STAT = DEALLOC_ERR )
IF ( DEALLOC_ERR .NE. 0 ) STOP ("PROBLEM WITH MEMORY DEALLOCATION - TRAN!!!")
END PROGRAM EES_TEST
MODULE DERIVED_TYPE
IMPLICIT NONE
TYPE , PUBLIC :: TRONA
  PRIVATE
    REAL :: Sn
    REAL :: Vn
  CONTAINS
    PROCEDURE , PUBLIC :: UCI => UCI_POD_TRONA
    PROCEDURE , PUBLIC :: TAKE_Sn => TAKE_POD_Sn
    PROCEDURE , PUBLIC :: TAKE_Vn => TAKE_POD_Vn
END TYPE TRONA
PRIVATE :: UCI_POD_TRONA
PRIVATE :: TAKE_POD_Sn , TAKE_POD_Vn
CONTAINS
  FUNCTION UCI_POD_TRONA ( THIS ) RESULT ( WRONG )
    IMPLICIT NONE
    CLASS ( TRONA ) :: THIS
    LOGICAL :: WRONG
    WRONG = .FALSE.
    READ ( 15 , * , ERR = 100 ) THIS%Sn
    READ ( 15 , * , ERR = 101 ) THIS%Vn
  RETURN
  100 WRITE (*,*) "WRONG FORMAT - INPUT 100!"
  WRONG = .TRUE.
  STOP
  101 WRITE (*,*) "WRONG FORMAT - INPUT 101!"
  WRONG = .TRUE.
  STOP
  END FUNCTION UCI_POD_TRONA
  FUNCTION TAKE_POD_Sn ( THIS ) RESULT ( POD_Sn )
    IMPLICIT NONE
    CLASS ( TRONA ) :: THIS
    REAL :: POD_Sn
    POD_Sn = THIS%Sn
  RETURN
  END FUNCTION TAKE_POD_Sn

  FUNCTION TAKE_POD_Vn ( THIS ) RESULT ( POD_Vn )
    IMPLICIT NONE
    CLASS ( TRONA ) :: THIS
    REAL :: POD_Vn
    POD_Vn = THIS%Vn
  RETURN
  END FUNCTION TAKE_POD_Vn
END MODULE DERIVED_TYPE

我在Fortran中以对象为导向的编程非常新，因此我需要使用对象指针来调用来自派生类型的方法的说明。在这种情况下，我想检查内存泄漏是否有任何问题，如果有情况，是否有检查丢失多少内存以及哪一行的方法？另一件事是无效派生类型指针。在这种情况下如何做？

Answer 1

通常，除非您在某个地方分配某些东西，否则您的内存泄漏。这根本是不可能的。您只能泄漏您分配给指针目标的东西，别无其他。

在您的代码中，您没有allocate()用于指针，因此不能有任何内存泄漏。

要发生内存泄漏，必须按顺序进行两件事。

1. 必须分配一个匿名指针目标。只有通过分配语句

   才有可能

   allocate(p_tra)
   

2. 丢失了目标指针。它是在其他地方重定向的

   p_tra => somewhere_else
   

   或它不再存在，因为它是子例程的局部变量，或者是结构的组成部分，该结构是被交易或类似的...

您始终可以使用GCC消毒-fssnitize=leak或valgrind检查内存泄漏。

关于努力，只需使用nulify语句或分配给null()即可。这是一个像其他任何人一样的指针。

p_tra => null()