【Fortran】Fortran可选参数optional和接口interface的示例程序

最新推荐文章于 2025-07-28 15:55:01 发布
原创 最新推荐文章于 2025-07-28 15:55:01 发布 · 3k 阅读 · 3 ·
CC 4.0 BY-SA版权
本文为博主原创文章，未经博主允许不得转载。
文章标签：

#fortran

本文档展示了一个Fortran模块`mod_tools`，其中包含多个子程序，这些子程序使用可选参数。通过`test_optional`接口，实现了不同维度数组的实数和整数类型可选参数的处理。在`Main`程序中调用了这些子程序，演示了如何传递可选参数并检查其是否存在。此代码示例详细解释了Fortran中可选参数的使用和接口声明。

代码

module mod_tools
  implicit none

  integer,parameter :: its = 1
  integer,parameter :: ite = 4
  integer,parameter :: jts = 1
  integer,parameter :: jte = 3
  integer,parameter :: kms = 1
  integer,parameter :: kme = 2


  interface test_optional
    module procedure test_optional_integer_1d
    module procedure test_optional_integer_2d
    module procedure test_optional_integer_3d

    module procedure test_optional_real_1d
    module procedure test_optional_real_2d
    module procedure test_optional_real_3d
  end interface ! test_optional

  contains

  subroutine test_optional_real_1d(var1,var2)
! ---------------------------------------
! var2是可选参数；
! optional属性表示这个参数是可选的；
! 用present来判断是否传入可选参数；
! ---------------------------------------
    implicit none
    real,dimension(its:ite),intent(in) :: var1
    real,dimension(its:ite),optional,intent(in) :: var2

    print*,"var1=",var1

    if(present(var2)) then
      print*,"var2=",var2
    end if

    print*," "

  end subroutine test_optional_real_1d


  subroutine test_optional_real_2d(var1,var2)
    implicit none
    real,dimension(its:ite,jts:jte),intent(in) :: var1
    real,dimension(its:ite,jts:jte),optional,intent(in) :: var2

    print*,"var1=",var1

    if(present(var2)) then
      print*,"var2=",var2
    end if

    print*," "

  end subroutine test_optional_real_2d


  subroutine test_optional_real_3d(var1,var2)
    implicit none
    real,dimension(its:ite,jts:jte,kms:kme),intent(in) :: var1
    real,dimension(its:ite,jts:jte,kms:kme),optional,intent(in) :: var2

    print*,"var1=",var1

    if(present(var2)) then
      print*,"var2=",var2
    end if

    print*," "
    
  end subroutine test_optional_real_3d


  subroutine test_optional_integer_1d(var1,var2)
    implicit none
    integer,dimension(its:ite),intent(in) :: var1
    integer,dimension(its:ite),optional,intent(in) :: var2

    print*,"var1=",var1

    if(present(var2)) then
      print*,"var2=",var2
    end if

    print*," "

  end subroutine test_optional_integer_1d


  subroutine test_optional_integer_2d(var1,var2)
    implicit none
    integer,dimension(its:ite,jts:jte),intent(in) :: var1
    integer,dimension(its:ite,jts:jte),optional,intent(in) :: var2

    print*,"var1=",var1

    if(present(var2)) then
      print*,"var2=",var2
    end if

    print*," "

  end subroutine test_optional_integer_2d


  subroutine test_optional_integer_3d(var1,var2)
    implicit none
    integer,dimension(its:ite,jts:jte,kms:kme),intent(in) :: var1
    integer,dimension(its:ite,jts:jte,kms:kme),optional,intent(in) :: var2

    print*,"var1=",var1

    if(present(var2)) then
      print*,"var2=",var2
    end if

    print*," "
    
  end subroutine test_optional_integer_3d

END module mod_tools



program Main
  use mod_tools
  implicit none
  integer,dimension(its:ite)                 :: int_1d_1,int_1d_2
  integer,dimension(its:ite,jts:jte)         :: int_2d_1,int_2d_2
  integer,dimension(its:ite,jts:jte,kms:kme) :: int_3d_1,int_3d_2
  real   ,dimension(its:ite)                 :: real_1d_1,real_1d_2
  real   ,dimension(its:ite,jts:jte)         :: real_2d_1,real_2d_2
  real   ,dimension(its:ite,jts:jte,kms:kme) :: real_3d_1,real_3d_2

  int_1d_1 = 1
  int_1d_2 = 2

  int_2d_1 = 3
  int_2d_2 = 4

  int_3d_1 = 5
  int_3d_2 = 6

  real_1d_1 = 1.5
  real_1d_2 = 2.5

  real_2d_1 = 3.5
  real_2d_2 = 4.5

  real_3d_1 = 5.5
  real_3d_2 = 6.5


  call test_optional(int_1d_1,int_1d_2)
  call test_optional(int_2d_1,int_2d_2)
  call test_optional(int_3d_1,int_3d_2)
  call test_optional(real_1d_1,real_1d_2)
  call test_optional(real_2d_1,real_2d_2)
  call test_optional(real_3d_1,real_3d_2)


