Programmieren in Fortran 90/95


  1. Die Struktur von Fortran 90/95
  2. Wie wir gesehen haben, versteht man nach DIN 44300 Teil 4 unter einer Programmiersprache allgemein eine zum Abfassen von Computerprogrammen geschaffene Sprache. Unter einem Programm versteht man wiederum eine von einem Computer interpretierbare vollständige Arbeitsanweisung zur Lösung einer Aufgabe.

    Wie bei jeder anderen höheren Programmiersprache gelten auch in Fortran 90 strenge, formale Regeln für Syntax und Semantik.

    Syntax und Semantik - Wiederholung

Die Syntax bezeichnet die nach bestimmten Regeln festgelegten Verknüpfungsmöglichkeiten von Zeichen und Befehlen aus dem Zeichen- und Befehlsvorrat einer Programmiersprache.
Die Semantik entspricht der Bedeutung, die mit der Abfolge der Sprachelemente in der Programmiersprache verknüpft wird.

kurz:

  1. Mittels eines Hilfsprogramms (Compiler oder Interpreter) kann das Programm in die für den Computer verständliche Maschinensprache übersetzt und danach ausgeführt werden.
  1. Die höheren Programmiersprachen sind weitestgehend von der Hardware-Architektur des Rechners unabhängig.
    (Dies gilt insbesondere für die nach ANSI standardisierten Programmiersprachen, zu denen auch Fortran 90 und Fortran 95 gehören).
  2. Wenn Sie Ihren Fortran 90/95 Code mit einem Compiler übersetzen, wird ein direkt ausführbares Programm erzeugt. Das ausführbare Programm wird auch executable genannt und wurde in der prozessorabhängigen Maschinensprache generiert. Damit sind Executables nur zwischen Rechnern mit gleicher Architektur portierbar. Ihr nach ANSI-Standard erstelltes Fortran-Quelltext-Programm ist jedoch rechnerunabhängig. Sobald auf Ihrem Computer ein Fortran 90-Compiler vorhanden ist, können Sie Ihr Fortran-Programm dort übersetzen (compilieren) und ausführen lassen.

Die äußere Struktur von Fortran-Programmen

Die "free source form" von Fortran 90/95

Ein einfaches Fortran-Programm (nur ein Hauptprogramm) besteht im wesentlichen aus 4 Programmteilen:

  • Programmkopf

  • Vereinbarungs- oder Deklarationsteil

  • eigentlicher Anweisungsteil

  • Programmende

Später werden zu dem Hauptprogramm noch Unterprogramme hinzukommen, die einen vergleichbaren strukturellen Aufbau aufweisen. Die Unterprogramme stehen in der Regel hinter dem Hauptprogramm oder werden als separate Dateien realisiert.

"free source form" bedeutet übersetzt soviel wie "freier Quelltext" und besagt, dass in Fortran 90/95 anders als im Vorgänger FORTRAN 77 das dort notwendige spaltenorientierte Format nicht mehr eingehalten werden muss.

Der Befehlssatz von Fortran 90/95 stellt eine Obermenge der Befehle von FORTRAN 77 dar, so dass mit minimalen Änderungen FORTRAN 77 - Programme vom Fortran 90/95 - Compiler übersetzt werden können.

Die Struktur einer Fortran-Anweisung

Programme bestehen aus einer Folge von Anweisungen, die sowohl in sich als auch im Gesamtkontext betrachtet, den zugehörigen Syntax- und Semantik-Regeln der jeweiligen Programmiersprache genügen müssen. Dies gilt selbstverständlich auch für Fortran 90/95 - Programme.

Man unterscheidet

Nicht-ausführbare Anweisungen

liefern Informationen, die für das korrekte Arbeiten des Programms notwendig sind (z.B. Programmkopf-Deklaration, Variablen-Deklaration, Format-Beschreiber).

Ausführbare Anweisungen

beschreiben die Aktionen, die das Programm durchführt, wenn die entsprechende Programmanweisung abgearbeitet wird (z.B. Durchführung einer Wertzuweisung, Addition, Multiplikation etc.)

Wertzuweisungen

Wertzuweisungen in Fortran sind gemäß der folgenden Grundstrukur möglich
   <Variablenname> =  <Wert, Variable oder 
                          mathematischer Ausdruck>

Eine Zeile eines Fortran 90/95-Programms darf bis zu 132 Zeichen lang sein.

Falls eine Anweisung zu lange ist, um in eine Zeile zu passen, kann man die Anweisung in der Folgezeile fortsetzen, indem man die fortzusetzende Zeile mit dem Zeichen & am Zeilenende markiert.

Wenn man möchte, könnte man zusätzlich zu Beginn der Folgezeile ebenfalls ein & setzen (optional).
Natürlich muss man nicht unbedingt 132 Zeichen in einer Zeile vollschreiben, um sich für die Fortsetzung einer Anweisung in der nächsten Zeile zu entscheiden. Oft erhöht ein Zeilenumbruch die Lesbarkeit des Programms und ist aus diesem Grunde sinnvoll. Prinzipiell hat man also Möglichkeiten der Zeilenfortsetzung, wobei das Zeichen & am Ende der fortzuführenden Zeile immer notwendig und das & zu Anfang der fortgesetzten Anweisung optional ist.
Die Zeile

          output = input1 + input2
soll statt in einer Zeile in 2 Zeilen geschrieben werden. Eine Möglichkeit der Zeilenfortsetzung wäre z.B.
 
           output = input1 & 
                  + input2    
als andere Möglichkeit ginge z.B. auch zu Beginn der Fortsetzungszeile das Fortsetzungszeichen zusätzlich zu wiederholen:
 
           output = input1 &
                  & + input2    
Eine Zeilenfortsetzung darf sich nach dem Standard von Fortran90/95 über bis zu 40 Zeilen erstrecken.

Kommentare werden in Fortran 90/95 durch ein ! (Ausrufezeichen) markiert. Innerhalb einer Zeile wird alles rechts vom Ausrufezeichen ignoriert. Deshalb können in einer Zeile hinter Anweisungen noch mit Ausrufezeichen eingeleitete Kommentare stehen.
Fortran 90/95-Programme können auch beliebig viele Leerzeilen aufweisen. Diese werden vom Compiler ignoriert.

Die meisten Anweisungen können mit einer Anweisungsnummer zwischen 1 und 99999 versehen werden. Dabei handelt es sich um eine Markierungen, die für den gezielten Zugriffen auf die Anweisung mit dieser Markierung vorgesehen ist.

 
	program hello
	   90000 write(*,*) 'Hello'
	   1         write(*,*) 'World !'
	end program hello 
