0

我是一个新手，不知道这些术语，所以我无法在网上搜索这个问题的答案。

不止一次，在编程中，我想做这样的事情。

A 和 B 是子程序，c 和 d 是函数。A 和 B 各自在其中多次调用一个函数。

call A(c(x))
call A(d(x))
call B(c(x))
call B(d(x))

这种结构不起作用。有人告诉我，Fortran 不支持函数的别名，至少在这种情况下是这样。（大多数涉及“别名”的搜索结果是指别名变量而不是函数，这就是我没有找到答案的原因。）

那么我可以使用什么结构来做到这一点而不必编写多个版本的 A 和 B？

4

4 回答 4

4

不完全确定我理解你想要什么，但它是否类似于以下内容？

Program f

  Implicit None

  Interface
     Integer Function c( x )
       Implicit None
       Integer, Intent( In ) :: x
     End Function c
     Integer Function d( x )
       Implicit None
       Integer, Intent( In ) :: x
     End Function d
  End Interface

  Call a( 3, c )
  Call a( 4, d )

  Call b( 5, c )
  Call b( 6, d )

Contains

  Subroutine a( x, func )

    Integer, Intent( In ) :: x
    Interface
       Integer Function func( x )
         Implicit None
         Integer, Intent( In ) :: x
       End Function func
    End Interface

    Write( *, * ) 'In a. Func = ', func( x )

  End Subroutine a

  Subroutine b( x, func )

    Integer, Intent( In ) :: x
    Interface
       Integer Function func( x )
         Implicit None
         Integer, Intent( In ) :: x
       End Function func
    End Interface

    Write( *, * ) 'In b. Func = ', func( x )

  End Subroutine b

End Program f

Integer Function c( x )
  Implicit None
  Integer, Intent( In ) :: x
  c = 2 * x
End Function c

Integer Function d( x )
  Implicit None
  Integer, Intent( In ) :: x
  d = 10 * x
End Function d
Wot now? gfortran -std=f95 f.f90 
Wot now? ./a.out
 In a. Func =            6
 In a. Func =           40
 In b. Func =           10
 In b. Func =           60
Wot now?

另一种方法是过程指针，但您需要一个 f2003 编译器，而且这些编译器还不是很常见 - 上面可以回到 f90 甚至比 External 更早地执行您想要的操作，但错误检查功能较少

于 2012-11-29T05:50:40.410 回答
4

正如 IanH 在他的评论中所说，调用 A(c(x)) 看起来像评估 c(x) 并将其传递给子例程 A。

如果您想将一个函数“C”传递给子例程 A，该函数接受一个类型为 X 的参数，有几种方法可以做到这一点。

如前所述，过程指针是一种新方法。虽然支持所有 Fortran 2003 标准的编译器极少，但这部分却得到了广泛的支持。

这是一个改编自Fortran 中的函数指针数组的示例

module ProcsMod

  implicit none

contains

function f1 (x)
  real :: f1
  real, intent (in) :: x

  f1 = 2.0 * x

  return
end function f1


function f2 (x)
   real :: f2
   real, intent (in) :: x

   f2 = 3.0 * x**2

   return
end function f2


subroutine fancy (func, x, answer)

   real, intent (in) :: x
   real, intent (out) :: answer

   interface AFunc
      function func (y)
         real :: func
         real, intent (in) ::y
      end function func
   end interface AFunc

   answer = func (x)

end subroutine fancy

end module  ProcsMod


program test_proc_ptr

  use ProcsMod

  implicit none

  interface
     function func (z)
        real :: func
        real, intent (in) :: z
     end function func
  end interface

  procedure (func), pointer :: f_ptr => null ()

  real :: answer

  f_ptr => f1
  call fancy (f_ptr, 2.0, answer)
  write (*, *) answer

  f_ptr => f2
  call fancy (f_ptr, 2.0, answer)
  write (*, *) answer


  stop

end program test_proc_ptr

调用“call fancy (f_ptr, 2.0, answer)”看起来是一样的，但是通过改变函数指针 f_ptr 指向的函数，一个不同的函数被传递给子程序 fancy。

这与 gfortran（版本 4.4 到 4.7）和 ifort 一起编译。

于 2012-11-29T08:28:48.977 回答
1

我认为 MSB 的回答描述了函数别名的含义；Fortran 术语是“过程指针”。作为对此和 Ian 的回答的替代方法，您还可以使用过程虚拟参数（不一定是指针）。请注意，procedure仅自 F2003 起才支持任何声明，但 gfortran 4.7 和 ifort 13 都支持这一点。它可以在有或没有（抽象）接口块的情况下完成：

module dummy_procedure
  implicit none

  abstract interface
    real function myfunc(x)
      real, intent(in) :: x
    end function
  end interface

contains      
  subroutine a(func)
    ! Using the interface block:
    procedure(myfunc) :: func         
    print*, 'a:', func(.5)
  end subroutine

  subroutine b(func)
    ! Using the explicit interface of a known procedure:
    procedure(f1) :: func  
    print*, 'b:', func(.5)
  end subroutine

  real function f1(x)
    real, intent(in) :: x
    f1 = 2.0 * x
  end function

  real function f2(x)
    real, intent(in) :: x
    f2 = 3.0 * x**2
  end function
end module

现在可以直接将 and 传入and f1，输出如预期：f2ab

program main
  use dummy_procedure
  call a(f1)  ! a: 1.0
  call a(f2)  ! a: 0.75
  call b(f1)  ! b: 1.0
  call b(f2)  ! b: 0.75
end program
于 2012-11-29T16:46:31.640 回答
0

如果我了解您要执行的操作：

1）在模块中定义您的功能。

2) 使用模块。

3) 将函数和输入数据作为单独的参数提供给子程序。

这是一个对我有用的代码：

module iterfuncs
contains

! two example functions:
function approach_golden_ratio(a) result(agr)
  agr=1./a+1.
end function approach_golden_ratio

function approach_other_ratio(a) result(aor)
  aor=1./(a-1)
end function approach_other_ratio

end module



program use_some_functions

use iterfuncs

real :: final_res

final_res=2.3
! call subroutine with 1st function
call iterate(final_res,approach_golden_ratio)
print *,final_res

final_res=2.3
! call subroutine with 2nd function
call iterate(final_res,approach_other_ratio)
print *,final_res

end program



subroutine iterate(res,func)

use iterfuncs

do n=1,100
  res=func(res)
enddo

return

end subroutine
于 2012-12-01T00:17:02.060 回答