In questo articolo vedremo come utilizzare le interfacce nel Fortran per definire un sottoprogramma. Le interfacce sono necessarie per definire un sottoprogramma generico. L’ interfaccia è  un blocco di istruzioni non eseguibili  che serve a informare il compilatore sui tipi dati e numero degli argomenti dei sottoprogrammi utilizzati, in mdo che eventuali  utilizzi incoerenti (numero di argomenti diverso,  tipi dati differenti)  possa essere segnalato al momento della compilazione.

La sintassi per definire un blocco interfaccia è la seguente:

interface
...
end interface

al cui interno vanno inseriti i soli blocchi di dichiarazione dei sottoprogrammi e dei rispettivi argomenti. Non vanno messe nell’ interfaccia né  le dichiarazioni di variabili locali né  le istruzioni eseguibili dei sottoprogrammi.
In un blocco interfaccia si possono collocare le dichiarazioni relative a più  sottoprogrammi. Si possono anche avere più  blocchi interfaccia nella stessa unità  di programma.

Le interfacce nel Fortran riferiscono la specifica conoscenza che il compilatore ha circa una procedura durante la sua compilazione. Se l’interfaccia è esplicita, il compilatore può verificare che il sottoprogramma venga richiamato correttamente. Se, tuttavia, l’interfaccia è implicita, il compilatore Fortran 90 non dispone di informazioni sui tipi e numero di argomenti utilizzati dal sottoprogramma o il valore di ritorno del risultato di una funzione.

La Tipizzazione implicita viene utilizzata nel programma chiamante per determinare il risultato restituito da una funzione, nel caso in cui non si disponga della dichiarazione. Di conseguenza, nessun tipo di controllo può essere fatto per verificare che un sottoprogramma è stato chiamato correttamente. Diremo allora implicite tutte le interfacce che sono disponibili nel Fortran 77.

Ad esempio la funzione sin (x)  calcola, in modo appropriato, il seno del suo argomento, se x è singola o in doppia precisione, oppure un numero reale o complesso. In Fortran 90, i sottoprogrammi definiti dall’utente possono essere generici nello stesso senso. Le funzioni generiche e le subroutine possono essere definiti, analogamente a qualsiasi altro sottoprogramma, anche se l’interfaccia deve essere esplicita. Il modo usuale di definire una tale funzione generica è quella di inserirlo in un modulo, come nell’esempio riportato di seguito.

module AritmeticaRazionale
   type rational
      integer n, d   ! Numeratore e denominatore.
   end type rational

   interface operator (*)
      module procedure integerRationalMultiply, &
                       rationalIntegerMultiply
   end interface

   contains

   function integerRationalMultiply( i, r )
      type( rational ) integerRationalMultiply
      integer, intent( in ) :: i
      type( rational ), intent( in ) :: r

      integerRationalMultiply = rational( i * r%n, r%d )
   end function integerRationalMultiply

   function rationalIntegerMultiply( r, i )
      type( rational ) rationalIntegerMultiply
      type( rational ), intent( in ) :: r
      integer, intent( in ) :: i

      rationalIntegerMultiply = rational( i * r%n, r%d )
   end function rationalIntegerMultiply

end module AritmeticaRazionale

LINK DI APPROFONDIMENTO PER L’ARGOMENTO:

• Programmare con Fortran
• I moduli nel Fortran
• Cicli a condizione iniziale nel Fortran
• Istruzione Select Case nel Fortran
• Istruzione if nel Fortran