Diese Anweisungsnummern markieren nicht die Reihenfolge, in der die Anweisungen abgearbeitet werden, sondern stellen eine Art "Markierung" innerhalb des Programmcodes dar (engl. statement labels ). Dieses Beispielprogramm wird ungeachtet der gewählten Zahlenwerte von oben nach unten abgearbeitet. Und ungeachtet dessen, dass 90000 sehr viel größer als 1 ist, erfolgt die Bildschirmausgabe weiterhin in der Reihenfolge 'Hello' gefolgt von 'World !'. Der englische Ausdruck statement label macht sehr viel klarer, dass es sich bei diesen Zahlen weniger um eine Nummerierung sondern vielmehr um eine "Markierung" handelt.

Ihre Programme in Fortran 90/95 sollten stets in der "free source form" geschrieben werden und nicht mehr nach dem alten FORTRAN 77 - Standard, der nach leichten Modifikationen durchaus noch von einem Fortran 90/95 - Compiler verarbeitet werden kann. Allerdings ist damit zu rechnen, dass bei einer der nächsten Standardisierungen von Fortran die Abwärtskompatibilität zur "fixed source form" von FORTRAN 77 entfallen wird, da diese bei der Standardisierung von Fortran 95 als obsolescent (engl. für "allmählich außer Gebrauch kommend") bezeichnet wurde.

Die "fixed source form" von FORTRAN 77

Anders als in Fortran 90/95 gilt bei seinem Vorgänger FORTRAN 77 noch ein aus der Lochkarten-Ära stammendes festes Spaltenformat. Schematischer Aufbau eines FORTRAN 77 - Programms

Zwei einfache Beispiele in Fortran 90/95 und in FORTRAN 77

Es sollen zwei ganze Zahlen multipliziert und der Wert des Produkts ausgegeben werden.

Der Fortran 90/95 -Zeichensatz und der Zeichensatz von FORTRAN 77

Wie jede natürliche Sprache hat auch jede Computersprache einen eigenen speziellen Zeichensatz. Nur Zeichen aus diesem Zeichensatz können in Zusammenhang mit der Sprache verwendet werden.

Der Fortran 90/95 - Zeichensatz

Anzahl

Art des Symbols Werte

26

Großbuchstaben A-Z

26

Kleinbuchstaben a-z

10

Ziffern 0-9

1

Unterstrich _

5

Arithmetische Symbole + - * / **

17

verschiedene weitere Symbole ( ) . = , ' $ : sowie das Leerzeichen (engl. blank genannt)
! " % & ; < > ?

Die in rot dargestellten Zeichen waren in FORTRAN 77 noch nicht enthalten.

Die Gruppe der Buchstaben zusammen mit den Ziffern werden auch als die alphanumerischen Zeichen bezeichnet.

Obwohl anfangs nur Großbuchstaben im FORTRAN 77 - Zeichensatz vorgesehen waren, wurden im Laufe der Jahre die Compiler so erweitert, dass Kleinbuchstaben als gleichwertiger Ersatz für einen Großbuchstaben akzeptiert wurden.

Wichtig: Ein Fortran-Compiler unterscheidet nicht zwischen Groß- und Kleinschreibung!
Würden Sie in Ihrem Programm als Variablennamen wert und Wert verwenden, so würde der Fortran-Compiler anders als ein C-Compiler davon ausgehen, daß es sich um die gleiche Variable handelt.

Aus den zulässigen Zeichen sind die

Basis-Elemente von Fortran (Syntax)

zusammengesetzt

Namen in Fortran 90/95 und Namen in FORTRAN 77

Um z.B. Variablen und Konstanten mit einer Bezeichnung versehen zu können, sieht Fortran 90/95 vor, dass diese einen Namen erhalten.

Ein Name darf in Fortran 90/95 bis zu 31 Zeichen lang sein. Der Name muss mit einem Buchstaben beginnen. Für die auf das erste Zeichen folgenden Zeichen dürfen alle alphanumerischen Zeichen sowie Unterstriche verwendet werden. Groß- und Kleinschreibung kann eingesetzt werden, bleibt aber vom Compiler unberücksichtigt.

Eine Anmerkung zu FORTRAN 77: Hier sind Namen bis zu einer Länge von 6 Zeichen zulässig. Auch in der Vorgägerversion FORTRAN77 muss der Name mit einem Buchstaben beginnen. An den bis zu 5 folgenden Stellen dürfen alphanumerische Zeichen folgen. Der Unterstrich kann nicht verwendet werden. In FORTRAN 77 können auch Namen verwendet werden, die aus mehr als 6 Zeichen bestehen, jedoch werden vom FORTRAN77-Compiler dem Standard gemäszlig; nur die Namen bis einschließlich des 6. Zeichens voneinander unterschieden. Das heißt: ein FORTRAN 77 - Compiler geht aufgrund der verwendeten Namensregelung davon aus, dass es sich bei RADIUS1 und RADIUS2 um ein und diesselbe Variable RADIUS handeln würde.

Hinweis: Da die Vergabe von Namen unter Fortran 90/95 sehr viel mehr Gestaltungsmöglichkeiten bietet, sollten Sie dieses Angebot nutzen und die von Ihnen vergebenen Namen so wählen, dass sie

Der allgemeine Aufbau eines Fortran 90/95 - Programms

Jedes Fortran - Programm besteht aus einer Mischung ausführbarer und nicht-ausführbarer Anweisungen, die in einer bestimmten Reihenfolge auftreten müssen. Das Programm selbst (und wie wir später sehen werden, auch jede Unterprogrammeinheit) gliedert sich in 3 Teile
  1. Der Deklarationsteil
    besteht aus einer Gruppe nichtausführbarer Anweisungen am Anfang eines jeden Fortran 90-Programms. Zunächst wird der Name des Programms definiert, dann werden die in den Programmen verwendeten Konstanten und Variablen (mit dem zugehörigen Datentyp) deklariert.
  2. Der Anweisungsteil
    besteht aus einer oder mehreren Anweisungen, die die Aktionen beschreiben, die beim Abarbeiten des Programms ausgeführt werden sollen.
  3. Das Programmende
    besteht aus einer (oder mehreren) Anweisungen, die die Ausführung des Programms unterbricht und markiert, dass an dieser Stelle der entsprechende Programmteil abgeschlossen ist.

Der Deklarationsteil

Ein Fortran 90/95 - Programm beginnt mit der nicht-ausführbaren Anweisung

program <Programmname>

Statt <Programmname> ist der von Ihnen gewählte Programmname einzusetzen, der selbstverständlich der Fortran 90/95 -
Namenssyntax genügen muss. Zum Deklarationsteil gehören auch die

Konstanten- und Variablen-Vereinbarungen

Eine Konstante ist ein Datenobjekt, welches vor der Programmausführung definiert wird. Während der Abarbeitung des Programms bleibt der Wert einer Konstante unverändert. Die Zuweisung eines Wertes zu einer Konstanten gehört deshalb in den Deklarationsteil. Der Fortran-Compiler erzeugt eine Maschinensprachanweisung, durch die bei der Programmabarbeitung des Executables der Wert der Konstante in einen bestimmten Speicherplatz des Hauptspeichers geschrieben wird. Bei der Abarbeitung des Executables wird im folgenden bei einer Konstante der dort abgespeicherte Wert, sobald der Name der Konstante in dem Programm wieder auftritt, aus dem Speicherplatz der Konstanten ausgelesen.

