過程是一組執行一個明確定義的任務，可以從程式呼叫語句。資訊(或資料)被傳遞給呼叫程式，以過程作為引數。
有兩種型別的程式：
函式是返回一個數量的過程。函式不修改其引數。
返回數值被稱為函式值，並將其表示為函式名。
語法：
函式的語法如下：
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被稱為 dummy argument.
結果選項
如果想返回的值儲存在函式名的其他名稱，則可以使用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屬性的值：
| 值 | 使用為 | 解釋 |
|---|---|---|
| in | intent(in) | 用作輸入值，而不是在函式中改變 |
| out | intent(out) | 用作輸出值，它們將被覆蓋 |
| inout | intent(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
遞回發生在一個程式設計語言可以呼叫同一個函式在函式內。這就是所謂的函式的遞迴呼叫。
當一個過程呼叫本身，直接或間接地被稱為遞回過程。應該通過其宣告之前的字前面遞迴宣告這種型別的程式。
當一個函式被遞回使用，則 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