Fortran
Expliciete en impliciete interfaces

Interne / module-subprogramma's en expliciete interfaces

Een subprogramma (dat een procedure definieert) kan een subroutine of een function ; er wordt gezegd dat het een intern subprogramma is als het wordt aangeroepen of opgeroepen vanuit hetzelfde program of subprogramma dat het contains , als volgt

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

In dit geval weet de compiler alles over elke interne procedure, omdat deze de programma-eenheid als geheel behandelt. In het bijzonder zal het de interface de procedure "zien", dat wil zeggen

• of het nu een function of een subroutine ,
• dat zijn de namen en eigenschappen van de argumenten a1 , a2 , x1 , x2 , ...,
• dat zijn de eigenschappen van het resultaat f (in het geval van een function ).

Omdat de interface bekend is, kan de compiler controleren of de werkelijke argumenten ( arg1 , arg2 , xx1 , xx2 , fx , ...) zijn doorgegeven aan de procedureovereenkomst met de dummy-argumenten ( a1 , a2 , x1 , x2 , f , .. .).

In dit geval zeggen we dat de interface expliciet is .

Van een subprogramma wordt gezegd dat het modulesubprogramma is wanneer het wordt opgeroepen door een verklaring in de bevattende module zelf,

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

of van een verklaring in een ander programma eenheid die use is die module,

program my_prog

  use my_mod

  call my_mod_sub(...)

end program my_prog

Net als in de voorgaande situatie weet de compiler alles over het subprogramma en daarom zeggen we dat de interface expliciet is .

Externe subprogramma's en impliciete interfaces

Van een subprogramma wordt gezegd dat het extern is wanneer het niet is opgenomen in het hoofdprogramma, noch in een module of antoher subprogramma. In het bijzonder kan het worden gedefinieerd door middel van een andere programmeertaal dan Fortran.

Wanneer een extern subprogramma wordt opgeroepen, heeft de compiler geen toegang tot de code, dus alle informatie die aan de compiler is toegestaan, bevindt zich impliciet in de aanroepinstructie van het aanroepende programma en in het type eigenschappen van de acutale argumenten, niet de dummy-argumenten ( waarvan de verklaring onbekend is voor de compiler). In dit geval zeggen we dat de interface impliciet is .

Een external verklaring kan worden gebruikt om aan te geven dat de naam van een procedure relatief is aan een externe procedure,

external external_name_list

maar toch blijft de interface impliciet.

Een interface kan worden gebruikt om de interface van een externe procedure te specificeren,

interface
  interface_body
end interface

waarbij de interface_body normaal gesproken een exacte kopie is van de procedurekop, gevolgd door de verklaring van alle argumenten en, als het een functie is, van het resultaat.

Bijvoorbeeld voor de functie WindSpeed

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

U kunt de volgende interface schrijven

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