Fortran
Explizite und implizite Schnittstellen

Interne / Modul-Unterprogramme und explizite Schnittstellen

Ein Unterprogramm (das eine Prozedur definiert) kann entweder ein subroutine oder eine function . Es wird gesagt, dass es ein internes Unterprogramm ist, wenn es von demselben program oder Unterprogramm aufgerufen oder aufgerufen wird, contains es contains , wie folgt

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 diesem Fall kennt der Compiler alle internen Prozeduren, da er die Teileinheit als Ganzes behandelt. Insbesondere wird die interface der Prozedur "gesehen"

• ob es sich um eine function oder eine subroutine ,
• Welches sind die Namen und Eigenschaften der Argumente a1 , a2 , x1 , x2 , ...,
• Welches sind die Eigenschaften des Ergebnisses f (im Falle einer function ).

Als bekanntes Interface kann der Compiler prüfen, ob die an die Prozedur übergebenen tatsächlichen Argumente ( arg1 , arg2 , xx1 , xx2 , fx , ...) mit den Dummy-Argumenten ( a1 , a2 , x1 , x2 , f , ..) übereinstimmen. .).

In diesem Fall sagen wir, dass die Schnittstelle explizit ist .

Ein Unterprogramm wird als Modul-Unterprogramm bezeichnet, wenn es von einer Anweisung im übergeordneten Modul selbst aufgerufen wird.

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

oder durch eine Anweisung in einer anderen Programmeinheit, use dieses Modul verwendet,

program my_prog

  use my_mod

  call my_mod_sub(...)

end program my_prog

Wie in der vorherigen Situation weiß der Compiler alles über das Unterprogramm, und wir sagen, dass die Schnittstelle explizit ist .

Externe Unterprogramme und implizite Schnittstellen

Ein Unterprogramm wird als extern bezeichnet, wenn es weder im Hauptprogramm noch in einem Modul oder einem anderen Unterprogramm enthalten ist. Insbesondere kann es mit Hilfe einer anderen Programmiersprache als Fortran definiert werden.

Wenn ein externes Unterprogramm aufgerufen wird, kann der Compiler nicht auf seinen Code zugreifen, sodass alle Informationen, die für den Compiler zulässig sind, implizit in der aufrufenden Anweisung des aufrufenden Programms enthalten sind und im Typ a die Eigenschaften der aktuellen Argumente und nicht die Dummy-Argumente ( deren Deklaration dem Compiler nicht bekannt ist). In diesem Fall sagen wir, dass die Schnittstelle implizit ist .

Eine external Anweisung kann verwendet werden, um anzugeben, dass der Name einer Prozedur relativ zu einer externen Prozedur ist.

external external_name_list

Trotzdem bleibt die Schnittstelle implizit.

Mit einem interface kann die Schnittstelle einer externen Prozedur festgelegt werden.

interface
  interface_body
end interface

wobei der interface_body normalerweise eine exakte Kopie des Prozedurheaders ist, gefolgt von der Deklaration aller seiner Argumente und, wenn es sich um eine Funktion handelt, des Ergebnisses.

Zum Beispiel für die Funktion WindSpeed

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

Sie können die folgende Schnittstelle schreiben

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