end program Main

结果

var1=           1           1           1           1
 var2=           2           2           2           2

 var1=           3           3           3           3           3           3           3           3           3           3           3           3
 var2=           4           4           4           4           4           4           4           4           4           4           4           4

 var1=           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5           5
 var2=           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6           6

 var1=   1.50000000       1.50000000       1.50000000       1.50000000
 var2=   2.50000000       2.50000000       2.50000000       2.50000000

 var1=   3.50000000       3.50000000       3.50000000       3.50000000       3.50000000       3.50000000       3.50000000       3.50000000       3.50000000       3.50000000       3.50000000       3.50000000
 var2=   4.50000000       4.50000000       4.50000000       4.50000000       4.50000000       4.50000000       4.50000000       4.50000000       4.50000000       4.50000000       4.50000000       4.50000000

 var1=   5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000       5.50000000
 var2=   6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000       6.50000000

03-Fortran基础--Fortran函数和子程序
weixin_43339605的博客
05-09 4217
介绍Fortran函数的定义和应用，并提供了一些示例
FORTRAN-调用FORTRAN程序-动态链接库DLL
奔跑的驯鹿的博客
03-11 4303
FORTRAN-调用FORTRAN程序-动态链接库DLL1.创建FORTRAN动态链接库2.创建FORTRAN动态链接库中的调用3.创建FORTRAN主程序中的调用4.小结参考文章 1.创建FORTRAN动态链接库 2.创建FORTRAN动态链接库中的调用 3.创建FORTRAN主程序中的调用 4.小结 参考文章 ...
Fortran的两种显式接口：模块化和interface
WJF的博客
12-05 8072
写一个subroutine，如果形参给定数组元素个数，可以正常编译运行 subroutine abc(a) implicit none integer :: a(3) a(1)=1 a(2)=2 end subroutine program main implicit none integer :: a(3)=(/5,5,5/) ...
Fortran入门教程(八)——子例程及函数
Sumbrella_的博客
12-10 1万+
过程 在写程序时常常会有一些代码块需要经常使用, 我们可以将其封装起来，封装好后的代码块可以统一调用，减少代码的书写量，提高程序的可读性、拓展性等。 1. 子例程 (subroutine) 1.1 语法 封装一个子例程按如下语法封装 subroutine subroutine_name([argument1[, argument2, ..., argumentn]]) argument_type1 :: argument1 argument_type2 :: argument2 ..
学习笔记1：认识Verilog中的数据类型与数字的表达方式
weixin_60634144的博客
02-10 3899
本文属于学习笔记，我对于verilog的学习只是足够编写一个简单的多周期cpu，对于verilog属于是浅浅的接触了一下了，其中可能会有一些写的不够准确的地方，欢迎指正讨论相互学习。
fortran 中 interface
cepheid的专栏
12-25 4246
可变大小数组作为参数传递时，需要用interface 例子：program testimplicit nonereal,allocatable :: array(:)real             :: summallocate(array(5))array=8.call passarray(array, summ)write(*,*)summ
Fortran接口
pink9527的专栏
11-25 1587
Chapter 11 C-Fortran InterfaceThis chapter treats issues regarding Fortran and C interoperability.The discussion is inherently limited to the specifics of the Sun FORTRAN 77, Fortran 95, and C compilers. Note – Material common to both FORTRAN 77 and Fortra
Fortran中function，subroutine， interface和module的简单使用
热门推荐
ADreamClusive的博客
11-29 3万+
代码运行在simply fortran2下，复制，粘贴可直接运行看效果!!!!!------------------- ! Fortran中函数分两类：子程序（subroutine）和自定义函数（function）。 ! 自定义函数本质上就是一般数学上的函数，一般要传递自变量给自定义函数，返回函数值。 ! 子程序不一定是这样，可以没有返值也可以多个返回值。 ! func能做到
46、Fortran 程序声明与接口详解
最新发布
pytorchlight8的博客
07-28 53
本文深入探讨了Fortran编程语言中的过程声明与接口机制，详细介绍了语句函数、替代入口（ENTRY语句）以及各种类型过程的接口处理方式。重点阐述了显式接口与隐式接口的区别及其重要性，强调了显式接口在代码可靠性与可维护性方面的优势。同时，文章分析了不同类型的虚参对接口的影响，并通过示例展示了接口体、通用过程及接口块的使用方法。最后，对各类过程的接口情况进行了总结，为开发者提供了清晰的参考指南。
43、Fortran 程序单元详解
fff88的博客
07-23 40
本文详细解析了Fortran程序单元的核心内容，涵盖主程序和模块的定义、使用规则及其典型应用场景。通过示例代码深入介绍了模块的全局数据管理、用户定义运算符、数据抽象和过程库功能，并对比总结了主程序与模块的关键特性。旨在帮助开发者更好地组织和优化Fortran程序结构，提升代码的可维护性与复用性。
17、Fortran 程序中的属性声明与使用
pytorchlight8的博客
06-29 22
本文详细介绍了 Fortran 程序中的属性声明与使用方法，包括实体导向与属性导向的子程序声明、VALUE、OPTIONAL、EXTERNAL、INTRINSIC 等关键属性的作用与规则，以及过程声明语句和属性兼容性等内容。通过示例和流程图梳理，帮助开发者更高效、准确地编写 Fortran 程序。
关于optional的用法
happydroll的博客
03-09 1095
optional是一个工具类，用来避免空指针异常，与传统java中用if判断是否为null相比，optional最大的优点是可以避免if嵌套（逐层判断是否为null）， 可以链式调用，语义化非常好，简洁，易懂。 http://www.importnew.com/26066.html...
Fortran笔记，重载&自定义操作符&继承Module
qq_21091051的博客
02-20 1702
介绍通过interface实现函数的重载(overload)，自定义操作符，以及module继承
用fortran调用dll
encaidx的专栏
10-24 4976
采用vs.net+ifort做一个简单的dll，当然是从help里面拷出来的。 SUBROUTINE ARRAYTEST(arr) !DEC$ ATTRIBUTES DLLEXPORT :: ARRAYTEST REAL(4) arr(3, 7) INTEGER i, j DO i = 1, 3 DO j = 1, 7    arr (i, j) = 11.0 * i + j EN
FORTRAN 同名函数的重载与自定义运算符 from《FROTRAN95 程序设计》
qlj061001的博客
03-21 2639
1、同名函数的重载类似于C语言的函数重载，FORTRAN90中支持自定义虚拟函数名称： 根据输入参数的不同以及数目不同来选择要调用函数，这些功能通过在module中使用interface来实现。module MA implicit none interface show ! 虚拟函数名称show module procedure show_in...
【Fortran学习笔记4】--子程序和函数
weixin_62037267的博客
03-09 1838
写程序时候，可以把一段经常使用的、具有特定功能的程序代码独立处理爱，封装成子程序，以后只需要使用call调用就可以执行这一程序。在Fortran中，子程序内部变量可以影响局部变量的，可以用intent声明参数只是可读的。在函数中定义一个进入口，调用该进入口，则程序会从该入口处开始执行，而跳过在该点之前的代码。自定义程序的也需要调用才能执行，也可以独立声明，但是和子程序有两点不同。在Fortran的递归中， 输入和输出是分开的。也可以简单定义函数，此时无需调用。
关键字参数和可选参数
tanshiqian的博客
02-04 1468
通常Fortran的实参和形参的参数数量以及类型必须是匹配的，但是如果过程接口是显式的，那么就可以改变参数表中调参数的顺序，或为过程的某些iochengde形参特别指定实参。通过将过程放在模块中，并在调用程序中用use关联访问模块，可以显式的说明接口过程。 可选参数（optional argument）是指当调用过程时，其形参并不一定全部出现。可选参数仅可用于显式接口过程中，通过在形参声明中引入...
fortran中的各种内置函数
Leo的博客
10-24 2万+
fortran和所有语言一样包含了各种内置的函数接口供使用者调用 我在使用过程中遇到各种内置函数，会在此记录和简单介绍 2018.10.24 1.trim（string） 函数功能：舍去字符串尾部的空格，并返回剩余部分。 character(len=10) ::str str = "leo " write(*,"(a,a)") str,"***" write(*,"(a,...
用Fortran来实现DLL的编程和应用(3)
PolyUp的专栏
08-18 2013
 三、几个说明的问题：1．DLL与EXE的目录问题。原始的Help中是如此说的：For an application to access your DLL, it must be located in a directory on the search path or in the same directory as the main project. If you have mo
在Fortran90中如何声明主程序之外的文件中子程序的接口
07-09
<think>在Fortran 90中，如果你在主程序中使用一个外部子程序（例如，位于另一个文件中的函数或子例程），并且你想确保类型安全，或者子程序的参数具有特殊属性（如可选的、指针、目标等），那么你需要为这个子程序提供一个接口块（interface block）。接口块允许你明确指定子程序的参数类型和返回类型（如果是函数），这样编译器就能进行正确的类型检查。 以下是如何声明主程序之外的文件中子程序的接口的步骤： 1. 创建一个接口块（interface），在块内声明子程序的形参和返回类型（如果是函数）。 2. 在主程序中使用该接口块。 注意：如果子程序在同一模块中，那么使用模块（module）来包含子程序，然后在主程序中使用该模块（use module_name）是更好的方式，这样编译器会自动生成接口。但是，如果子程序不在模块中（例如，是外部的或者放在另一个文件中的普通子程序），那么就需要显式声明接口。 示例： 假设我们有一个外部函数 `external_function` 定义在另一个文件中（比如 `external.f90`），该函数计算两个实数的和，并返回一个实数。在主程序文件中，我们需要使用这个函数。 文件 `external.f90` 的内容： ```fortran function external_function(a, b) result(c) implicit none real :: a, b, c c = a + b end function external_function ``` 主程序文件 `main.f90` 的内容： ```fortran program main implicit none ! 声明外部函数的接口 interface function external_function(x, y) result(z) implicit none real, intent(in) :: x, y real :: z end function external_function end interface real :: a, b, c a = 5.0 b = 3.0 c = external_function(a, b) print *, 'The sum is ', c end program main ``` 解释： 1. 在主程序中，我们使用了一个接口块（interface ... end interface）来声明外部函数`external_function`的接口。 2. 在接口块内部，我们重复了函数的声明，包括参数和返回值的类型。注意，我们在这里使用了`intent(in)`属性来指定参数是输入的，这有助于编译器优化和检查。 3. 然后，在主程序中，我们可以像调用内部函数一样调用`external_function`。 重要提示： - 接口块必须与子程序的实际定义完全一致（包括参数的类型、顺序、属性，以及函数返回值的类型）。如果不一致，编译器可能会报错或者导致运行时错误。 - 对于子例程（subroutine），声明方式类似，只是没有返回值。 另一种情况：如果外部子程序有可选参数（optional），或者使用了指针、目标等属性，那么接口块中必须明确写出这些属性。 示例：带有可选参数的外部子例程 文件 `external_sub.f90`： ```fortran subroutine external_sub(a, b, c) implicit none real, intent(in) :: a real, intent(in), optional :: b real, intent(out), optional :: c if (present(b)) then if (present(c)) then c = a + b end if else if (present(c)) then c = a end if end if end subroutine external_sub ``` 主程序文件 `main.f90`： ```fortran program main implicit none ! 声明外部子例程的接口 interface subroutine external_sub(x, y, z) implicit none real, intent(in) :: x real, intent(in), optional :: y real, intent(out), optional :: z end subroutine external_sub end interface real :: a, b, c a = 5.0 b = 3.0 ! 调用方式 call external_sub(a, b, c) ! 三个参数都提供 print *, 'c = ', c call external_sub(a, c=c) ! 只提供第一个和第三个参数（使用关键字参数） print *, 'c = ', c end program main ``` 注意：在接口块中，我们声明了可选参数（optional）属性，这样在主程序中调用时就可以使用可选参数，并且可以使用关键字参数（如`c=c`）来指定。 使用接口块的好处是，它使得编译器能够检查调用的正确性（参数数量、类型、属性等），从而避免一些难以调试的错误。 然而，如果外部子程序很多，每个都写接口块会很繁琐。因此，Fortran 90推荐将相关的子程序放在模块中，然后通过模块来使用它们，这样编译器会自动生成接口，无需手动编写。 例如，将外部函数放在模块中： 文件 `my_module.f90`： ```fortran module my_module implicit none contains function external_function(a, b) result(c) real, intent(in) :: a, b real :: c c = a + b end function external_function end module my_module ``` 主程序文件 `main.f90`： ```fortran program main use my_module ! 使用模块，这样模块中的函数自动具有显式接口 implicit none real :: a, b, c a = 5.0 b = 3.0 c = external_function(a, b) print *, 'The sum is ', c end program main ``` 这样，通过模块使用子程序是更简洁、更安全的方式。 但是，如果你不能修改外部子程序（比如它是第三方库），那么你就需要手动编写接口块。 总结： 在Fortran 90中，为外部子程序声明接口的方法是在主程序中使用接口块（interface block）。接口块应该包含子程序的完整声明，包括所有参数和返回值的类型、属性（如intent, optional, pointer等）。这样编译器就能进行类型和属性检查，保证调用正确。 然而，如果可能，建议将子程序封装在模块中，然后通过use语句使用模块，这样可以自动生成接口。 §§相关问题§§: 1. 在Fortran90中，模块（module）和接口块（interface）有什么区别？ 2. 如何为Fortran中的外部子程序（不在模块中）编写接口块，特别是当子程序的参数是数组时？ 3. 在Fortran90中，使用接口块有什么性能上的影响吗？ 4. 如果外部子程序的参数是假定形状数组（assumed-shape array），那么在接口块中应该如何声明？</think>### 在Fortran90中声明外部子程序接口 在Fortran90中，当主程序需要调用外部文件中的子程序（函数或子例程）时，为了确保类型安全和正确调用，需要显式声明接口块（interface block）。以下是详细解决方案： #### 解决方案代码 ```fortran ! main.f90 - 主程序文件 program main implicit none ! 声明外部子程序的接口块 interface real function external_func(x, y) real, intent(in) :: x, y end function external_func subroutine external_sub(arr, size, flag) integer, intent(in) :: size real, dimension(size), intent(inout) :: arr logical, intent(out) :: flag end subroutine external_sub end interface ! 变量声明 real :: a = 3.0, b = 4.0, result real, dimension(5) :: array = [1.0, 2.0, 3.0, 4.0, 5.0] logical :: status ! 调用外部函数 result = external_func(a, b) print *, "Function result:", result ! 调用外部子例程 call external_sub(array, 5, status) print *, "Subroutine status:", status end program main ``` ```fortran ! external.f90 - 外部子程序文件 real function external_func(x, y) implicit none real, intent(in) :: x, y external_func = sqrt(x**2 + y**2) end function external_func subroutine external_sub(arr, size, flag) implicit none integer, intent(in) :: size real, dimension(size), intent(inout) :: arr logical, intent(out) :: flag arr = arr * 2.0 ! 数组元素翻倍 flag = all(arr > 0.0) ! 检查是否全为正数 end subroutine external_sub ``` #### 代码解释 1. **接口块声明**： - 使用`interface`和`end interface`关键字包裹外部子程序声明 - 精确复制子程序的参数列表和属性（如`intent`） - 函数需声明返回类型（如`real function`） 2. **关键属性说明**： - `intent(in)`：输入参数（不可修改） - `intent(out)`：输出参数（未初始化） - `intent(inout)`：输入输出参数（可修改） - `dimension(size)`：显式形状数组声明 3. **编译和执行**： ```bash gfortran -c external.f90 # 编译外部子程序 gfortran main.f90 external.o -o program # 链接主程序 ./program # 运行程序 ``` 4. **注意事项**： - 接口声明必须与子程序实际定义完全一致 - 对于可选参数，需添加`optional`属性 - 对于指针参数，需添加`pointer`属性 - 对于字符型函数，需指定返回长度 #### 替代方案：使用模块 更推荐的方式是将子程序封装在模块中，避免手动声明接口： ```fortran ! my_module.f90 module my_module implicit none contains real function mod_func(x, y) real, intent(in) :: x, y mod_func = sqrt(x**2 + y**2) end function subroutine mod_sub(arr, flag) real, dimension(:), intent(inout) :: arr logical, intent(out) :: flag arr = arr * 2.0 flag = all(arr > 0.0) end subroutine end module ! main.f90 program main use my_module ! 自动包含接口 real :: arr(5) = [1,2,3,4,5] logical :: flag print *, mod_func(3.0, 4.0) ! 输出 5.0 call mod_sub(arr, flag) end program ```
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值