Fortran: FORTRAN 77: Ein- und Ausgabe

Links hinzufügen
Aus Wikibooks
<<< zur Fortran-Startseite
<< FORTRAN 77 Fortran 90/95 >>
< Unterprogramme Anhang >

READ[Bearbeiten]

Die READ-Anweisung dient dem Einlesen von Daten. Typisches Beispiel ist die Dateneingabe mittels Tastatur. Formal sieht eine READ-Anweisung so aus:

READ([UNIT=]unit, [FMT=]fmt [, ERR=err] [, END=end] [, IOSTAT=iostat]) [eingabeliste]
  • unit ... Nummer der Eingabeeinheit (ist systemabhängig), Sternoperator oder auch die einer Datei mittels OPEN-Anweisung zugeordnete Nummer.
  • fmt ... Anweisungsnummer zu einer FORMAT-Anweisung oder Sternoperator
  • err ... Tritt während der Eingabe ein Fehler auf, so wird zu dieser Anweisungsnummer gesprungen
  • end ... Nach dem Einlesen des letzten Datensatzes wird zu dieser Anweisungsnummer gesprungen
  • iostat ... READ-Status


Listengesteuerte Eingabe auf der Standardeingabe (normalerweise die Tastatur): 

READ (*,*) A, B, C

Alternativ kann das auch so geschrieben werden: 

READ (UNIT=*, FMT=*) A, B, C

Beim Intel Fortran Compiler, gfortran und g95 ist auch UNIT = 5 als stdin (Tastatur) vorbelegt. Das Einlesen aus Dateien und die Einstellung des Formates werden später erläutert.


Beispiel: 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP

      INTEGER I(5)

C  Einlesen in ein Feld (UNIT ... Standardeingabe, FMT ... listengesteuert)
      READ (*,*) I
C     ...
      
      END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8


Kurze Erläuterung zu IOSTAT:

Wert Erläuterung
0 kein Fehler
positiver Wert (systemabhängig) Fehler
negativer Wert (systemabhängig) End Of File und kein Fehler


Beispiel: 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP

      INTEGER I
      INTEGER ST

C  Einlesen eines Wertes
      READ (*, *, IOSTAT=ST) I
      
C  Ausgabe des IO-Status      
      WRITE (*,*) 'IO-Status:', ST
      
      END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8
Ausgabe:
Für Eingabe: 5 → 0
Für Eingabe: 5.3 → Positiver Wert = Fehler

WRITE[Bearbeiten]

Die WRITE-Anweisung dient der Datenausgabe. Typisches Beispiel ist die Anzeige von Daten auf dem Bildschirm. Formal sieht eine WRITE-Anweisung so aus:

WRITE([UNIT=]unit, [FMT=]fmt [, ERR=err] [, IOSTAT=iostat]) [ausgabeliste]
  • unit ... Nummer der Ausgabeeinheit (ist systemabhängig), Sternoperator oder auch die einer Datei mittels OPEN-Anweisung zugeordnete Nummer.
  • fmt ... Anweisungsnummer zu einer FORMAT-Anweisung oder Sternoperator
  • err ... Tritt während der Ausgabe ein Fehler auf, so wird zu dieser Anweisungsnummer gesprungen
  • iostat ... WRITE-Status


Listengesteuerte Ausgabe auf der Standardausgabe (normalerweise der Bildschirm): 

WRITE (*,*) A, B, C

Alternativ kann das auch so geschrieben werden: 

WRITE (UNIT=*, FMT=*) A, B, C

Beim Intel Fortran Compiler, gfortran und g95 sind auch

  • unit=0 als stderr (Bildschirm) und
  • unit=6 als stdout (Bildschirm)

vorbelegt. Bezüglich IOSTAT gilt auch hier der im vorigen Abschnitt kurz geschilderte Sachverhalt. Die Ausgabe in Dateien und die Einstellung des Formates werden nachfolgend erläutert.


Beispiel: 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP

      INTEGER I(5)

C     I(1) = ...
C     ...

C Ausgabe der Feldwerte (UNIT ... Standardausgabe, FMT ... listengesteuert)
      WRITE (*,*) I
C     ...
      
      END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8

Formatierung[Bearbeiten]

Die Ein- und Ausgabeformatierung kann beeinflusst werden. Zu diesem Zweck gibt es die FORMAT-Anweisung. 

       ... (..., FMT = marke, ...) ...
marke  FORMAT (formatliste)

Alternativ dazu kann auch direkt bei der FMT-Option die Formatliste bekanntgemacht werden. 

       ... (..., FMT = '(formatliste)', ...) ...

