Fortran
Interfacce esplicite e implicite

Sottoprogrammi interni / moduli e interfacce esplicite

Un sottoprogramma (che definisce una procedura ) può essere una subroutine o una function ; si dice che sia un sottoprogramma interno se viene chiamato o invocato dallo stesso program o sottoprogramma che lo contains , come segue

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 questo caso il compilatore saprà tutto su qualsiasi procedura interna, poiché tratta l'unità di programma come un tutto. In particolare, "vedrà" l' interface della procedura, cioè

• se si tratta di una function o subroutine ,
• quali sono i nomi e le proprietà degli argomenti a1 , a2 , x1 , x2 , ...,
• quali sono le proprietà del risultato f (nel caso di una function ).

Essendo l'interfaccia nota, il compilatore può verificare se gli argomenti effettivi ( arg1 , arg2 , xx1 , xx2 , fx , ...) passati alla procedura coincidono con gli argomenti dummy ( a1 , a2 , x1 , x2 , f , .. .).

In questo caso diciamo che l'interfaccia è esplicita .

Si dice che un sottoprogramma è un sottoprogramma del modulo quando viene invocato da un'istruzione nel modulo contenitore stesso,

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

o da una dichiarazione in un'altra unità di programma che use quel modulo,

program my_prog

  use my_mod

  call my_mod_sub(...)

end program my_prog

Come nella situazione precedente, il compilatore saprà tutto sul sottoprogramma e, quindi, diciamo che l'interfaccia è esplicita .

Sottoprogrammi esterni e interfacce implicite

Si dice che un sottoprogramma è esterno quando non è contenuto nel programma principale, né in un modulo o sottoprogramma antoher. In particolare, può essere definito mediante un linguaggio di programmazione diverso da Fortran.

Quando viene richiamato un sottoprogramma esterno, il compilatore non può accedere al suo codice, quindi tutte le informazioni permesse al compilatore sono implicitamente contenute nell'istruzione chiamante del programma chiamante e nel tipo una proprietà degli argomenti acutali, non gli argomenti fittizi ( la cui dichiarazione è sconosciuta al compilatore). In questo caso diciamo che l'interfaccia è implicita .

È possibile utilizzare un'istruzione external per specificare che il nome di una procedura è relativo a una procedura esterna,

external external_name_list

ma anche così, l'interfaccia rimane implicita.

Un blocco di interface può essere usato per specificare l'interfaccia di una procedura esterna,

interface
  interface_body
end interface

dove l' interface_body è normalmente una copia esatta dell'intestazione della procedura seguita dalla dichiarazione di tutti i suoi argomenti e, se si tratta di una funzione, del risultato.

Ad esempio, per la funzione WindSpeed

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

Puoi scrivere la seguente interfaccia

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