Question

为了遍历Fortran中的链表，我使用指向当前元素的指针，该元素移动到循环内的下一个元素。尝试在对所述链接列表进行操作的pure函数内应用此操作会导致错误。

示例：

module list
  implicit none

  ! Node
  type n_list
    integer               :: val
    type(n_list),pointer  :: next => NULL()
  end type

  ! Linked list
  type t_list
    type(n_list),pointer  :: head
  end type

contains

  pure function in_list( list, val ) result(res)
    implicit none
    class(t_list),intent(in)  :: list
    integer,intent(in)        :: val
    logical                   :: res
    type(n_list),pointer      :: cur

    res = .true.
    ! Traverse the list
    cur => list%head
    do while ( associated(cur) )
      if ( cur%val == val ) return 
      cur => cur%next
    enddo

    ! Not found
    res = .false.
  end function
end module

结果

    cur => list%head
         1
Error: Bad target in pointer assignment in PURE procedure at (1)

我知道错误/警告背后的基本原理，并且很难确保在使用指针时函数的参数不会改变（Fortran 2008，ch.12.7“Pure procedures”，特别是C1283）。但是，在这种情况下，list永远不会改变。

是否可以告诉编译器（ifort和gfortran）{0}未被违反？

Answer 1

我找到了使用recursive函数的解决方案，该解决方案至少符合标准。它不优雅也不快，并且受到堆栈深度的限制，但它正在工作。我会发布它作为答案，虽然我希望有一个人有更好的解决方案......

module list
  implicit none

  ! Node
  type n_list
    integer               :: val
    type(n_list),pointer  :: next => NULL()
  end type

  ! Linked list
  type t_list
    type(n_list),pointer  :: head
  end type

contains

  pure function in_list( list, val ) result(res)
    implicit none
    class(t_list),intent(in)  :: list
    integer,intent(in)        :: val
    logical                   :: res

    if (  associated(list%head) ) then
      res = in_list_node( list%head, val ) 
    else
      res = .false.
    endif
  end function

  recursive pure function in_list_node( node, val ) result(res)
    implicit none
    class(n_list),intent(in)  :: node
    integer,intent(in)        :: val
    logical                   :: res

    if ( node%val == val ) then
      res = .true.
    elseif ( associated(node%next) ) then
      ! Recurse
      res = in_list_node( node%next, val ) 
    else
      res = .false.
    endif
  end function
end module

program test
  use list
  implicit none
  integer,parameter     :: MAXELEM = 100000
  integer               :: i
  type(t_list)          :: lst
  type(n_list),pointer  :: cur

  ! Fill list
  lst%head => NULL()
  allocate( lst%head )
  lst%head%val = 1

  cur => lst%head
  do i=2,MAXELEM
    allocate( cur%next )
    cur%next%val = i
    cur => cur%next
  enddo !i

  print *,'is MAXELEM/2 in list? ', in_list( lst, MAXELEM/2 )
  print *,'is MAXELEM+1 in list? ', in_list( lst, MAXELEM+1 )
end program

Answer 2

您遇到的约束的相关部分（C1283）是

在纯子程序中，任何具有基础对象的指示符都是......具有INTENT（IN）属性的伪参数..不得使用



...



作为pointer-assignment-stmt

中的数据目标

下面的说明约束描述激励它

上述约束旨在保证纯程序没有副作用

你想说的是＆＃34;我保证没有副作用，我们不需要那些约束＆＃34;。约束条件已足够但不是必需的，您可以很好地分析代码。

但是，符合标准的处理器/编译器必须能够来检测违反约束的行为，而不仅仅是约束的总体目标，因此您不需要说＆＃34;它＆＃39; s pure真的＆＃34;，但也＆＃34;我不需要被告知违反C1283＆＃34;。对于编译器供应商而言，这似乎需要付出很多努力才能获得很少的好处。