Formatlistenelemente[Bearbeiten]

Formatspezifizierer Kommentar
Ix[.z] Ganzzahl mit einer Feldlänge von x Zeichen. z gibt die Mindestanzahl der auszugebenden Zeichen an (Feld wird, wenn nötig, mit führenden Nullen aufgefüllt).
Fx.y Fixkommazahl mit einer Gesamtfeldlänge von x Zeichen. y ist die Anzahl der Nachkommastellen (Vorzeichen und Dezimalpunkt müssen in der Gesamtfeldlänge berücksichtigt werden).
Ex.y Gleitkommazahl mit einer Gesamtfeldlänge von x Zeichen. y ist die Anzahl der Nachkommastellen. (Vorzeichen, Dezimalpunkt und die Zeichen für den Exponenten müssen in der Gesamtfeldlänge berücksichtigt werden).
Dx.y -"-
A Ein Zeichenkette.
Ax Eine Zeichenkette mit x Zeichen.
Lx Ein logischer Wert, T bzw. F
xX x Leerzeichen.

Obige Tabelle der Formatlistenelemente ist nicht vollständig. Fortran kennt noch weitere Formatierungsmöglichkeiten. Die Ausgabe erfolgt normalerweise rechtsbündig. Reicht die Gesamtfeldlänge bei numerischen Werten nicht aus, so werden anstelle einer Zahl Sternchen angezeigt.

Beispiel: 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP
 
      INTEGER A
   
      A = 999
      WRITE (*, 3333) A
C  Ausgabe: 999
  
      A = -999
      WRITE (*, 3333) A
C  Ausgabe: ***
 
 3333 FORMAT (I3)
     
      END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8


Weitere Formatierungsbeispiele:

Code Ausgabe 
      WRITE(*, 999) 1234
      WRITE(*, 999) 1234567
      WRITE(*, 999) 1234567890
     
999   FORMAT(I9.6)  

   001234
  1234567
*********

      WRITE(*, 999) 555.6666
      WRITE(*, 999) +5.6
      WRITE(*, 999) -55.666E7
      WRITE(*, 999) -55555.666
     
999   FORMAT(F9.3)

  555.667
    5.600
*********
*********

      WRITE(*, 999) 555.6666
      WRITE(*, 999) +5.6
      WRITE(*, 999) -55.666E7
      WRITE(*, 999) -55555.666
        
999   FORMAT(E9.3) 

0.556E+03
0.560E+01
-.557E+09
-.556E+05

      WRITE(*, 999) 'Hallo'
      WRITE(*, 999) 'ABCDEFGHIJKL'
      WRITE(*, 888) 'ABCDEFGHIJKL'
     
     
888   FORMAT(A)
999   FORMAT(A10)

     Hallo
ABCDEFGHIJ
ABCDEFGHIJKL

      WRITE(*, *) 'FORTRAN', '77'
      WRITE(*, 999) 'FORTRAN', '77'
     
999   FORMAT(A, 1X, A)  

 FORTRAN77
FORTRAN 77

      WRITE(*, 888) 'FORTRAN', '77'
      WRITE(*, 999) 'FORTRAN', '77'

888   FORMAT(A, T3, A)              
999   FORMAT(A, T20, A)

FO77RAN
FORTRAN            77

      WRITE(*, 999) 'FORTRAN', '77'

999   FORMAT(A, /, A) 

FORTRAN
77

      WRITE(*, 999) 34.56
      WRITE(*, *)   34.56
     
C  SP ... Sign Plus (+)
999   FORMAT(SP, F12.3)

    +34.560
34.56

Wiederholung von Formatteilen[Bearbeiten]

Beispiel: 

      WRITE (*, 100) 'abc', 10.3, 'xxx', 23.4
 100  FORMAT (2(A3, F6.1))

WRITE etwas anders[Bearbeiten]

Beispiel: 

      WRITE (*, 100) 
 100  FORMAT ('Hallo', 1X, 'Welt!')

Dateien[Bearbeiten]

Datensatz[Bearbeiten]

Datensätze können in folgender Form auftreten:

  • Formatierter Datensatz: Textdatensatz
  • Unformatierter Datensatz: Datensatz in einer maschineninternen Form.
  • Dateiendesatz

Datei[Bearbeiten]

Für FORTRAN 77 ist alles eine Datei, das durch READ oder WRITE bearbeitbar ist.