Im Gegensatz zu einer Konstanten ist eine Fortran-Variable ein Datenobjekt, dessen Wert sich bei der Ausführung des Programms verändern kann. Wenn ein Fortran-Compiler im Deklarationsteil einer Variablen begegnet, reserviert er an einer bestimmten Stelle im Speicher einen Speicherplatz in der für den angegebenen Datentyp notwendigen Größe als Speicherplatz für die möglichen Werte dieser Variablen. Immer wenn der Compiler auf den Namen dieser Variablen trifft, erzeugt er eine Referenzierung auf diesen Speicherplatz. Bei der Ausführung des compilierten Programms (des Executables) wird je nach vorliegender Anweisung der Inhalt dieses Speicherplatzes entweder gelesen oder es wird dort ein aktualisierter Wert abgelegt.

Jede Variable und jede Konstante muss innerhalb einer Programmeinheit einen eindeutigen Namen erhalten, z.B. time, distance, z123456789, ergebnis_der_multiplikation. Die Namen der Variablen müssen der Fortran 90/95 - Namenssyntax-Regel genügen. Nicht zulässig ist es, Leerzeichen im Namen zu schreiben (verwenden Sie statt dessen den Unterstrich) oder den Programmnamen als Variablennamen verwenden zu wollen. Dies würde dazu führen, dass der Compiler beim Übersetzen Ihres Programms mit einer Fehlermeldung abbricht.

Hinweis: Gute Programmierpraxis ist es, sich am Anfang des Programms ein Verzeichnis der im Programm auftretenden Variablen und Konstanten nach Namen, Datentyp und Bedeutung innerhalb des Programms zu erstellen.

6. Die in Fortran 90/95 intrinsisch enthaltenen Datentypen

Datentyp Erläuterung Beispiele von Werten dieses Datentyps
integer (ganze Zahlen) 10 -2 1 +1
real (reelle Zahlen) 12.3 1.23 1.23e-1 -1.E-6 -.98
complex (komplexe Zahlen) (1.0,2.e-3)
logical (logische Werte) .TRUE. .FALSE.
character (Zeichenketten) 'Name' "Zahl" 'Hälfte'

Neben diesen intrinsischen Datentypen gibt es noch eine Reihe abgeleiteter Datentypen. Diese werden in einer der folgenden Vorlesungen behandelt.

Die Bedeutung von implicit none

Historisch bedingt enthält Fortran 90 noch die Möglichkeit zur impliziten Datentypvereinbarung der Vorgängerversionen.

Bei der impliziten Datentypvereinbarung wird vom Compiler anhand des ersten Buchstabens eines Variablen- oder Konstantennamens angenommen, dass der zugehörige Datentyp real oder integer sei.

Und zwar gilt bei der impliziten Datentypvereinbarung die Regel:

Beginnt der Name mit i, j, k, l, m oder n (oder dementsprechend mit I, J, K, L, M oder N), so wird bei der impliziten Datentypvereinbarung angenommen, dass es sich um eine Variable vom Datentyp integer handelt. Falls ein anderer Anfangsbuchstabe vorliegt, so wird vom Compiler angenommen, dass es sich um eine Variable des Datentyps real handelt.

Dringende Empfehlung zur Vermeidung von ungewollten Programmierfehlern: Variablen stets explizit vereinbaren (d.h. jede Variable im Deklarationsteil zusammen mit dem dazugehörigen Datentyp explizit auflisten) und die implizite Typvereinbarungregel von vorneherein ausschalten durch

         implicit none 
unmittelbar hinter der program-Anweisung.

Konstanten und Variablen von Datentyp integer

Konstanten und Variablen vom Datentyp integer können Werte aus einen Teilbereich der ganzen Zahlen annehmen. In der Regel stehen für den Datentyp integer 4-Byte Speicherplatz zur Verfügung. Da im Rechner Zahlen im Binär- oder Dual-System codiert werden, stehen somit insgesamt 4 Byte = 4 mal 8 Bit = 32 Bit zur Verfügung. Dies schränkt den Bereich der ganzen Zahlen bei einer 4-Byte-integer-Darstellung ein auf ganze Zahlen im Wertebereich von -2**31+1 bis 2**31-1 = 2147483647. Abhängig von der Hardware-Architektur Ihres Rechners und von dem eingesetzten Compiler können Ihnen auch mehr als 4-Byte (z.B. 8-Byte intrinsisch für den Datentyp integer zur Verfügung stehen. Durch die Verwendung eines abgeleiteten Datentyps können Sie den Darstellungsbereich des Datentyps integer in der Regel auf das Doppelte (8 Byte) ausdehnen.

Beispiele zum Datentyp integer: integer_beispiele.f90

Konstanten und Variablen von Datentyp real

Auch hier sind in der Regel 4-Byte Speicherplatz pro Variable/Konstante vorgesehen. Von den 32 Bit stehen normalerweise 24 Bit für die Darstellung der Mantisse und 8 Bit für den Exponenten zur Verfügung. Auch aufgrund der hardwareseitigen Vorgaben ist der darstellbare Bereich der reellen Zahlen eingeschränkt. Die größte darstellbare reelle Zahl wäre in etwa 3.37*10**38, die kleinste reelle positive Zahl 8.43*10**-37. Bei den negativen reellen Zahlen sind die Schranken -3.37*10**-38 und -8.43*10**37. Wird versucht, einer Variablen oder einer Konstanten innerhalb des Programms einen Wert außerhalb dieses Darstellungsbereichs zuzuweisen, erhält man einen "overflow" oder "underflow" error.

Zahlenwerte von Variablen und Konstanten des Datentyps real kann man in Fortran 90/95 in der Gleitpunkt- oder in der wissenschaftlichen Exponentendarstellung schreiben. Damit haben Zahlen das Format a.b, wobei a für die Zahl vor dem "Komma" und b für die Zahl nach dem "Komma" steht. Beispiele:

1.2345 0.999 123.12 -450.3273 23.0 23. -0.99 -.99
Grundsätzlich schreibt man in Fortran statt dem im Deutschen verwendeten Komma, in Anlehnung an die englische Zahlendarstellung auch in Fortran einen Punkt um Vor- und Nachkommastellen zu trennen. Ein negatives Vorzeichen muss der Zahl direkt vorangestellt werden. Mit einem positiven Vorzeichen kann man dies tun oder es einfach weglassen. Reine Nullen als Nachkommastellen können ganz weggelassen werden. Eine führende Null als einzige Vorkommastelle kann ebenfalls weggelassen werden.

Die von der Wissenschaft und Technik bekannte Darstellung einer Zahl mit Vor- und Nachkommastellen zusammen mit einem Exponenten zur Basis 10 wird auch in Fortran verwendet. So stellt z.B. mancher Taschenrechner eine Milliarde als 1.E+9. Der Ausdruck 'E+9' steht für den Exponenten zur Basis 10 und besagt hier nichts anderes, als dass die 1 noch mit 10**9 = 1000000000 zu multiplizieren wäre. Das Zahlenformat mit dem Exponenten zur Basis 10 aus der wissenschaftlichen Darstellung ist natärlich auch in Fortran "eingebaut". Reelle Zahlen innerhalb des Darstellungsbereichs lassen sich schreiben als a.bEc oder a.bE-c oder -a.bEc oder a.bE-c. Wahlweise ließe sich wieder ein Pluszeichen zusätzlich aufführen und/oder führende Nullen oder folgende Nullen in den Nachkommastellen vernachlässigen.

    12.3 1.23 1.23e-1 -1.E-6 -.98  +1.23e-1 5.e+1
Siehe auch: real_beispiele.f90

Konstanten und Variablen vom Typ character
Der character-Datentyp besteht aus einer Kette (Aneinanderreihung) von Zeichen, die in ' (einfache Anfährungszeichen) oder " doppelte Anführungszeichen eingeschlossen sind. In FORTRAN 77 sind nur die einfachen Anführungszeichen bei der Definition von Zeichenketten (engl. strings) als Begrenzer möglich. Zeichen, die innerhalb einer Zeichenkette stehen, werden in diesem Kontext betrachtet, z.B. wird ein in der Zeichenkette eingeschlossenes Ausrufzeichen ! nicht als Einleitungszeichen eines Kommentars behandelt. Innerhalb der Zeichenkette dürfen auch Zeichen ausserhalb des Fortran-Zeichensatzes verwendet werden, z.B. deutsche Umlaute etc.

Die minimale Länge einer Zeichenkette ist 1 und die maximale Länge der Zeichenkette ist compilerabhängig. Beispiele für zulässige Zeichenketten:

  'Radius = '
  "Radius = "
  'This is a test!'
  ' '
  '{ }'
  'Klöße und Bier'
  'Peter''s Backstube'
  "Peter's Backstube" 
  'Er wunderte sich: "Was ist denn das?"'
Falsche, nicht zulässige Zeichenketten wären beispielsweise This is a test! (die Begrenzer der Zeichenkette wurden vergessen), 'This is a test!" (inhomogene Begrenzer der Zeichenkette).
Siehe auch: character_beispiele.f90

Deklaration von Zeichenketten

Beispiel 1:

	character :: buchstabe
Hier wurde eine Zeichenkette mit der Länge 1 deklariert.

Beispiel 2:

	character(15) :: Zeichenkette_mit_15_Zeichen
Damit wird eine Zeichenkette mit 15 Zeichen deklariert.

Beispiel 3 (die ausführliche Deklaration einer Zeichenkette):

	character(len=15) :: Zeichenkette_mit_15_Zeichen
Bei der ausführlichen Version steht explizit len als Abkürzung des englischen Wortes length für die Länge der Zeichenkette.

Vorgriff: Bei Zeichenketten ist es unbedingt empfehlenswert, unter Angabe des Formatbeschreibers A in der read-Anweisung einzulesen, weil so gewährleistet werden kann, dass auch ohne Angabe der Zeichenkettenbegrenzer ' bzw." Zeichenketten mit eingebetteten Leerzeichen (z.B. eine Zeichenkette aus 2 Worten) vollständig gelesen werden.

Nachdem z.B. eine Zeichenkette der Länge 40 deklariert wurde

    character(len=40) :: zeichenkette   
kann mit
    read(*,'(A)') zeichenkette 
in die Zeichenkette z.B. Guten Morgen ohne Angabe der Zeichenkettenbegrenzer ' "eingelesen werden. Würde listengesteuert eingelesen werden
    read(*,*) zeichenkette 
müsste zum Einlesen der vollständigen Zeichenkette der Anwender 'Guten Morgen' bzw. "Guten Morgen" eingeben. Denn bei der Eingabe von Guten Morgen ohne die Zeichenkettenbegrenzer würde nur Guten als Einlesewert für die Zeichenkette übernommen werden.

Beispielprogramm zum Selbst-Ausprobieren: character_einlesen.f90

Konstanten und Variablen vom Datentyp logical

Der Datentyp logical kennt wie die Grundmenge der (binären) Booleschen Algebra nur 2 Werte:
.TRUE. für logisch wahr und .FALSE. für logisch falsch. Eine Variable vom Typ logical kann Werte vom Datentyp logical annehmen.
Siehe auch: logical_beispiele.f90

Deklaration benannter Konstanten

Hinweis:Am besten oberhalb des Blocks mit den Variablendeklarationen hinter der Zeile mit der implicit none - Anweisung durchführen!

Benannte Konstanten werden durch die Angabe des Datentyps, der um das parameter-Attribut ergänzt wurde, gefolgt von :: und der Angabe des Namens gefolgt von einer Wertzuweisung deklariert. Beispiele:

   real,parameter :: pi = 3.141593
   character(len=13), parameter :: fehlerstring = 'unknown error'
Die Länge des Strings braucht bei der Deklaration einer benannten Zeichenketten-Konstante nicht unbedingt berechnet zu werden. Dies kann auch der Compiler übernehmen. Nur ist dann an Stelle der Längenangabe ein * einzufügen
   character(*), parameter :: fehlerstring = 'unknown error'

Hinweis: Die Deklaration benannter Konstanten sollte in einem Programm vor der Deklaration der Variablen erfolgen. Bereits vereinbarte Konstanten können bei Bedarf bei der Variablendeklaration wieder eingesetzt werden. Zum Beispiel kann man die Länge einer Zeichenkette als Konstante vereinbaren und diese dann zur Längenangabe einer Zeichenkette verwenden.

    integer, parameter           :: zeilenlaenge = 80
    character(len=zeilenlaenge)  :: erste_zeile, zweite_zeile, dritte_zeile

Wertzuweisungen und arithmetische Berechnungen

Eine Wertzuweisung hat die Form

      < Variablenname > = < Ausdruck >

Bei einer Wertzuweisung wird zunächst der Wert auf der rechten Seite des =-Zeichens berechnet und dann der Variablen auf der linken Seite zugewiesen. Damit ist auch klar, dass bei einer Wertzuweisung auf der linken Seite nur der Name einer Variablen stehen kann - ( und weder der Name einer Konstanten noch ein Ausdruck).

Bei dem '='-Zeichen handelt es sich im mathematischen Sinne keineswegs um ein Gleichheitszeichen, sondern um einen Zuweisungsoperator. Um z.B. den Wert einer integer-Variablen um 1 zu erhöhen, schreibt man

	i = i + 1
was im mathematischen Sinne Unsinn wäre, im Kontext von Fortran jedoch die richtige Form einer Wertzuweisung darstellt.

Auf der rechten Seite einer Wertzuweisung darf jede gültige Kombination von Konstanten, Variablen, Werten, Klammern, arithmetischen und logischen Operatoren stehen.

Die arithmetischen Operatoren in Fortran sind
+ Addition
- Subtraktion
* Multiplikation
/ Division
** Exponentiation
Diese Operatoren kommen normalerweise als binäre Operatoren vor und verknüpfen
      < Variable1 oder Konstante1 > < binärer Operator > < Variable1 oder Konstante1 > z.B. a + b, a - b, a * b, a / b, a ** b. '+' und '-' können auch als unitäre Operatoren auftreten z.B. +a , -b.

Es gelten folgende

Regeln für die arithmetischen Operatoren

  1. Zwei Operatoren dürfen nicht unmittelbar aufeinander folgen:
    unzulässig ist z.B. a*-b richtig ist: a*(-b)
  2. Der Multiplikationsoperator darf anders als in der Mathematik nicht weggelassen werden:
    unzulässig ist z.B. a(x+y) richtig ist: a*(x+y)
  3. Klammern werden in der aus der Mathematik bekannten Reihenfolge ausgewertet (von innen nach außen). Z.B.
    2**((7*2)/5) = 2**(14/5) = 2**(2) = 2**2 = 4

Hierarchie der Operatoren

Hierarchie der Operatoren

  1. Klammern in mathematischer Reihenfolge (s.o.)

  2. Exponentiation, z.B. ist die Formel für den freien Fall durchaus richtig implementiert als
    Ort = 0.5 * Erdbeschleunigung * Zeit ** 2

  3. Bei gemischten Ausdrücken mit Mulitplikation bzw. Division und Addition bzw. Subtraktion gilt die Regel "Punkt" vor "Strich"

  4. Arithmetische Ausdrücke auf gleicher Hierarchiestufe (z.B. nur Multiplikationen und Divisionen im arith. Ausdruck) werden von "links nach rechts" ausgewertet
    b / c * e / f = ( ( b / c ) *e ) / f
    Für Ausdrücke nur mit Additionen und Subtraktionen gilt ebenso die Auswerteregel "von links nach rechts".

    Ausnahme: Auf der reinen Hierarchiestufe der Exponentiationen wird von rechts nach links ausgewertet.

Integer - Arithmetik

Werden in einem arithmetischen Ausdruck zwei Werte von Datentyp integer mit einem Operator miteinander verknüpft, so ist das Resultat ebenfalls von Datentyp integer.
Achtung: Bei der Division ganzer Zahlen wird dabei nur der ganzzahlige Anteil als Ergebnis verwendet. So ergibt 3/4 als Resultat 0, 4/4 liefert 1 und 7/4 hat als Ergebnis ebenfalls 1.
Siehe auch:
integer_arith.f90 und als Ausgabe auf der btrcx1.cip.uni-bayreuth.de integer_arith.erg.

Wird einer der beteiligten Zahlen in der Form des Datentyps real angegeben, so wird vor der Berechnung der Wert von Datentyp integer nach real konvertiert, so dass das Ergebnis der Operation als Datentyp real (richtig berechnet) vorliegt. So ergibt sowohl 3./4 als auch 3/4. als Resultat 0.7500000.

Siehe auch: integer_arith_mod.f90 und als Ausgabe auf der btrcx1.cip.uni-bayreuth.de integer_arith_mod.erg.

Dem beobachten Verhalten liegen die

Regeln für die interne Datentyp-Konversion

zugrunde. Werden zwei Variablen, Konstanten oder Werte mit gleichen oder unterschiedlichen Datentypen mit einem der Operatoren +, -, * oder / verknüpft, dann ergibt sich der Datentyp des resultierenden Ausdrucks aus der folgenden Tabelle:

a <op> b

integer :: b real :: b
integer :: a integer real
real :: a real real

<op> = +, -, *, /

Beispiele:

arithmetischer Ausdruck
mit gemischten Datentypen
 Ergebnis
1 + 1 / 4  1
1. + 1 / 4  1.000000
1 + 1. / 4  1.250000

Ein weiteres Beispiel: conv_demo.f90

  program conv_demo
     implicit none
     integer :: ergebnis
     ergebnis = 1.25 + 9 / 4        
     write(*,*) 'ergebnis (Datentyp integer) = 1.25 +  9 / 4 = ', ergebnis
     write(*,*) 'Zum Vergleich :               1.25 +  9 / 4 = ', 1.25 + 9 / 4 
  end program conv_demo
Bildschirmausgabe (nach dem Compilieren und dem Aufrufen des Executables): conv_demo.erg
 ergebnis (Datentyp integer) = 1.25 +  9 / 4 =            3
 Zum Vergleich :               1.25 +  9 / 4 =    3.250000   

Bei der Wertzuweisung

     ergebnis = 1.25 + 9 / 4        
wird aufgrund der Operator-Hierarchie ("Punkt vor Strich") zunächst die Division 9/4 (zweier Zahlen von Datentyp integer) ausgeführt. Wegen der Integer-Arithmetik-Regeln hat dieser Ausdruck den Wert 2. Im nächsten Schritt wird die real-Zahl  1.25 zu der 2 hinzugezählt. Dabei wird vorher die (integer) 2 aufgrund der Datentyp-Konversions-Regeln in den Datentyp real des ersten Summanden (real) 1.25 ) gewandelt. Das Ergebnis der Addition ist von Datentyp real und hat den Wert 3.25. Sie stellt den Wert dar, die der integer-Variablen ergebnis zugewiesen werden soll. Die Variable ergebnis hat den Datentyp integer. Deshalb wird (real) 3.25 nochmals in die integer-Zahl 3 gewandelt, bevor die Wertzuweisung durchgeführt und die 3 am Speicherplatz der integer-Variablen ergebnis abgespeichert wird.

