📅 最后修改于: 2020-11-04 06:20:07 🧑 作者: Mango
过程是一组执行明确定义的任务的语句，可以从您的程序中调用它们。信息(或数据)作为参数传递给调用程序，并传递给过程。
有两种类型的程序-
函数是返回单个数量的过程。函数不应修改其参数。
返回的数量称为函数值，并由函数名称表示。
句法
函数的语法如下-
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称为伪参数。
如果要以函数名称以外的其他名称存储返回的值，则可以使用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属性的值-
| Value | Used as | Explanation |
|---|---|---|
| in | intent(in) | Used as input values, not changed in the function |
| out | intent(out) | Used as output value, they are overwritten |
| inout | intent(inout) | Arguments are both used and overwritten |
以下示例演示了概念-
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