Zugriffsmethoden:

  • Sequentieller Zugriff: Lesen ab Beginn der Datei (file) und dann immer den nächsten Datensatz einlesen. Geschrieben wird jeweils ans Dateiende. Auf interne Dateien kann nur sequentiell zugegriffen werden.
  • Direkter Zugriff: Bearbeiten in beliebiger Reihenfolge durch Angabe der Satznummer.

Dateitypen:

  • Externe Datei: Eine konventionelle Datei
  • Interne Datei: CHARACTER-Variable oder -Feld.

Dateien haben im Betriebssystem einen Dateinamen. In FORTRAN wird eine Datei über eine Dateinummer (unit) angesprochen. Die Zuordnung erfolgt mit dem Befehl OPEN.

OPEN[Bearbeiten]

Zum Öffnen einer externen Datei dient die OPEN -Anweisung.

OPEN (liste)

mit folgender liste

Element Kommentar
[UNIT =] x x ist eine Dateinummer (0 bis 99)
FILE = x x ist der externe Dateiname
IOSTAT = x x ist 0 wenn OPEN fehlerfrei ausgeführt wurde, ansonsten eine systemabhängige Fehlernummer
ERR = x Bei Fehler Sprung zur Anweisungsnummer x
STATUS = x Dateistatus:
'OLD' ... Datei existiert bereits
'NEW' ... Datei wird neu erzeugt
'REPLACE' ... Wenn die Datei existiert, wird sie überschrieben, ansonsten neu erzeugt.
'SCRATCH' ... namenlose temporäre Datei
'UNKNOWN' ... System bestimmt Dateistatus selbst
ACCESS = x Zugriffsmethode:
'SEQUENTIAL' ... Sequentielle Datei
'DIRECT' ... direkter Zugriff
FORM = x Format:
'FORMATTED' oder 'UNFORMATTED'
RECL = x Datensatzlänge (positive Zahl, ACCESS='DIRECT', in Bytes bzw. bei formatierten Dateien in Characters)
BLANK = x 'NULL' (ignorieren von Leerzeichen bei numerischen Werten) oder 'ZERO' (Leerzeichen bei numerischen Werten als 0 interpretieren)


Eingestellte Vorgabewerte sind:

  • STATUS = 'UNKNOWN'
  • ACCESS = 'SEQUENTIAL'
  • FORM = 'FORMATTED'
  • BLANK = 'NULL'

Wird ACCESS='DIRECT' gesetzt, so gilt FORM='UNFORMATTED' als Vorgabewert.

Beispiel: 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP
 
      OPEN (20, FILE='/tmp/testdatei.txt', STATUS='OLD', ERR=222)
 
      WRITE (*,*) 'Voller Erfolg'
 
      CLOSE(20)
      GOTO 333 
 
 222  WRITE(*,*) 'Fehler beim Öffnen der Datei'
 333  END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8

CLOSE[Bearbeiten]

Geschlossen wird die Verbindung zur externen Datei mit dem CLOSE-Befehl.

CLOSE (liste)

liste:

Element Kommentar
[UNIT =] x wie bei OPEN
IOSTAT = x wie bei OPEN
ERR = x wie bei OPEN
STATUS = x KEEP ... Datei erhalten
DELETE ... Datei löschen

Lesen und Schreiben[Bearbeiten]

Aus Dateien gelesen oder in Dateien geschrieben wird mit den bereits bekannten READ- und WRITE-Anweisungen.

Element Kommentar
[UNIT =] x Unit 0 bis 99 bzw. CHARACTER-Variable oder Feld (interne Datei)
[FMT =] x siehe Formatierung
REC = x Datensatznummer bei Direktzugriff (siehe Abschnitt Direktzugriff)
IOSTAT = x wie bei READ
ERR = x Bei Fehler Sprung zur Anweisungsnummer x
END = x Bei Dateiende Sprung zur Anweisungsnummer x (nicht erlaubt bei Direktzugriff)


Beispiel: 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP
 
      CHARACTER*80 A
 
      OPEN (20, FILE='/tmp/testdatei.txt', STATUS='OLD', ERR=222)
 
 10   CONTINUE
C  Aus Datei lesen
      READ (20, 888, END=20) A
C  Auf Standardausgabe schreiben   
      WRITE (*,*) A
      GOTO 10 
 
 20   CLOSE(20)
      GOTO 333 
 
 222  WRITE(*,*) 'Fehler beim Öffnen der Datei'
 888  FORMAT(A) 
 333  END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8

Direktzugriff[Bearbeiten]

OPEN:

