Question

我正在使用包含一些数组指针的fortran代码;根据用户输入，它们可能被设置为指向具有赋值语句=>的另一个数组，或者它们可能直接使用allocate语句分配。

这会在代码末尾释放内存时产生问题，因为在第一种情况下我只想nullify指针，而在第二种情况下我需要deallocate它来防止内存泄漏。问题是在两种情况下associated返回 true ，所以我不知道如何在不跟踪手动情况的情况下判断我在哪种情况。由于有许多这样的数组指针，我宁愿避免这样做。

有没有一种简单的方法来区分这两种情况？

谢谢！

Answer 1

这听起来像一个可怕的混乱。我假设你有这样的事情：

program really_bad
    implicit none
    integer, dimension(:), pointer :: a
    integer, dimension(:), allocatable, target :: b
    logical :: point_to_b

    allocate(b(10))
    write(*, *) "Should I point to B?"
    read(*, *) point_to_b

    if (point_to_b) then
        a => b
    else
        allocate(a(10))
    end if

    ! Destroy A

end program really_bad

你的问题是毁灭性的部分。如果a指向b，那么您需要NULLIFY，因为您需要保留b。但如果a未指向b，而您只NULLIFY，则会出现内存泄漏。

正如@ ian-bush指出的那样，你可以检查某些东西是否与其他东西相关联，但这意味着你必须将指针与所有可能的目标进行比较，并声称你有很多这些目标。

你可以尝试一件事，但这可能是一个更糟糕的想法，就是尝试解除分配，并使用其STAT=伪参数来检查释放是否真的有效。请注意，这是一个可怕的黑客攻击，我只能在英特尔上工作，而不是在GFortran上工作，但这里什么也没做：

program don
    implicit none
    integer, dimension(:), pointer :: a
    integer, dimension(:), target, allocatable :: b
    logical :: point_to_b
    integer :: stat

    allocate(b(10))
    b = (/ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /)
    write(*, *) "Should I point to B?"
    read(*, *) point_to_b
    if ( point_to_b ) then
        a => b
    else
        allocate(a(10))
    end if
    deallocate(a, stat=stat)
    if ( stat /= 0 ) nullify(a)
end program don

一个更好的方法可能是将数组指针替换为同时具有指针和标志的类型的类型。

program don
    implicit none
    type :: my_array_pointer_type
        integer, dimension(:), pointer :: array
        logical :: master
    end type my_array_pointer_type
    type(my_array_pointer_type) :: a
    integer, dimension(:), target, allocatable :: b
    logical :: point_to_b
    integer :: stat

    allocate(b(10))

    b = (/ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 /)
    write(*, *) "Should I point to B?"
    read(*, *) point_to_b
    if ( point_to_b ) then
        a%master = .false.
        a%array => b
    else
        a%master = .true.
        allocate(a%array(10))
    end if

    if (a%master) then
        deallocate(a%array)
    else
        nullify(a%array)
    end if
end program don

如果您可能将另一个指针指向a，然后尝试销毁，则这些建议都不会对您有所帮助。在这种情况下，我真的建议重新考虑整个项目设计。

Answer 2

您的数据结构有多复杂？也就是说，在给定时间有多少指针同时与单个目标相关联？当引用计数通过allocate语句实例化的目标时，Fortran标准是完全无声的，即，它没有指定一种机制来确保在所有目标存储器全部释放时释放目标存储器。罪人被解散了。内置垃圾收集正是99.9％的时候allocatable属性优先于pointer属性的原因。在极少数情况下，您绝对必须使用指针并且其目标在某个其他子程序中分配，然后将调用链传递给不同的过程，跟踪指针所有权变成了一场噩梦。

如果您可以访问现代Fortran编译器（2008+），则以下模块可能会有所帮助;仅供参考，模块中声明的变量会自动继承save属性。目标foo是私有模块变量，ref_counter跟踪与foo关联的指针数。通过重载deallocate语句，我们可以安全地无效，或者取消释放+ deallocate。与call deallocate(some_ptr, dealloc_stat)

