Fortran 中模块、子例程和函数的正确使用

发布于 2024-12-20 02:31:22 字数 713 浏览 6 评论 0原文

我最近在向 Fortran 程序添加函数时了解了接口块。一切都运行良好且整洁，但现在我想在界面块中添加第二个功能。

这是我的界面块：

interface
    function correctNeighLabel (A,i,j,k)
    integer :: correctNeighLabel
    integer, intent(in) :: i,j,k
    integer,dimension(:,:,:),intent(inout) :: A
    end function

    function correctNeighArray (B,d,e,f)
        character :: correctNeighArray
    integer, intent(in) :: d,e,f
    character, dimension(:,:,:),intent(inout) :: B
    end function
end interface

在我看来，这可能不是最好的选择。

我研究过子例程，但我不太确信这是正确的解决方案。我正在做的事情相对简单，我需要将参数传递给子例程，但我见过的所有子例程都是a）复杂（即对于函数来说太复杂），b）不接受参数。它们的行为就好像它们在没有将变量传递给它们的情况下操纵变量一样。

我还没有真正正确地研究过模块，但从我所看到的来看，这不是正确的使用方式。

我应该何时使用哪一个，以及如何最好地使用它？

原文

I've recently learnt about interface blocks when adding a function to my Fortran program. Everything works nice and neatly, but now I want to add a second function into the interface block.

Here is my interface block:

interface
    function correctNeighLabel (A,i,j,k)
    integer :: correctNeighLabel
    integer, intent(in) :: i,j,k
    integer,dimension(:,:,:),intent(inout) :: A
    end function

    function correctNeighArray (B,d,e,f)
        character :: correctNeighArray
    integer, intent(in) :: d,e,f
    character, dimension(:,:,:),intent(inout) :: B
    end function
end interface

It appears to me that this may not be the best option.

I've looked into subroutines, but I'm not very confident that it's the right solution. What I'm doing is relatively simple, and I need to pass arguments to the subroutine, but all the subroutines I've seen are a) complicated (i.e. too complicated for a function), and b) don't take arguments. They behave as though they manipulate variables without them being passed to them.

I've not really looked into modules properly, but from what I've seen it's not the right thing to use.

Which should I use when, and how do I go about it best?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

傻比既视感 2024-12-27 02:31:22

模块始终是正确的选择；-)

如果您有一个非常简单的 F90 程序，您可以在“包含”块中包含函数和子例程：

 program simple
   implicit none
   integer :: x, y
   x = ...
   y = myfunc(x)
 contains
   function myfunc(x) result(y)
     implicit none
     integer, intent(in)  :: x
     integer              :: y
     ...
   end function myfunc
 end program

那么函数/子例程的接口将在程序中已知，并且不会需要在接口块中定义。

对于更复杂的程序，您应该将所有函数/子例程保留在模块中，并在需要时加载它们。因此，您也不需要定义接口：

 module mymod
   implicit none
   private
   public :: myfunc
 contains
   function myfunc(x) result(y)
     implicit none
     integer, intent(in)  :: x
     integer              :: y
     ...
   end function myfunc
 end module mymod

 program advanced
   use mymod, only: myfunc
   implicit none
   integer :: x, y
   x = ...
   y = myfunc(x)
 end program advanced

模块和程序可以（实际上应该）位于单独的文件中，但模块必须在实际程序之前编译。

Modules are always the right thing to use ;-)

If you have a very simple F90 program you can include functions and subroutines in the 'contains' block:

 program simple
   implicit none
   integer :: x, y
   x = ...
   y = myfunc(x)
 contains
   function myfunc(x) result(y)
     implicit none
     integer, intent(in)  :: x
     integer              :: y
     ...
   end function myfunc
 end program

Then the interface of the functions/subroutines will be known in the program and don't need to be defined in an interface block.

For more complex programs you should keep all functions/subroutines in modules and load them when required. So you don't need to define interfaces, either:

 module mymod
   implicit none
   private
   public :: myfunc
 contains
   function myfunc(x) result(y)
     implicit none
     integer, intent(in)  :: x
     integer              :: y
     ...
   end function myfunc
 end module mymod

 program advanced
   use mymod, only: myfunc
   implicit none
   integer :: x, y
   x = ...
   y = myfunc(x)
 end program advanced

The module and the program can (actually should) be in separate files, but the module has to be compiled before the actual program.

回复收藏 0 原文

别挽留 2024-12-27 02:31:22

支持并扩展已经说过的内容。最好将您的过程（子例程和函数）放入模块中并“使用”它们，因为您可以轻松地对接口进行自动一致性检查。其他方法也有缺点。如果您使用接口块定义接口，那么您需要维护三件事，而不是两件事：接口、过程本身和调用。如果您进行更改，则所有三个都必须修改才能保持一致。如果您使用一个模块，则只需更改两个。使用接口块的一个原因是，如果您无法访问源代码（例如，预编译库）或源代码采用另一种语言（例如，您通过 ISO C 绑定使用 C 代码）。

“包含”方法的缺点是包含的过程继承父程序的所有局部变量......这不是很模块化，如果您忘记这个“功能”，可能会非常混乱。

回复收藏 0 原文

女中豪杰 2024-12-27 02:31:22

alexurba 和 MSB 的答案一如既往地正确且有用；让我在一点上充实一点细节——如果模块是可行的方法（而且确实如此），那么接口到底有什么用呢？

对于模块中的函数和子例程，任何使用该模块的东西都可以自动看到这些接口；接口是在编译模块时生成的（该信息除其他外，会进入编译模块时生成的 .mod 文件）。所以你不需要自己写。类似地，当您使用 CONTAINed 子程序时（与 MSB 一致，我发现它更令人困惑而不是有帮助 - 它们更好地被认为是闭包或嵌套子例程而不是外部子例程），主程序已经可以显式地“看到”接口，并且不需要您为其编写它。

接口块适用于您无法执行此操作的情况 - 当编译器无法为您生成显式接口时，或者当您想要与给定的接口不同的东西时。一个例子是使用 C 时-Fortran 2003 中的 Fortran 互操作性。在这种情况下，Fortran 代码链接到某些 C 库（例如），并且无法生成为您提供正确的 C 例程的 Fortran 接口——您必须自己编写自己的接口块。

另一个例子是，当您已经知道子例程的接口时，但是当您想要创建一个新接口来“隐藏”后面的子例程时 - 例如，当您有一个对（比如说）整数进行操作的例程和一个对实数进行操作的例程时，并且您希望能够在两者上调用相同的例程名称，并让编译器根据参数对其进行排序。此类构造称为泛型例程，自 Fortran 90 以来就已存在。在这种情况下，您可以显式地为这个新泛型创建一个接口例程，并列出该接口块中“真实”例程的接口。