FORTRAN过程
过程是一组执行一个明确的任务，可以从你的程序中调用语句。信息（或数据）被传递给调用的程序，向步骤作为参数。
有两种类型的程序：
- 功能
- 子程序
功能
函数是返回一个单一的量的过程。函数不应该修改其参数。
返回的数量被称为函数值 ，并且它由函数名表示。
句法：
语法功能如下：
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
请注意：
必须指定在两个主程序隐无以及程序。
在被调用函数的参数r被称为伪参数 。
结果选项
如果你想返回的值存储在其它一些名称与功能名称，您可以使用结果选项。
您可以指定返回变量名：
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]
调用子程序
您需要使用呼叫语句调用的子程序。
下面的例子演示了一个子程序交换，改变其参数值的定义和使用。
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
指定参数的意图
这样做的目的属性允许你指定与参数在程序中使用的意图。下表提供的意图属性的值：
| 值 | 作为 | 说明 |
|---|---|---|
| 在 | 意图（中） | 用作输入值，而不是在功能改变 |
| 出 | 意图（出） | 用作输出值，它们都将被覆盖 |
| 进出 | 意图（INOUT） | 参数都是使用和覆盖 |
下面的例子演示了这个概念：
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
递归过程
递归当编程语言，您可以调用同一个函数内的函数发生。这就是所谓的函数的递归调用。
当一个过程调用本身，直接或间接地被称为递归过程。你应该通过其声明之前递归字前面的声明这种类型的程序。
当一个函数被递归使用， 结果选项被使用。
以下是一个例子，它计算阶乘用于使用递归过程的给定数量：
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