module foo_target

  ! Explicit typing only
  implicit none

  private
  public :: deallocate, nullify, point_at_foo

  ! Neither foo nor ref_counter are public
  real, pointer      :: foo(:) => null()
  integer, protected :: ref_counter = 0

  interface deallocate
     module procedure deallocate_ptr
  end interface deallocate

  interface nullify
     module procedure nullify_ptr
  end interface nullify

contains

  subroutine deallocate_ptr(ptr_to_foo, return_stat)
    ! Dummy arguments
    real, pointer, intent (in out) :: ptr_to_foo(:)
    integer,       intent (out)    :: return_stat
    ! Local variables
    enum, bind(C)
       enumerator :: DEALLOC_ERROR=1, NO_ASSOC, BAD_ASSOC
    end enum
    integer :: alloc_stat

    ! Initialize
    return_stat = 0

    block_construct: block

      ! Check association
      if (ref_counter == 0 .or. .not. associated(foo)) then
          return_stat  = NO_ASSOC
          exit block_construct
      else if (.not. associated(ptr_to_foo, foo)) then
          return_stat = BAD_ASSOC
          exit block_construct
      end if

      if (ref_counter > 1 ) then
          ! Further associations still persist, only nullify
          call nullify(ptr_to_foo)
      else if (ref_counter == 1) then
          ! No remaining associations, nullify and deallocate
          call nullify(ptr_to_foo)
          deallocate(foo, stat=alloc_stat)
          ! Check deallocation status
          if (alloc_stat /= 0) return_stat = DEALLOC_ERROR
      end if

    end block block_construct

  end subroutine deallocate_ptr


  subroutine nullify_ptr(ptr_to_foo)
      ! Dummy arguments
      real, pointer, intent (in out) :: ptr_to_foo(:)

      ! Terminate association
      nullify(ptr_to_foo)

      ! Decrement
      ref_counter = ref_counter - 1

    end subroutine nullify_ptr


    function point_at_foo() result (return_value)
      ! Dummy arguments
      real, pointer :: return_value(:)

      ! Establish association
      return_value => foo

      ! Increment
      ref_counter = ref_counter + 1

    end function point_at_foo

end module foo_target

Answer 3

也许对某人有用。我向GitHub推送了我引用计数的简单实现，它使您能够跟踪对变量的引用。当引用数为0时，对象将自动释放。链接https://github.com/LadaF/Fortran-RefCount

它基于论文Car - A reference counting implementation in Fortran 95/2003和书籍Scientific Software Design: The Object-Oriented Way的想法。

引用对象本身存储指向另一个对象refptr的指针，该对象存储指向数据本身的指针以及指向它的引用数。分配已重载，以便更新引用计数。参考对象的最终确定将根据需要从引用计数中减去。

  type refptr
    integer :: ref_count = 0
    class(*), allocatable :: data
  contains
    final :: refptr_finalize
  end type

  type :: ref
    type(refptr),pointer :: ptr => null()
    integer :: weak = 0 !1.. this is a weak reference, -1.. make weak references to this
  contains
    procedure :: assign_star
    generic :: assignment(=) => assign_star
    ...
    procedure :: pointer => ref_pointer
    final :: ref_finalize
  end type

  interface ref
    module procedure ref_init
    module procedure ref_init_1
  end interface

用法非常简单：

type(ref) :: a, b

a = 42
print *, "a:", a%value(0)

!this does not copy the value, it points the reference
b = a
print *, "b:", b%value(0)

!sets a to point to something new, b still points to 42
a = 2.3

免责声明：自动完成已经实施，未经过太多测试。到目前为止，我已经将它用于手动调用以在gfortran-4.8中完成。这已经过相当广泛的测试。

如何判断fortran数组指针是直接分配还是与另一个对象相关联？

3 个答案: