Fortran: Fortran 95: Unterprogramme
<<< zur Fortran-Startseite | |
<< Fortran 95 | Fortran 2003 >> |
< Standardfunktionen | Ein- und Ausgabe > |
Werden Programme umfangreicher und komplexer oder werden einzelne Programmabschnitte öfter verwendet, dann ist es sinnvoll Unterprogramme (Prozeduren) zu verwenden. Fortran 95 kennt zwei Typen von Unterprogrammen:
- Funktionen (
function
) - Subroutinen (
subroutine
)
Darüber hinaus existiert in Fortran die Möglichkeit Unterprogramme und Daten mittels Modulen in das Programm einzubeziehen.
Das function
Unterprogramm
Bearbeiten
Eine Funktion ist ein Unterprogramm, das genau einen Wert zurück gibt. Welcher Art von Datentyp der Wert ist, wird durch eine Zuweisung an den Funktionsnamen erreicht ( z. B. real
).
Die allgemeine Funktionsdeklaration lautet:
datentyp function funktionsname ( [formale parameter] ) Vereinbarungsteil Anweisungsteil funktionsname = wert [return] end function funktionsname |
Wird der Datentyp bei der Funktionsdeklaration nicht angegeben, so muss der Datentyp der Funktion im Vereinbarungsteil festgelegt werden:
function funktionsname ( [formale parameter] ) Vereinbarungsteil datentyp :: funktionsname Anweisungsteil funktionsname = wert [return] end function funktionsname |
Mittels return
kann zur aufrufenden Programmeinheit zurückgekehrt werden. Ein return
unmittelbar vor der end
-Anweisung ist nicht unbedingt erforderlich, da das Programm beim Erreichen der end
-Anweisung zur aufrufenden Programmeinheit zurück springt. Deswegen sollte bei allen neueren Programmen darauf verzichtet werden. Wichtig ist die return
-Anweisung für alternative Rücksprünge zur aufrufenden Programmeinheit.
Eine Funktion wird meist mittels folgender allgemeiner Anweisung von der ausführenden Programmeinheit aufgerufen:
variable = funktionsname( aktuelle parameter ) |
Dabei orientiert sich diese Unterprogrammtechnik direkt an mathematischen Funktionen. Im folgenden Beispiel ruft das Programm test
die Funktion funk
auf, führt das Unterprogramm aus und gibt den entsprechenden Rückgabewert an das Programm test
zurück:
Datei bsp.f95:
Fortran 90/95-Code (free source form) |
program test ! implicit none real :: funk real :: x, y write(*,*) 'x -> ' read(*,*) x y = funk( x ) write(*,*) 'funk -> ', y end program test real function funk( a ) ! implicit none real :: a funk = a**2 end function funk |
Das Unterprogramm funk
kann sich direkt unter der aufrufenden Programmeinheit in der selben Textdatei oder in einer separaten Datei befinden. Befindet sich das Unterprogramm in einer separaten Datei, so muss diese und die aufrufende Programmeinheit zusammen kompiliert werden:
Übersetzung mit gfortran im vorliegenden Fall:
gfortran -o bsp bsp.f95
Übersetzung mit gfortran bei separaten Dateien (bspw.):
gfortran -o bsp bsp.f95 funk.f95
Es ist aber auch möglich eine Funktion nur durch ihren Namen aufzurufen. Der Rückgabewert der Funktion wird dann direkt ausgegeben:
Datei bsp.f95:
Fortran 90/95-Code (free source form) |
program test ! implicit none real :: funk real :: x write(*,*) 'x -> ' read(*,*) x write(*,*) 'funk -> ', funk( x ) end program test real function funk( a ) ! implicit none real :: a funk = a**2 end function funk |
Das subroutine
Unterprogramm
Bearbeiten
Eine subroutine
ist ein Unterprogramm, das mehr als einen Wert zurückgeben kann. Eine Subroutine besitzt im Gegensatz zu einer Funktion keinen Datentyp und Rückgabewert.
Die allgemeine Deklaration einer Subroutine lautet:
subroutine subroutinenname ([formale parameter]) Vereinbarungsteil Anweisungsteil [return] end subroutine subroutinenname |
Mittels return
kann zur aufrufenden Programmeinheit zurückgekehrt werden. Ein return
unmittelbar vor der end
-Anweisung ist nicht unbedingt erforderlich, da das Programm beim Erreichen der end
zur aufrufendenen Programmeinheit zurück springt. Deswegen sollte bei allen neueren Programmen darauf verzichtet werden. Wichtig ist die return
Anweisung für alternative Rücksprünge zur aufrufenden Programmeinheit.
Aufgerufen wird eine Subroutine aus der aufrufenden Programmeinheit mittels der call
-Anweisung:
call subroutinenname [([aktuelle parameter])] |
Im folgenden Beispiel wird die Subroutine sub
aufgerufen. Diese gibt dann zwei Werte zurück:
Datei bsp.f95
Fortran 90/95-Code (free source form) |
program bsp ! implicit none real :: x, y, z write( *, * ) 'x -> ' read( *, * ) x call sub( x, y, z ) write( *, * ) 'y -> ', y, 'z -> ', z end subroutine sub( a, b, c ) ! implicit none real :: a, b, c b = a**2 c = a**2 + b end subroutine sub |
Weitere Anweisungen für die Unterprogrammtechnik
BearbeitenDas intent
-Attribut
Bearbeiten
Im Vereinbarungsteil der Funktion wird der Parameterdeklaration das Schlüsselwort intent
mitgegeben.
datentyp, intent( in ) :: var
Mit intent( in )
wird angezeigt, dass der Parameter var
in der Funktion nicht geändert wird und kein Rückfluss der Information in die aufrufende Programmeinheit stattfindet. Ein intent( out )
oder intent( inout )
wie bei Subroutinen wäre meist auch möglich, widerspricht aber dem Grundgedanken des Fortran-Funktionsbegriffs und der strukurierten Programmierung. Bei einer Funktion soll der Informationsrückfluss über den Rückgabewert stattfinden und nicht über Parameter.
Bei der Parameterübergabe bietet eine Subroutine folgende intent
-Möglichkeiten:
- datentyp, intent(in) :: var ... Informationfluss von der aufrufenden Programmeinheit in die Funktion
- datentyp, intent(out) :: var ... Informationfluss von der Subroutine zur aufrufenden Programmeinheit
- datentyp, intent(inout) :: var ... beidseitiger Informationsfluss
Beispiel:
Fortran 90/95-Code (free source form) |
program bsp implicit none real :: a, b, c a = 1.0 b = 2.0 c = 3.0 call sub(a, b, c) write (*,*) 'Hauptprogramm: ', a, b, c ! Ausgabe: 1.000000 22.20000 33.30000 end subroutine sub(x, y, z) implicit none real, intent(in) :: x real, intent(out) :: y real, intent(inout) :: z write (*,*) 'Unterprogramm: ', x, y, z ! Ausgabe: 1.000000 2.000000 3.000000 y = 22.2 z = 33.3 end subroutine sub |
Die aktuellen und formalen Parameter müssen hinsichtlich Datentyp, Anzahl, Reihenfolge übereinstimmen.
Die pure
Anweisung
Bearbeiten
Ein Unterprogramm welches keine Seiteneffekte hat ist ein bloßes bzw. reines (pure) Unterprogramm. Ein Unterprogramm erzeugt dann keine Seiteneffekte, wenn es weder seine Eingabedaten, noch die Daten verändert, die außerhalb des Unterprogrammes liegen, es sei denn, es wären seine Ausgabedaten. In einem reinen Unterprogramm haben die lokalen Variablen keine save
Attribute, noch werden die lokalen Variablen in der Datendeklaration initialisiert.
Reine Unterprogramme sind für das forall
-Konstrukt notwendig: das forall
-Konstrukt wurde für das parallele Rechnen konzipiert, weshalb hier der Computer entscheidet, wie das Konstrukt abgearbeitet werden soll. Dazu ist es aber notwendig, das es egal ist in welcher Reihenfolge das Konstrukt abgearbeitet wird. Gilt dies nicht - hat das Unterprogramm also Seiteneffekte - so kann das forall
-Konstrukt nicht verwendet werden.
Jedes Ein- und Ausgabeargument in einem reinen Unterprogramm muss mittels des intent
-Attributs deklariert werden. Darüberhinaus muss jedes Unterprogramm, das von einem reinen Unterprogramm aufgerufen werden soll, ebenfalls ein reines Unterprogramm sein. Sonst ist das aufrufende Unterprogramm kein reines Unterprogramm mehr.
Die elemental
Anweisung
Bearbeiten
Ein Unterprogramm ist elementar, wenn es als Eingabewerte sowohl Skalare als auch Felder akzeptiert. Ist der Eingabewert ein Skalar, so liefert ein elementares Unterprogramm einen Skalar als Ausgabewert. Ist der Eingabewert ein Feld, so ist der Ausgabewert ebenfalls ein Feld.
Die return
Anweisung
Bearbeiten
Eine return
-Anweisung darf nur im Gültigkeitsbereich von Unterprogrammen verwendet werden. Sie bewirkt einen Abbruch der Unterprogrammausführung und eine Rückkehr zum Aufrufpunkt, wo mit der nächsten Anweisung fortgesetzt wird.
Beispiel:
Fortran 90/95-Code (free source form) |
program main implicit none call xyz( -2 ) write( *, * ) "UP-Ende" stop write( *, * ) "Programmende" contains subroutine xyz( n ) integer, intent( in ) :: n integer :: k do k = n, n+20 write( *, * ) k if( k == 5 ) return end do write( *, * ) "k_max =", k end subroutine xyz ! Ausgabe: ! -2 ! -1 ! 0 ! 1 ! 2 ! 3 ! 4 ! 5 ! UP-Ende end program main |
Einige Compiler erlauben zwecks Programmabbruch auch ein return
anstelle des stop
im Hauptprogramm. Das ist aber nicht standardkonform. Andere Compiler würden solchen Code mit einer Fehlermeldung abweisen, das Programm wäre somit nicht mehr uneingeschränkt portabel.
Ein exit
in der Schleife anstelle der return
-Anweisung würde nur den Schleifendurchlauf abbrechen und die Unterprogrammausführung würde nach der Schleife fortgesetzt.
Felder als Parameter
BearbeitenBeispiel: Übergabe eines ganzen Feldes
Datei bsp.f95:
Fortran 90/95-Code (free source form) |
program bsp implicit none integer, dimension(3,3) :: feld integer :: cnt, i, j cnt = 1 do i = 1, 3 do j = 1, 3 feld(j,i) = cnt cnt = 1 + cnt end do end do ! Unterprogrammaufruf call sub(feld) ! Ausgabe: 1 2 3 4 5 6 7 8 9 end program bsp |
Datei sub.f95
Fortran 90/95-Code (free source form) |
subroutine sub(arr) implicit none integer, dimension(3,3), intent(in) :: arr write(*,*) arr end subroutine sub |
Beispiel: Übergabe einer Feld-Teilkette
Datei bsp.f95:
Fortran 90/95-Code (free source form) |
program bsp implicit none integer,dimension(3,3) :: feld integer :: cnt, i, j cnt = 1 do i = 1, 3 do j = 1, 3 feld(j,i) = cnt cnt = 1 + cnt end do end do ! Unterprogrammaufruf call sub(feld(1:2,2:3)) ! Ausgabe: 4 5 7 8 end program bsp |
Datei sub.f95
Fortran 90/95-Code (free source form) |
subroutine sub(arr) implicit none integer, dimension(0:1, 0:1), intent(in) :: arr write(*,*) arr end subroutine sub |
Beispiel: Übergabe eines Feld-Einzelelements
Datei bsp.f95:
Fortran 90/95-Code (free source form) |
program bsp implicit none integer, dimension(3,3) :: feld integer cnt, i, j cnt = 1 do i = 1, 3 do j = 1, 3 feld(j,i) = cnt cnt = 1 + cnt end do end do ! Unterprogrammaufruf call sub(feld(1,2)) ! Ausgabe: 4 end program bsp |
Datei sub.f95
Fortran 90/95-Code (free source form) |
subroutine sub(arr) implicit none integer, intent(in) :: arr write(*,*) arr end subroutine sub |
Prozeduren als Parameter
BearbeitenAuch Prozeduren können als Parameter übergeben werden.
Standardfunktionen (intrinsic functions) werden dazu folgendermaßen im Vereinbarungsteil gekennzeichnet:
intrinsic namensliste |
oder
datentyp, intrinsic :: namensliste |
Eigene Unterprogramme oder Unterprogramme aus Bibliotheken mit:
external namensliste |
oder
datentyp, external :: namensliste |
Beispiel:
Fortran 90/95-Code (free source form) |
program bsp real, parameter :: PI=3.1415927 ! intrinsic functions intrinsic sin, cos ! Unterprogrammaufrufe call sub(sin, PI) ! Ausgabe: 0.000000 call sub(cos, PI) ! Ausgabe: -1.000000 end program bsp subroutine sub(funk, x) implicit none real :: funk, x write(*,*) nint(funk(x)*1000)/1000.0 end subroutine sub |
Optionale Parameter
BearbeitenAb Fortran 90 sind auch optionale Parameter für Unterprogramme erlaubt. Solche Parameter sind durch das Attribut optional
zu kennzeichnen. Auch der aufrufenden Programmeinheit muss diese Parameter-Optionalität bekannt gegeben werden, z.B. über ein Interface. Das aktuelle Vorhandensein eines als optional markierten Parameters beim Unterprogrammaufruf kann im Unterprogramm selbst durch die Funktion present
geprüft werden.
Beispiel:
Fortran 90/95-Code (free source form) |
program bsp implicit none interface subroutine ab(a, b) integer, intent( in ) :: a integer, intent( in ), optional :: b end subroutine ab end interface call ab( 1 ) call ab( 8, 12 ) ! Ausgabe: ! Nur a gegeben 1 ! Beide Parameter gegeben 8 12 end program bsp subroutine ab(a, b) integer, intent( in ) :: a integer, intent( in ), optional :: b if( present( b ) ) then write (*,*) "Beide Parameter gegeben", a, b else write (*,*) "Nur a gegeben", a end if end subroutine ab |
Module
BearbeitenModule ersetzen in Fortran 95 die FORTRAN 77-COMMON
-Blöcke. In einem Modul können Variablen, Konstanten und auch Unterprogramme abgelegt werden. Diese können dann von verschiedenen Programmeinheiten angesprochen werden.
module modulname [implicit none] [save] Deklaration von Variablen, Konstanten [contains Unterprogramme ] end module modulname |
Das Einbinden eines Moduls in eine Programmeinheit geschieht mittels der Anweisung
use modulname [, only liste] |
only
signalisiert, dass nur die in liste
angegebenen Variablen oder Konstanten verwendet werden sollen.
Beispiel:
Fortran 90/95-Code (free source form) |
module m1 implicit none save real, parameter :: PI=3.1415 real :: a end module m1 program bsp use m1 implicit none a = 1.5 write(*,*) 'Hauptprogramm 1: ', PI, a ! Ausgabe: Hauptprogramm 1: 3.141500 1.500000 call sub write(*,*) 'Hauptprogramm 2: ', PI, a ! Ausgabe: Hauptprogramm 2: 3.141500 2.500000 end program bsp subroutine sub use m1 implicit none write(*,*) 'Unterprogramm: ', PI, a ! Ausgabe: Unterprogramm: 3.141500 1.500000 a = 2.5 end subroutine sub |
Das save
-Statement in Modulen stellt sicher, dass die aktuellen Werte von Modulvariablen beim Wechsel zwischen den verschiedenen Programmeinheiten sicher erhalten bleiben.
Rekursiver Unterprogrammaufruf
BearbeitenIn Fortran 95 können Unterprogramme (Funktionen, Subroutinen) auch rekursiv aufgerufen werden. Rekursion bedeutet, dass ein Unterprogramm sich selbst wieder aufruft (lat. recurrere oder en. recur ... wiederkehren, zurückkommen).
Beispiel: Berechnung von n! (vereinfacht)
Fortran 90/95-Code (free source form) |
program bsp implicit none integer :: zahl, ergebnis, fac write(*,*) "Gib eine Ganzzahl ein: " read(*,*) zahl ergebnis = fac(zahl) write(*,*) "Ergebnis ist: ", ergebnis end program bsp recursive function fac(n) result(zerg) implicit none integer, intent(in) :: n integer :: zerg ! Vereinfacht: Keine Überprüfung ob Überlauf, negative Zahl, etc. zerg = n if (n > 1) then zerg = n * fac(n-1) end if return end function fac |
Der Funktionskopf ist bei diesem Beispiel etwas anders gestaltet als üblich. Während der Intel-Fortran-Compiler auch ein
recursive integer function fac(n)
oder ein
integer recursive function fac(n)
problemlos akzeptiert, wirft der gfortran-Compiler bei diesen Varianten einen Syntaxfehler.
<<< zur Fortran-Startseite | |
<< Fortran 95 | Fortran 2003 >> |
< Standardfunktionen | Ein- und Ausgabe > |