Merke:

Beim Programmieren sollte man darauf achten, dass man Zahlen ohne Nachkommastellen, die in Ausdrücken mit dem Datentyp real verwendet werden, stets im real-Format als Zahl mit dem .oder noch besser wegen der besseren Übersichtlichkeit als Zahl gefolgt von .0 eingibt (z.B. 2. oder 2.0 statt 2), um die in der integer-Arithmetik versteckten Gefahren zu umgehen.

Explizite Datentyp-Umwandlungen

Will man einen integer-Wert explizit in einen Wert vom Datentyp real umwandeln oder umgekehrt, so kann man dies tun indem man den Wert oder die Variable in int( ) bzw. real( ) einschließt.


Ausgangs-Datentypen

Umwandlungsfunktion
neuer Datentyp
integer real( ) real
real int( ) integer

Exponentiationen

Keine Regel ohne Ausnahme. Bei einem ganzzahligen (integer) Exponenten sollte man auch bei einer Basis vom Datentyp real den Exponenten als integer d.h. als ganze Zahl schreiben. Eine Wertzuweisung der Form

    p = x**n 
mit x und p vom Datentyp real und n vom Datentyp integer (n > 0) wird bei der Auswertung die Exponentiation in eine Multiplikation verwandelt, d.h. x n-mal mit sich selbst mulitpliziert. Dies geht zum einen schneller, zum anderen erhält man exaktere Resultate. Hier findet auch keine implizite Datentypkonversion statt, weil stets mit dem Datentyp real gearbeitet wird.

Eine Wertzuweisung der Form

    p = x**y 
wobei sowohl x und p als auch y vom Datentyp real sind, wird intern anders ausgewertet. Dies wäre der Fall, wenn z.B. y den Wert 2.5 hätte. Der arithmetische Ausdruck auf der rechten Seite wird ausgewertet, indem die Umrechnungsformel für den Logarithmus verwendet wird. Statt x**y direkt zu berechnen, wird dieser Ausdruck in exp(y*log(x)) umgewandelt und dieser Ausdruck ausgewertet. exp lautet der Name der in Fortran intrinsisch enthaltene Berechnungsroutine für die Exponentialfunktion, log ist der Funktionsname für den natürlichen Logarithmus, den man in der Mathematik gemeinhin als ln schreibt.

Da der Logarithmus nur für positive Zahlen definiert ist, können in Fortran somit auch keine nichtganzzahligen (reellen) Exponenten für negative Basen verwendet werden.

Beispiel: exp_error.f90

  program exp_error
   implicit none
   real    :: x, y
       x = -8.0 
       y = 1.0/3.0
       write(*,*)
       write(*,*) 'x = ', x, '; y = ', y
       write(*,*) 'x**y = ', x**y
  end program exp_error
Bei der Programmausführung erhält man auf der btrcx1.cip.uni-bayreuth.de einen sogenannten runtime error, d.h. einen Fehler, der beim Abarbeiten des Executables auftritt.
 x =   -8.000000     ; y =   0.3333333    
forrtl: error (65): floating invalid
   0: __FINI_00_remove_gp_range [0x3ff81a6c374]
   1: __FINI_00_remove_gp_range [0x3ff81a740d8]
   2: __FINI_00_remove_gp_range [0x3ff800d0b9c]
   3: __FINI_00_remove_gp_range [0x3ff802199f8]
   4: __FINI_00_remove_gp_range [0x3ff80218f7c]
   5: __FINI_00_remove_gp_range [0x3ff80243b9c]
   6: exp_error_ [exp_error.f90: 10, 0x120001d50]
   7: main [for_main.c: 203, 0x120001b9c]
   8: __start [0x120001b18]
Abort

Merkregel: Zu einer negativen Basis sollten in einem FORTRAN-Programm keine reellen Exponenten stehen. Sie müssten hier problemangepasste Lösungen implementieren, die im speziellen Fall diese Problematik umgehen.

Allerdings gibt es hier wiederum Situationen, in denen spezielle Compiler diese ungünstige Situation durch Wegoptimierung umgehen, falls zu einer negativen Basis der reelle Exponent einer ganzen Zahl entspricht (z.B. (-8.0)**2.0; probieren Sie hierzu, wie sich Ihr Compiler bei exponentiation.f90 ) verhält.

Wertzuweisungen und Ausdrücke vom Datentyp logical

Eine "logische" Wertzuweisung hat die Form

      < logische Variable > = < logischer Ausdruck >

Unter einem logischen Ausdruck versteht man in diesem Zusammenhang einen Ausdruck, der zum Datentyp logical gehört. Der logische Ausdruck kann sich aus jeder zulässigen Kombination logischer Konstante, logischer Variabler oder logischer Werte zusammensetzen.
Ein logischer Operator ist ein Operator, der auf numerische, character oder logische Daten angewandt wird und als Ergebnis einen logischen Wert hat.

Es gibt 2 Arten logischer Operatoren:

  1. Vergleichsoperatoren
  2. Verknüpfungsoperatoren

Vergleichsoperatoren

stehen zwischen zwei arithmetischen oder Zeichenausdrücken oder Werten und ergeben als Resultat einen logischen Ausdruck. Der Wert des resultierenden Ausdrucks ist entweder wahr (.TRUE.) oder falsch (.FALSE.).

Fortran 90/95 FORTRAN 77 Bedeutung des
Vergleichsoperators

==

.EQ.

gleich

/=

.NE.

ungleich

>

.GT.

größer als

>=

.GE.

größer oder gleich

<

.LT.

kleiner als

<=

.LE.

kleiner oder gleich

Beispiele:

logischer Vergleich Ergebnis

3 < 4

.TRUE.

3 <= 4

.TRUE.

3 == 4

.FALSE.

3 > 4

.FALSE.

4 <= 4

.TRUE.

3 /= 4

.TRUE.

'A' < 'B'

.TRUE.

Hierarchie der logischen Operatoren

Der logische Ausdruck
  7 + 3  < 2 + 11
wird aufgrund der in Fortran 90/95 implementierten Operatorhierarchie in der Form
  ( 7 + 3 )  < ( 2 + 11 )
ausgewertet.

Der logische Vergleich

  4 == 4.
ist möglich und ergibt .TRUE.. Hier wird die integer-Zahl in einen Wert vom Datentyp real umgewandelt und dann wird verglichen. Der Versuch
  4 <= 'A' 
führt jedoch bei den meisten Compilern zu einem Abbruch des Übersetzungs-Vorgangs mit einem compiler error.

Hierarchie der Operatoren

Logische Verknüpfungsoperatoren

Logische Ausdrücke lassen sich mit den logischen Verknüpfungsoperatoren miteinander verbinden. Die binären Operatoren sind

Verknüpfungsoperator

Bedeutung

.AND.

logisches Und

.OR.

logisches Oder

.EQV.

wahr, wenn beide Ausdrücke denselben logischen Wert haben

.NEQV.

wahr, wenn beide Ausdrücke einen unterschiedlichen logischen Wert haben

Wertetabelle für die logischen Verknüpfungsoperatoren

l1 l2 l1 .AND. l2 l1 .OR. l2 l1 .EQV. l2 l1 .NEQV. l2

.FALSE.

.FALSE.

.FALSE.

.FALSE.

.TRUE.

.FALSE.

.FALSE.

.TRUE.

.FALSE.

.TRUE.

.FALSE.

.TRUE.

.TRUE.

.FALSE.

.FALSE.

.TRUE.

.FALSE.

.TRUE.

.TRUE.

.TRUE.

.TRUE.

.TRUE.

.TRUE.

.FALSE.

Des weiteren gibt es noch einen unitären Operator, der logischen Ausdrücken, Variablen oder Werten vorangestellt werden kann

unitärer logischer Operator

Bedeutung

.NOT.

Negation

Wertetabelle für den Negations-Operator

l1 .NOT. l1

.FALSE.

.TRUE.

.TRUE.

.FALSE.

Auswerteregeln für Operatoren

Gemischte Ausdrücke werden nach den folgenden Regeln ausgewertet.

  1. Die arithmetischen Operatoren werden nach den bereits bekannten hierarchischen Regeln (wie oben dargestellt) ausgewertet
  2. Dann folgen die Ausdrücke mit den Vergleichsoperatoren ( ==, /=, >, >=, <, <= ) von links nach rechts
  3. Daraufhin folgt in der Auswertehierarchie der Negationsoperator .NOT. (von links nach rechts), gefolgt von .AND., danach von .OR. (von links nach rechts) und von .EQV. und .NEQV. auf gleicher Hierarchiestufe (auch hier von links nach rechts).

Zeichenketten-Verarbeitung

Zeichenketten (engl. strings) entstehen durch die Aneinanderreihung mehrerer Zeichen einer Zeichen des Datentyps character. Zum Beispiel kann eine Zeichenkette mit 10 Zeichen Länge durch
   character(len=10) :: ausdruck
deklariert werden (Fortran 90/95). Zulässig wäre auch, dies in der Form
   character(10) :: ausdruck
zu tun (Fortran 90/95 und Fortran 77). Veraltet und nicht mehr verwendet werden sollte die (alte) Fortran 77 - Version
   character*10 ausdruck
Variablen vom Datentyp einer Zeichenkette lassen sich genauso wie Variablen der anderen Datentypen durch eine Wertzuweisung mit Werten belegen, z.B.
   ausdruck = 'diesunddas'
Nochmals zur Wiederholung: character-Daten müssen in einfache (Fortran 77 und Fortran 90/95) oder doppelte Anführungszeichen (Fortran 90/95) eingeschlossen werden.

Die Länge einer Zeichenkette lässt sich mit

  len(ausdruck) 
bestimmen. Durch die Angabe zweier Indexgrenzen lassen sich Unterzeichenketten innerhalb einer Zeichenkette auswählen, z.B.
  ausdruck(5:7)
ergibt und als Unterzeichenkette.

Will man das erste Auftreten eines bestimmten Zeichens finden, gibt es hierzu

  index(<Name eines Ausdrucks>,character-Zeichen)
Diese Funktion kann man zusammen mit der Möglichkeit, Unterzeichenketten durch die Angabe zweier Indexgrenzen zu extrahieren, kann man auch nutzen, um z.B. in einer Zeichenkette einzelne Worte zu separieren (siehe Beispielprogramm).

Achtung: Wenn Sie Zeichenketten, die Leerstellen enthalten können, einlesen wollen, sollten Sie statt listengesteuert (read(*,*)) formatiert einlesen, z.B.

read(*,'(A)') <Variablenname einer Zeichenkettenvariable>

Will man bei einer Zeichenkette evtl. sich am Ende befindliche Nullstellen nicht mit ausgegeben haben, so kam man

  trim(ausdruck) 
einsetzen.

Das folgende Beispiel illustriert das unterschiedliche Verhalten der beiden Einleseformate (formatiert, unformatiert) und einiger der Befehle zur Zeichenkettenverarbeitung.

Programm: strings.f90

! Beispielprogramm zur Zeichenkettenverarbeitung
! insbesondere zum unterschiedlichem Verhalten von 
! listengesteuertem und formatgesteuertem Einlesen von Zeichenketten

program strings

   implicit none
   character(len=20), parameter :: messlatte = "....5....|....5....|"
   character(len=20)            :: zeichenkette1, zeichenkette2

   write(*,*) 
   write(*,*) 'Bitte geben Sie einen max. 20 Zeichen langen Text ein!'
   write(*,*) 'listengesteuertes Einlesen mit read(*,*)'
   read(*,*)   zeichenkette1
   write(*,*) 
   write(*,*) 'Ausgabe der Zeichenkette nach Einlesen mit read(*,*)' 
   write(*,*)  zeichenkette1
   write(*,*)  messlatte
   write(*,*) 
   write(*,*) 'Bitte geben Sie erneut einen max. 20 Zeichen langen Text ein!'
   write(*,*) 'formatiertes Einlesen mit read(*,''(A)'')'
   read(*,'(A)') zeichenkette2
   write(*,*) 
   write(*,*) "Ausgabe der Zeichenkette nach Einlesen mit read(*,'(A)')"
   write(*,*)  zeichenkette2
   write(*,*)  messlatte

   write(*,*)
   write(*,*) 'weitere Verarbeitung von Zeichenketten:'
   write(*,*)
   write(*,*) 'len(zeichenkette1): ', len(zeichenkette1)
   write(*,*) 'len(zeichenkette2): ', len(zeichenkette2)
   write(*,*) 'len_trim(zeichenkette1): ', len_trim(zeichenkette1)
   write(*,*) 'len_trim(zeichenkette2): ', len_trim(zeichenkette2)
   
   write(*,*)
   write(*,*) 'das 1. bis einschliesslich das 7. Zeichen ausgeben lassen'
   write(*,*) 'zeichenkette1(1:7): ', zeichenkette1(1:7)
   write(*,*) 'zeichenkette2(1:7): ', zeichenkette2(1:7)
   write(*,*)
   write(*,*) 'die Stelle anzeigen lassen, an der das 1. Leerzeichen auftritt'
   write(*,*) "index(zeichenkette1,' '): ", index(zeichenkette1,' ')
   write(*,*) "index(zeichenkette2,' '): ", index(zeichenkette2,' ')

end program strings

Beispielhafte Bildschirmausgabe strings.erg

 Bitte geben Sie einen max. 20 Zeichen langen Text ein!
 listengesteuertes Einlesen mit read(*,*)
123 56789

 Ausgabe der Zeichenkette nach Einlesen mit read(*,*)
 123
 ....5....|....5....|

 Bitte geben Sie erneut einen max. 20 Zeichen langen Text ein!
 formatiertes Einlesen mit read(*,'(A)')
123 56789

 Ausgabe der Zeichenkette nach Einlesen mit read(*,'(A)')
 123 56789
 ....5....|....5....|

 weitere Verarbeitung von Zeichenketten:

 len(zeichenkette1):           20
 len(zeichenkette2):           20
 len_trim(zeichenkette1):            3
 len_trim(zeichenkette2):            9

 das 1. bis einschliesslich das 7. Zeichen ausgeben lassen
 zeichenkette1(1:7): 123
 zeichenkette2(1:7): 123 567

 die Stelle anzeigen lassen, an der das 1. Leerzeichen auftritt
 index(zeichenkette1,' '):            4
 index(zeichenkette2,' '):            4

