Fortran過(guò)程

過(guò)程是一組執(zhí)行一個(gè)明確定義的任務(wù)，可以從程序調(diào)用語(yǔ)句。信息(或數(shù)據(jù))被傳遞給調(diào)用程序，以過(guò)程作為參數(shù)。

有兩種類(lèi)型的程序：

• 函數(shù)
• 子程序

函數(shù)

函數(shù)是返回一個(gè)數(shù)量的過(guò)程。函數(shù)不修改其參數(shù)。

返回?cái)?shù)值被稱(chēng)為函數(shù)值，并將其表示為函數(shù)名。

語(yǔ)法：

函數(shù)的語(yǔ)法如下：

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

下面的示例演示一個(gè)函數(shù)名為area_of_circle。它計(jì)算半徑為 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

當(dāng)編譯并執(zhí)行上述程序，它會(huì)產(chǎn)生以下結(jié)果：

The area of a circle with radius 2.0 is
   12.5663710   

請(qǐng)注意：

• 必須指定隱含都不在這兩個(gè)在主程序和過(guò)程中。

• 在被調(diào)用函數(shù)的參數(shù)r被稱(chēng)為 dummy argument.

結(jié)果選項(xiàng)

如果想返回的值存儲(chǔ)在函數(shù)名的其他名稱(chēng)，則可以使用result選項(xiàng)。

可以根據(jù)指定返回變量名：

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

子程序

子程序沒(méi)有返回值，但可以修改其參數(shù)。

語(yǔ)法

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

調(diào)用子程序

需要使用call語(yǔ)句來(lái)調(diào)用一個(gè)子程序。

下面的例子演示了一個(gè)子程序交換，改變其參數(shù)值的定義和使用。

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

當(dāng)編譯并執(zhí)行上述程序，它會(huì)產(chǎn)生以下結(jié)果：

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

指定參數(shù)的意圖

意圖屬性允許指定與參數(shù)的過(guò)程中使用的意向。下表提供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

當(dāng)編譯并執(zhí)行上述程序，它會(huì)產(chǎn)生以下結(jié)果：

The value of the discriminant is
   17.0000000    

遞歸過(guò)程

遞歸發(fā)生在一個(gè)編程語(yǔ)言可以調(diào)用同一個(gè)函數(shù)在函數(shù)內(nèi)。這就是所謂的函數(shù)的遞歸調(diào)用。

當(dāng)一個(gè)過(guò)程調(diào)用本身，直接或間接地被稱(chēng)為遞歸過(guò)程。應(yīng)該通過(guò)其聲明之前的字前面遞歸聲明這種類(lèi)型的程序。

當(dāng)一個(gè)函數(shù)被遞歸使用，則 result 選項(xiàng)要被使用。

以下是一個(gè)例子，它計(jì)算階乘用于使用一個(gè)遞歸過(guò)程：

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

內(nèi)部過(guò)程

當(dāng)一個(gè)過(guò)程被包含在程序中，它被稱(chēng)為程序的內(nèi)部程序。包含一個(gè)內(nèi)部程序的語(yǔ)法如下：

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   

當(dāng)編譯并執(zhí)行上述程序，它會(huì)產(chǎn)生以下結(jié)果：

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