Fortran 程序

程序是一组执行明确任务的语句，可以从程序中调用。信息（或数据）作为参数传递给调用程序。

有两种类型的程序:

• Functions
• Subroutines

函数

函数是一个返回单个数量的过程。函数不应修改其参数。

返回的数量称为函数值，由函数名表示。

语法

function name(arg1, arg2, ....)
   [declarations, including those for the arguments]
   [executable statements]
end function [name]

以下实例演示了一个名为 area_of_circle 的函数，它计算半径为 r 的圆的面积：

program calling_func
   real :: a
   a = area_of_circle(2.0)
   Print *, "The area of a circle with radius 2.0 is"
   Print *, a
end program calling_func
! this function computes the area of a circle with radius r
function area_of_circle (r)
! function result
implicit none
   ! dummy arguments
   real :: area_of_circle
   ! local variables
   real :: r
   real :: pi
   pi = 4 * atan (1.0)
   area_of_circle = pi * r**2
end function area_of_circle

结果为：

The area of a circle with radius 2.0 is
   12.5663710

注意

• 您必须在主程序和过程中都指定隐式 none。
• 被调用函数中的参数 r 称为伪参数。

结果选项

如果希望将返回值存储在函数名以外的其他名称中，可以使用 result 选项。

您可以将返回变量名称指定为：

function name(arg1, arg2, ....) result (return_var_name)
   [declarations, including those for the arguments]
   [executable statements]
end function [name]

子程序

子程序不返回值，但可以修改其参数。

语法

subroutine name(arg1, arg2, ....)
   [declarations, including those for the arguments]
   [executable statements]
end subroutine [name]

调用子程序

您需要使用 call 语句调用子程序。

以下实例演示了更改其参数值的子程序交换的定义和使用。

program calling_func
implicit none
   real :: a, b
   a = 2.0
   b = 3.0
   Print *, "Before calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
   call swap(a, b)
   Print *, "After calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
end program calling_func
subroutine swap(x, y)
implicit none
   real :: x, y, temp
   temp = x
   x = y
   y = temp
end subroutine swap

结果为：

Before calling swap
a = 2.00000000
b = 3.00000000
After calling swap
a = 3.00000000
b = 2.00000000

指定参数的 intent 属性

intent 属性让您可以指定在过程中使用参数的意图。下表提供了 intent 属性的值：

比如下面的实例：

program calling_func
implicit none
   real :: x, y, z, disc
   x = 1.0
   y = 5.0
   z = 2.0
   call intent_example(x, y, z, disc)
   Print *, "The value of the discriminant is"
   Print *, disc
end program calling_func
subroutine intent_example (a, b, c, d)
implicit none
   ! dummy arguments
   real, intent (in) :: a
   real, intent (in) :: b
   real, intent (in) :: c
   real, intent (out) :: d
   d = b * b - 4.0 * a * c
end subroutine intent_example

结果为：

The value of the discriminant is
   17.0000000

递归程序

当编程语言允许您调用同一函数内的函数时，就会发生递归。这被称为函数的递归调用。

当一个过程直接或间接地调用自身时，称为递归过程。您应该在声明递归一词之前声明这类过程。

当递归使用函数时，必须使用 result 选项。

以下是一个实例，它使用递归过程计算给定数字的阶乘：

program calling_func
implicit none
   integer :: i, f
   i = 15
   Print *, "The value of factorial 15 is"
   f = myfactorial(15)
   Print *, f
end program calling_func
! computes the factorial of n (n!)
recursive function myfactorial (n) result (fac)
! function result
implicit none
   ! dummy arguments
   integer :: fac
   integer, intent (in) :: n
   select case (n)
      case (0:1)
         fac = 1
      case default
         fac = n * myfactorial (n-1)
   end select
end function myfactorial

内部程序

当程序中包含一个程序时，它被称为程序的内部程序。包含内部程序的语法如下：

program program_name
   implicit none
   ! type declaration statements
   ! executable statements
   . . .
   contains
   ! internal procedures
   . . .
end program program_name

实例如下：

program mainprog
implicit none
   real :: a, b
   a = 2.0
   b = 3.0
   Print *, "Before calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
   call swap(a, b)
   Print *, "After calling swap"
   Print *, "a = ", a
   Print *, "b = ", b
contains
   subroutine swap(x, y)
      real :: x, y, temp
      temp = x
      x = y
      y = temp
   end subroutine swap
end program mainprog

结果如下：

Before calling swap
a = 2.00000000
b = 3.00000000
After calling swap
a = 3.00000000
b = 2.00000000