Fortran
Interfaces explicites et implicites

Sous-programmes internes / modules et interfaces explicites

Un sous-programme (qui définit une procédure ) peut être soit un subroutine - subroutine soit une function . il est dit être un sous - programme interne s'il est appelé ou appelé depuis le même program ou sous - programme qui le contains , comme suit

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

Dans ce cas, le compilateur sera au courant de toute procédure interne, car il traite l'unité de programme dans son ensemble. En particulier, il "verra" l' interface la procédure, c'est-à-dire

• que ce soit une function ou un subroutine - subroutine ,
• qui sont les noms et propriétés des arguments a1 , a2 , x1 , x2 , ...,
• quelles sont les propriétés du résultat f (dans le cas d'une function ).

Étant donné que l'interface est connue, le compilateur peut vérifier si les arguments réels ( arg1 , arg2 , xx1 , xx2 , fx , ...) transmis à la procédure correspondent aux arguments factices ( a1 , a2 , x1 , x2 , f , .. .).

Dans ce cas, on dit que l'interface est explicite .

On dit qu'un sous-programme est un sous-programme de module lorsqu'il est appelé par une instruction dans le module contenant lui-même,

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

ou par une déclaration dans une autre unité de programme use ce module,

program my_prog

  use my_mod

  call my_mod_sub(...)

end program my_prog

Comme dans la situation précédente, le compilateur saura tout sur le sous-programme et, par conséquent, nous disons que l'interface est explicite .

Sous-programmes externes et interfaces implicites

Un sous-programme est dit externe lorsqu'il n'est pas contenu dans le programme principal, ni dans un module, ni dans un autre sous-programme. En particulier, il peut être défini au moyen d'un langage de programmation autre que Fortran.

Lorsqu'un sous-programme externe est invoqué, le compilateur ne peut pas accéder à son code, de sorte que toutes les informations admissibles au compilateur sont implicitement contenues dans l'instruction appelante du programme appelant et dans le type a les propriétés des arguments, dont la déclaration est inconnue du compilateur). Dans ce cas, nous disons que l'interface est implicite .

Une instruction external peut être utilisée pour spécifier que le nom d'une procédure est relatif à une procédure externe,

external external_name_list

mais malgré tout, l'interface reste implicite.

Un bloc d' interface peut être utilisé pour spécifier l'interface d'une procédure externe,

interface
  interface_body
end interface

où l' interface_body est normalement une copie exacte de l'en-tête de procédure suivie de la déclaration de tous ses arguments et, s'il s'agit d'une fonction, du résultat.

Par exemple, pour la fonction WindSpeed

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

Vous pouvez écrire l'interface suivante

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