Die Datentypen
| Typ | Beispiel | Hinweis |
|---|---|---|
integer | 42 | Ganzzahl (meist 32 Bit) |
real | 3.14 | einfache Genauigkeit (32 Bit) |
double precision / real(kind=8) | 3.14d0 | doppelte Genauigkeit (64 Bit) |
complex | (1.0, 2.0) | komplexe Zahl |
logical | .true., .false. | Wahrheitswert |
character | "Text" | Zeichenkette fester Länge |
program typen
use, intrinsic :: iso_fortran_env, only: int64, real32, real64
implicit none
integer :: i = 42
integer(int64) :: gross = 9000000000_int64
real(real32) :: einfach = 1.0_real32 / 3.0_real32
real(real64) :: doppelt = 1.0_real64 / 3.0_real64
complex :: z = (3.0, 4.0)
logical :: ok = .true.
character(len=10) :: s = "Fortran"
character(len=:), allocatable :: dyn
print *, i, gross
print *, einfach
print *, doppelt
print *, abs(z), real(z), aimag(z), z * z
print *, ok, .not. ok, ok .and. .false., ok .or. .false.
print *, "[", s, "] [", trim(s), "] len=", len(s), " len_trim=", len_trim(s)
dyn = "dynamisch"
print *, dyn, len(dyn)
print *, huge(i), huge(gross), digits(einfach), digits(doppelt)
print *, kind(1.0), kind(1.0d0), kind(i), kind(gross)
print *, 0.1_real64 + 0.2_real64 == 0.3_real64
print *, abs(0.1_real64 + 0.2_real64 - 0.3_real64) < epsilon(1.0_real64)
end program typen42 9000000000
0.333333343
0.33333333333333331
5.00000000 3.00000000 4.00000000 (-7.00000000,24.0000000)
T F F T
[Fortran ] [Fortran] len= 10 len_trim= 7
dynamisch 9
2147483647 9223372036854775807 24 53
4 8 4 8
F
TStrings
program texte
implicit none
character(len=30) :: s
character(len=:), allocatable :: t
integer :: pos, n
s = "Hallo Welt"
print *, len(s), len_trim(s)
print "(a)", s(1:5) ! Teilstring
print "(a)", trim(s) // "!" ! Verkettung
pos = index(s, "Welt")
print *, pos
print "(a)", adjustl(" links")
print *, scan("abc.def", "."), verify("123x", "0123456789")
print *, repeat("ab", 3)
t = "Fortran"
do pos = len(t), 1, -1 ! rückwärts ausgeben
write(*, "(a)", advance="no") t(pos:pos)
end do
print *
print *, lge("b", "a"), llt("a", "b")
n = 0
do pos = 1, len_trim(s)
if (s(pos:pos) == "l") n = n + 1
end do
print *, "Anzahl l:", n
write(s, "(a, i0, a, f0.2)") "Wert=", 42, " Preis=", 3.5
print "(a)", trim(s)
read(s(6:7), *) n ! aus dem Text lesen
print *, n + 1
print "(a)", merge("ja ", "nein", n > 10)
end program texte30 10
Hallo
Hallo Welt!
7
links
4 4
ababab
nartroF
T T
Anzahl l: 3
Wert=42 Preis=3.50
43
jaFormatierte Ausgabe
print * gibt Werte mit Standardformat aus. Mit einer Formatangabe kontrollierst du jede Spalte:
| Format | Bedeutung |
|---|---|
i5 / i0 | Ganzzahl in 5 Stellen / so kurz wie möglich |
f8.3 / f0.2 | Festkomma: 8 Stellen, 3 Nachkommastellen |
es12.4 / e12.4 | wissenschaftlich |
a / a10 | Text |
l1 | logical |
x / 3x | Leerzeichen |
/ | neue Zeile |
2(i3) / *(i3) | Wiederholung |
program format_demo
implicit none
integer :: i
real :: pi_ = 3.14159265
print "(i5)", 42
print "(i0)", 42
print "(f8.3)", pi_
print "(f0.2)", pi_
print "(es12.4)", 12345.678
print "(a, i3, a)", "[", 7, "]"
print "(3(i4))", 1, 2, 3
print "(a10, '|', a)", "rechts", "links"
print "(2f6.1, /, 2f6.1)", 1.0, 2.0, 3.0, 4.0
print "(*(i3))", (i * i, i = 1, 8)
print "('Summe: ', f6.2)", 1.5 + 2.25
write(*, "(a)", advance="no") "ohne Umbruch, "
write(*, "(a)") "weiter"
print "(i0.3)", 7
print "(l1, 1x, l1)", .true., .false.
print "(a)", "Zeile1" // new_line("a") // "Zeile2"
end program format_demo42
42
3.142
3.14
1.2346E+04
[ 7]
1 2 3
rechts|links
1.0 2.0
3.0 4.0
1 4 9 16 25 36 49 64
Summe: 3.75
ohne Umbruch, weiter
007
T F
Zeile1
Zeile2Merke
- Typen:
integer,real,double precision/real(real64),complex,logical,character kindlegt die Genauigkeit fest:use iso_fortran_envliefertint64,real64- Strings sind fest lang:
trim,len_trim,//,index, Teilstringss(1:5) - Formatierte Ausgabe mit
(i5, f8.3, a, ...);i0/f0.2für kompakte Zahlen
Aufgabe
Gib eine kleine Tabelle der Quadratzahlen von 1 bis 5 mit rechtsbündigen Spalten aus.