Fortran
Explicit och implicit gränssnitt

Internprogram / modulunderprogram och explicita gränssnitt

Ett underprogram (som definierar en procedur ) kan vara antingen en subroutine eller en function ; det sägs vara ett internt underprogram om det kallas eller åberopas från samma program eller underprogram som contains det, enligt följande

program my_program

  ! declarations
  ! executable statements,
  ! among which an invocation to
  ! internal procedure(s),
  call my_sub(arg1,arg2,...)
  fx = my_fun(xx1,xx2,...)

contains
  
  subroutine my_sub(a1,a2,...)
    ! declarations
    ! executable statements
  end subroutine my_sub

  function my_fun(x1,x2,...) result(f)
    ! declarations
    ! executable statements
  end function my_fun

end program my_program

I detta fall kommer kompilatorn att veta allt om alla interna procedurer, eftersom den behandlar programenheten som helhet. I synnerhet kommer det att "se" procedurens interface , det vill säga

• vare sig det är en function eller subroutine ,
• som är namnen och egenskaperna för argumenten a1 , a2 , x1 , x2 , ...,
• som är egenskaperna för resultatet f (i fallet med en function ).

Eftersom gränssnittet är känt kan kompilatorn kontrollera om de faktiska argumenten ( arg1 , arg2 , xx1 , xx2 , fx , ...) gått till proceduren matchar dummy-argumenten ( a1 , a2 , x1 , x2 , f , .. .).

I det här fallet säger vi att gränssnittet är uttryckligt .

Ett underprogram sägs vara modulens subprogram när det åberopas av ett uttalande i själva innehållande modulen,

module my_mod

  ! declarations

contains
  
  subroutine my_mod_sub(b1,b2,...)
    ! declarations
    ! executable statements
    r = my_mod_fun(b1,b2,...)
  end subroutine my_sub

  function my_mod_fun(y1,y2,...) result(g)
    ! declarations
    ! executable statements
  end function my_fun

end module my_mod

eller genom ett uttalande i en annan programenhet som use den modulen,

program my_prog

  use my_mod

  call my_mod_sub(...)

end program my_prog

Precis som i föregående situation kommer kompilatorn att veta allt om delprogrammet och därför säger vi att gränssnittet är uttryckligt .

Externa underprogram och implicita gränssnitt

Ett underprogram sägs vara externt när det inte finns i huvudprogrammet, inte heller i en modul eller ett annat underprogram. Speciellt kan det definieras med hjälp av ett annat programmeringsspråk än Fortran.

När ett externt underprogram startas kan kompilatorn inte komma åt sin kod, så all information som tillåts för kompilatorn finns implicit i samtalsprogrammet för samtalsprogrammet och i typen en egenskap hos de akutala argumenten, inte dummy-argumenten ( vars förklaring är okänd för kompilatorn). I det här fallet säger vi att gränssnittet är implicit .

Ett external uttalande kan användas för att specificera att namnet på en procedur är relativt en extern procedur,

external external_name_list

men ändå så förblir gränssnittet implicit.

Ett interface kan användas för att specificera gränssnittet för en extern procedur,

interface
  interface_body
end interface

där interface_body normalt är en exakt kopia av procedurhuvudet följt av deklarationen av alla dess argument och, om det är en funktion, av resultatet.

Till exempel för funktionen WindSpeed

real function WindSpeed(u, v)
  real, intent(in) :: u, v
  WindSpeed = sqrt(u*u + v*v)
end function WindSpeed

Du kan skriva följande gränssnitt

interface
  real function WindSpeed(u, v)
    real, intent(in) :: u, v
  end function WindSpeed
end interface