Element Kommentar
ACCESS = x x ... 'DIRECT'
RECL = x x ... Datensatzlänge (positive Zahl, ACCESS='DIRECT', in Bytes bzw. bei formatierten Dateien in Characters)

READ/WRITE:

Element Kommentar
REC = x x ... Satznummer bei Direktzugriff


Beispiel: Gegeben ist die Textdatei /tmp/testdatei.txt mit dem Inhalt 

Die WRITE-Anweisung dient der Datenausgabe aus einem FORTRAN-Programm auf ein 
externes Gerät. Typisches Beispiel ist die Anzeige von Daten auf dem Bildschirm. 
Formal sieht eine WRITE-Anweisung so aus:

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP
 
      CHARACTER*10 C
 
      OPEN (20, FILE='/tmp/testdatei.txt', 
     &          STATUS='OLD', 
     &          ACCESS='DIRECT', 
     &          RECL=10,
     &          ERR=222)
 
      READ (20, REC=4, ERR=333) C
      WRITE (*,*) C

      READ (20, REC=25, ERR=333) C
      WRITE (*,*) C
 
      CLOSE (20)
      GOTO 444
 
 222  WRITE (*,*) 'Fehler beim Öffnen der Datei'
 333  WRITE (*,*) 'Fehler beim Lesen des Datensatzes'
 444  CONTINUE
 
      END


12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8

Ausgabe: 

Datenausga
Fehler beim Lesen des Datensatzes

Positionieren bei sequentiellen Dateien[Bearbeiten]

Datensatzzeiger um einen Datensatz zurücksetzen:

BACKSPACE ([UNIT=]x [,IOSTAT=y] [,ERR=z])

Positionieren an den Dateibeginn:

REWIND ([UNIT=]x [,IOSTAT=y] [,ERR=z])

Schreiben eines Dateiendsatzes:

ENDFILE ([UNIT=]x [,IOSTAT=y] [,ERR=z])


Beispiel: 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP
 
      CHARACTER*100 C(3)
 
      OPEN (20, FILE='/tmp/testx.txt', 
     &          STATUS='NEW', 
     &          ERR=222)
  
      WRITE (20,*) 'Das ist eine Testdatei'
      WRITE (20,*) 'Dies ist Zeile 2 der Testdatei'
      WRITE (20,*) 'Jenes die Zeile 3 der Testdatei'
      WRITE (20,*) 'Jetzt ist''s aber genug'
      ENDFILE (20, ERR=444)      

      REWIND (20, ERR=444)
      READ (20, FMT=555, ERR=333) C      
      WRITE (*, FMT=555) C

      BACKSPACE (20, ERR=444) 
      READ (20, FMT=555, ERR=333) C(1)
      WRITE (*, FMT=555) C(1)
 
      GOTO 999
 
 222  WRITE (*,*) 'Fehler beim Öffnen der Datei'
      GOTO 999
      
 333  WRITE (*,*) 'Fehler beim Lesen des Datensatzes'
      GOTO 999

 444  WRITE (*,*) 'Sonstiger Fehler'
      GOTO 999

 555  FORMAT (A)

 999  CLOSE (20)
 
C  Ausgabe:
C   Das ist eine Testdatei
C   Dies ist Zeile 2 der Testdatei
C   Jenes die Zeile 3 der Testdatei
C   Jenes die Zeile 3 der Testdatei 

      END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8

INQUIRE[Bearbeiten]

Die Anweisung INQUIRE dient der Abfrage einiger Eigenschaften von Dateien oder I/O-Units.

INQUIRE (FILE = x, liste)

mit x ... Dateiname (inkl. Pfad)

INQUIRE ([UNIT =] x, liste)

mit x ... Nummer der I/O-Unit.


liste:

Element Kommentar
ACCESS = x x:
  • 'SEQ' ... sequentieller Dateizugriff
  • 'DIRECT' ... Direktzugriff
BLANK = x x:
  • 'NULL'
  • 'ZERO'
DIRECT = x x:
  • 'YES' ... Direktzugriff
  • 'NO' ... kein Direktzugriff für diese Datei erlaubt
  • 'UNKNOWN' ... unbekannt
ERR = x Bei Fehler Sprung zur Anweisungsnummer x
EXIST = x x:
  • .TRUE. ... Datei existiert
  • .FALSE. ... Datei existiert nicht
FORM = x x:
  • 'FORMATTED' ... Datei geöffnet für formatierte Datensätze
  • 'UNFORMATED' ... Datei geöffnet für unformatierte Datensätze
FORMATTED = x
  • 'YES' ... formatierte Datensätze sind erlaubt
  • 'NO' ... formatierte Datensätze sind nicht erlaubt
  • 'UNKNOWN' ... unbekannt
IOSTAT = x x ist 0 wenn INQUIRE fehlerfrei ausgeführt wurde, ansonsten eine systemabhängige positive Fehlernummer
NAME = x Der Dateiname wird der Zeichenketten-Variablen x zugewiesen. Hat die Datei keinen Namen, dann ist das Ergebnis undefiniert.
NAMED = x x:
  • .TRUE. ... Datei besitzt Namen
  • .FALSE. ... Datei besitzt keinen Namen
NEXTREC = x x ... Nummer des nächsten Datensatzes
NUMBER = x x ... Nummer der mit einer externen Datei verbundenen I/O-Unit.
OPENED = x x:
  • .TRUE. ... Datei ist geöffnet
  • .FALSE. ... Datei ist nicht geöffnet
RECL = x x ... Datensatzlänge bei Direktzugriff
SEQUENTIAL = x x:
  • 'YES' ... sequentiell
  • 'NO' ... nicht sequentiell
  • 'UNKNOWN' ... unbekannt
UNFORMATTED = x
  • 'YES' ... unformatierte Datensätze sind erlaubt
  • 'NO' ... unformatierte Datensätze sind nicht erlaubt
  • 'UNKNOWN' ... unbekannt


Beispiel: Datei vorhanden? 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP
 
      LOGICAL L
 
      INQUIRE (FILE='/tmp/testdatei.txt', EXIST=L, ERR=222)
      WRITE (*,*) L
C  Ausgabe:
C    wenn Datei existiert:       T
C    wenn Datei nicht existiert: F      
    
      GOTO 999
  
 222  WRITE (*,*) 'Fehler!'
 999  CONTINUE
      END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8


Beispiel: Infos zu einer geöffneten Datei 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP
 
      LOGICAL EX
      CHARACTER*15, DI, FO, AC, SE
      INTEGER NU
      
      OPEN (25, FILE='/tmp/testdatei.txt', STATUS='OLD', ERR=222) 
 
      INQUIRE (25, EXIST = EX, 
     &             DIRECT = DI, 
     &             SEQUENTIAL = SE,
     &             FORMATTED = FO,
     &             ACCESS = AC,
     &             NUMBER = NU,
     &             ERR=222)

      WRITE (*,*) 'EXIST? ', EX 
      WRITE (*,*) 'DIRECT? ', DI 
      WRITE (*,*) 'SEQUENTIAL? ', SE 
      WRITE (*,*) 'FORMATTED? ', FO
      WRITE (*,*) 'ACCESS? ', AC
      WRITE (*,*) 'NUMBER? ', NU

C  Ausgabe, z.B.
C     EXIST?  T
C     DIRECT? YES
C     SEQUENTIAL? YES
C     FORMATTED? YES
C     ACCESS? SEQUENTIAL
C     NUMBER?           25
    
      GOTO 999
  
 222  WRITE (*,*) 'Fehler!'
 999  CLOSE (25)

      END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8

Interne Dateien[Bearbeiten]

  • Interne Dateien sind vom Datentyp CHARACTER (Zeichen oder Zeichenketten)
  • Das Lesen aus bzw. das Schreiben in interne Dateien erfolgt immer sequentiell


Beispiel: Schreiben in eine interne Datei 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP
 
      CHARACTER*15 CH
      REAL R
      
      R = 12.5678
      
C  Interne Datei "CH"      
      WRITE (CH, *) R
      
      WRITE (*,*) 'R lexikalisch groesser als Buchstabe "A"? ', 
     &            LGE(CH, 'A')

      END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8


Beispiel: Lesen aus einer internen Datei 

0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8  
12345678901234567890123456789012345678901234567890123456789012345678901234567890

      PROGRAM BSP
 
      CHARACTER*15 CH
      REAL R
      
      CH = '12.5678'
      
C  Interne Datei "CH"      
      READ (CH, '(F15.5)') R
      
      WRITE (*,*) 'R    = ', R
      WRITE (*,*) 'R**2 = ', R**2

      END

12345678901234567890123456789012345678901234567890123456789012345678901234567890
0   . |  1    .    2    .    3    .    4    .    5    .    6    .    7 |  .    8



<<< zur Fortran-Startseite
<< FORTRAN 77 Fortran 90/95 >>
< Unterprogramme Anhang >
Abgerufen von „https://de.wikibooks.org/w/index.php?title=Fortran:_FORTRAN_77:_Ein-_und_Ausgabe&oldid=1004107“