Muss man einzelne Zeichenketten miteinander verknüpfen, gibt es hierzu den //-Verkettungsoperator.

Durch eine geschickte Kombination von Verkettungsoperator und

  iachar( )   ! gibt die Nummer eines Zeichens in der ASCII-Tabelle an
und
  achar( )    ! gibt zu der Nummer eines Zeichens in der ASCII-Tabelle 
              ! das zugehoerige character-Zeichen zurueck
lassen sich einfache sukzessive numerierte Dateinamen schaffen (siehe Beispiel):

Programm: zeichenketten.f90

   program zeichenketten
   implicit none
   character(len=10) :: ausdruck1
   character(len=4)  :: ausdruck2 = '.erg'
   character(len=10) :: ausdruck3
   integer :: i

   ausdruck1 = 'diesunddas'
   ausdruck3 = 'dies das'
   write(*,*)  'ausdruck1            = ', ausdruck1
   write(*,*)  'ausdruck2            = ', ausdruck2
   write(*,*)  'ausdruck3            = ', ausdruck3
   write(*,*)
   write(*,*)  'len(ausdruck1)       = ', len(ausdruck1)
   write(*,*)  'len(ausdruck2)       = ', len(ausdruck2)
   write(*,*)  'len(ausdruck3)       = ', len(ausdruck3)
   write(*,*)
   write(*,*)  'ausdruck1(5:7)       = ', ausdruck1(5:7)
   write(*,*)  'ausdruck2(1:1)       = ', ausdruck2(1:1)
   write(*,*)
   write(*,*)  'ausdruck1//ausdruck2 = ', ausdruck1//ausdruck2
   write(*,*)   
   write(*,*)  'Die Stelle (den Index) des 1. Leerzeichens in ausdruck3 finden:'
   write(*,*)  "index(ausdruck3,' ') = ", index(ausdruck3,' ')
   write(*,*)
   write(*,*)  'Die Nummer eines Zeichens in der ASCII-Tabelle finden:'
   write(*,*)  "iachar('a')          = ", iachar('a')
   write(*,*) 
   write(*,*)  'Zu der Nummer in die ASCII-Tabelle das korresp. Zeichen finden:'
   write(*,*)  'achar(65)            = ', achar(65)
   write(*,*)
   write(*,*)  "In der ASCII-Tabelle, das auf das 'A' folgende Zeichen finden:"
   write(*,*)  "achar(iachar('A')+1) = ", achar(iachar('A')+1)
   write(*,*)
   write(*,*)  "von ausdruck3 das erste Wort ausgeben:" 
   i =  index(ausdruck3,' ')
   write(*,*) ausdruck3(1:(i-1)) 
   write(*,*) 
   write(*,*) 'Sukzessive Dateinamen zusammensetzen: '
   do i= 1, 3
     write(*,*) 'datei'//achar(iachar('0')+i)//'.dat'
   end do

end program zeichenketten

Bildschirmausgabe zeichenketten.erg
 ausdruck1            = diesunddas
 ausdruck2            = .erg
 ausdruck3            = dies das  
 
 len(ausdruck1)       =           10
 len(ausdruck2)       =            4
 len(ausdruck3)       =           10
 
 ausdruck1(5:7)       = und
 ausdruck2(1:1)       = .
 
 ausdruck1//ausdruck2 = diesunddas.erg
 
 Die Stelle (den Index) des 1. Leerzeichens in ausdruck3 finden:
 index(ausdruck3,' ') =            4
 
 Die Nummer eines Zeichens in der ASCII-Tabelle finden:
 iachar('a')          =           97
 
 Zu der Nummer in die ASCII-Tabelle das korresp. Zeichen finden:
 achar(65)            = A
 
 In der ASCII-Tabelle, das auf das 'A' folgende Zeichen finden:
 achar(iachar('A')+1) = B
 
 von ausdruck3 das erste Wort ausgeben:
 dies
 
 Sukzessive Dateinamen zusammensetzen: 
 datei1.dat
 datei2.dat
 datei3.dat

Noch ein weiteres Beispiel, wie Dateinamen zusammengesetzt werden können (dateiname.f90)

program dateiname
  implicit none
  character(len=40) :: filename
  character(len=44) :: neuer_filename
  character(len=3)  :: zahlenstring
  integer :: zahl
  
  write(*,*) 'Demoprogramm: zusammengesetzte Dateinamen'
  write(*,*) 'Geben Sie den gewuenschten Dateinamen ein (max. 40 Zeichen):'
  read(*,'(A)') filename
  write(*,*) 'Geben Sie eine positive ganze Zahl (max. 3 Zeichen)'
  write(*,*) 'die als Endung des Dateinamens verwendet werden soll:'
  read(*,*)  zahl
  
  write(zahlenstring,'(I3)') zahl 
  ! internal write (Umwandung integer -> character)
  ! hier ist die Formatangabe zwingend notwendig
  ! zahlenstring wird allerdings von rechts aufgefuellt
  ! so dass weitere Tricks angewendet werden, 
  ! damit spaeter in neuer_filename keine Leerzeichen auftreten
              
  
  if ( zahl < 0 .or. zahl > 999 ) then
     stop 'Eingabefehler'

     else if ( zahl > 0 .and. zahl < 10 ) then               
     neuer_filename = trim(filename)//'.00'//adjustl(zahlenstring)
     ! trim( )schneidet Leerzeichen am Ende der Zeichenkette ab
     ! adjustl( ) fuehrende Leerzeichen in einer Zeichenkette werden
     !            nach hinten gesetzt 

       else if (zahl >= 10 .and. zahl < 100) then
       neuer_filename = filename(1:(len_trim(filename)))&
                        &//'.0'//adjustl(zahlenstring) 
      ! len_trim gibt die Stelle des 1. Leerzeichens an
      ! alternative, aufwendigere Realisierung mit gleicher Funktion wie trim( )  
           else
           neuer_filename = trim(filename)//'.'//adjustl(zahlenstring) 
  end if
  
  write(*,*) 
  write(*,*) 'Der zusammengesetzte Dateiname lautet:'
  write(*,*)  neuer_filename
  
end program dateiname

Bildschirmausgabe z.B. (dateiname.erg)


 Demoprogramm: zusammengesetzte Dateinamen
 Geben Sie den gewuenschten Dateinamen ein (max. 40 Zeichen):
ausgabedatei
 Geben Sie eine positive ganze Zahl (max. 3 Zeichen)
 die als Endung des Dateinamens verwendet werden soll:
95

 Der zusammengesetzte Dateiname lautet:
 ausgabedatei.095

Zurück zur Vorlesungsseite


Heidrun.Kolinsky@uni-bayreuth.de
(Dr. Heidrun Kolinsky, Rechenzentrum der Universität Bayreuth, Gebäude NW2, Raum 159, Universitätsstraße 30, D-95440 Bayreuth, Tel. 0921/55-2687)