我想，那时答案是＆＃34;没有＆＃34;：没有一种编译代码的方法。这不是确定的，因为我们真正进入了特定于实现的领域。你特别询问了gfortran和ifort，所以＆＃34;使用-nocheck c1283＆＃34;反驳我的回答＆＃34;。

现在，如果有一个选项，那么你就可以信任我，并且相信我＆＃34; （和非标准的Fortran）。所以，无论如何，让我们去那里。只是我们会撒谎。像往常一样，接口块将是我们的手段。

module list_mod
  implicit none

  ! Node
  type n_list
    integer               :: val
    type(n_list),pointer  :: next => NULL()
  end type

  ! Linked list
  type t_list
    type(n_list),pointer  :: head
  end type

  interface
    pure logical function in_list(list, val)
      import t_list
      class(t_list), intent(in) :: list
      integer, intent(in) :: val
    end function
  end interface

end module

! Interface mismatch in the external function
function in_list(list, val) result(res)
  use list_mod, only : t_list, n_list
  implicit none
  class(t_list),intent(in)  :: list
  integer,intent(in)        :: val
  logical                   :: res
  type(n_list),pointer      :: cur

  res = .true.
  ! Traverse the list
  cur => list%head
  do while ( associated(cur) )
    if ( cur%val == val ) return 
    cur => cur%next
  enddo

  ! Not found
  res = .false.
end function

  use list_mod
  type(t_list) testlist
  type(n_list), pointer :: ptr
  integer i
  logical :: res(5) = .FALSE.

  allocate(testlist%head)
  ptr => testlist%head

  do i=1,5
    allocate(ptr%next)
    ptr => ptr%next
    ptr%val = i
  end do

  ! in_list is pure, isn't it?
  forall(i=1:5:2) res(i)=in_list(testlist,i)
  print*, res
end

这是纯粹的肮脏并且是有限的：你不再有模块程序;你不符合标准;编译器可能很聪明并检查接口（即使它不需要）。如果编译器因此而讨厌你，你只能责怪自己。

最后，完成程序pure需要付出相当大的努力。

Answer 3

好的，我找到了使用transfer内在函数的解决方案。主要思想是克隆列表结构（没有数据，我检查过），并使用指向第一个节点（未更改）的指针作为起始值。是的，这是一个循环漏洞，但ifort和gfortran都接受了这一点而没有警告。

module list_mod
  implicit none

  ! Node
  type n_list
    integer               :: val
    type(n_list),pointer  :: next => NULL()
  end type

  ! Linked list
  type t_list
    type(n_list),pointer  :: head
  end type

contains

  pure function getHead(list) result(res)
    implicit none
    class(t_list),intent(in)  :: list
    type(n_list),pointer      :: res
    type(t_list),pointer      :: listPtr

    ! Create a copy of pointer to the list struct
    allocate( listPtr )
    listPtr = transfer( list, listPtr )

    ! Set the pointer
    res => listPtr%head

    ! Free memory
    deallocate( listPtr )
  end function

  pure function in_list( list, val ) result(res)
    implicit none
    class(t_list),intent(in)  :: list
    integer,intent(in)        :: val
    logical                   :: res
    type(n_list),pointer      :: cur

    res = .true.

    ! Traverse the list
    cur => getHead(list)
    do while ( associated(cur) )
      if ( cur%val == val ) return
      cur => cur%next
    enddo

    ! Not found
    res = .false.
  end function

end module

program test
  use list_mod
  implicit none
  integer,parameter     :: MAXELEM = 10000000
  integer               :: i
  type(t_list)          :: list
  type(n_list),pointer  :: cur

  ! Fill list
  list%head => NULL()
  allocate( list%head )
  list%head%val = 1

  cur => list%head
  do i=2,MAXELEM
    allocate( cur%next )
    cur%next%val = i
    cur => cur%next
  enddo !i

  print *,'is MAXELEM/2 in list? ', in_list( list, MAXELEM/2 )
  print *,'is MAXELEM+1 in list? ', in_list( list, MAXELEM+1 )
end program

纯函数指针

3 个答案: