====== Zeichenketten ======

Zeichenketten in Fortran haben eine Art Sonderstellung. Die Sprache war nicht dafür gedacht mit Zeichenketten umzugehen, was sich später ändern musste, da viele Anwender nicht mehr an der Lösung einer mathematischen Aufgabe interessiert waren, sondern Programme bedienen wollten. 

In C ist es üblich Zeichenketten mit einem Nullbyte (''\0'') abzuschließen. In Fortran werden Zeichenketten mit Leerzeichen aufgefüllt.

===== Deklaration einer Zeichenkette =====

Eine Zeichenkette wird genauso wie eine normale Variable definiert, allerdings wird anstelle der Länge des Datentyps, nach dem Stern die Länge der Zeichenkette angegeben. 

<code fortran>
  ! definiere eine Zeichnekette der Länge 8 Zeichen
  CHARACTER*8 a
  ! vergleiche dazu: Integer mit 8 Byte Genauigkeit
  INTEGER*8 b
</code>

Wollen Sie mehrere Zeichenketten unterschiedlicher Länge gleichzeitig anlegen, geht das so:

<code fortran>
  CHARACTER a*8, b*6;
</code>

Folgendermaßen kann (und sollte) eine Zeichenkette initialisiert werden:

<code fortran>
  CHARACTER*7 :: a = "EinWort"
  CHARACTER*7 :: b
  ! oder
  b = "EinWort"
</code>

==== Hollerith-Konstante ====

Als Hollerithkonstante wird die Angabe einer Zeichenkette nach folgendem Muster bezeichnet:

<code>
<Länge>h<Zeichenkette>
</code>

Dabei wird die Länge der Zeichenkette vor dem Buchstaben ''h'' angegeben, nach dem ''h'' folgt dann die eigentliche Zeichenkette. Diese Art der Angabe kann beim Initialisieren von Zeichenketten verwendet werden, bspw:

<code fortran>
  CHARACTER*8 a /8hdiesiste/
</code>

Der ''gfortran'' Compiler merkt an, dass die Angabe einer Zeichenkette als Hollerithkonstante veraltet ist.

===== Zugriff auf Elemente =====

In Fortran ist möglich auf Elemente einer Zeichenkette zuzugreifen, wie auf die eines Feldes, dh. es ist möglich auf einzelne Elemente zuzugreifen (und die bspw. zu überschreiben) oder auf ganze Teile der Zeichenkette:

<code fortran>
  CHARACTER*10 :: a = "EinTestEin"

  a(1:1) = "e"
  a(4:7) = "fach"

  write (*,*) a
</code>

Ausgabe: 
<code>
 einfachEin
</code>

===== Längenbestimmung =====

In Fortran gibt es zwei Funktionen um die Länge von Zeichenketten zu bestimmen. Zum einen ''LEN'', zum anderen ''LEN_TRIM''. ''LEN'' gibt die Anzahl an vereinbarten Zeichen zurück, dh. die Zahl, die nach dem Stern bei der Variablendeklaration steht bzw. stand. ''LEN_TRIM'' liefert die Länge des Zeichenkette zurück, dh. abzüglich der abschließenden Leerzeichen. 

===== Variabel lange Zeichenketten =====

In Fortran ist es wie oben beschrieben zunächst nur möglich konstant lange Zeichenketten zu definieren. Manchmal ist es aber notwendig Zeichenketten zu verlängern oder zu verkürzen. Dazu kann ''ALLOCATE'' verwendet werden. Mehr dazu im Kapitel [[dynaminc_memory|dynamische Speicherverwaltung]].

In einer offiziellen Spracherweiterung zu Fortran 90, wurden auch Zeichenketten variabler Länge eingeführt. So genannte ''varying_string''s. Mehr zu diesem Thema finden Sie unter [[https://de.wikibooks.org/wiki/Fortran:_Fortran_95:_Fortran_95-Erweiterungen#Zeichenketten_variabler_L.C3.A4nge|WikiBooks.org]].

===== Übergabe an Funktionen =====

Übergibt man Zeichenketten an Unterprogramme, so wird als letzter unsichtbarer Parameter die festgelegte Länge der Zeichenkette übergeben. Dh. im Unterprogramm liefert auch ''LEN'' die korrekte Länge der Zeichenkette. Als Länge der Zeichenkette im Unterprogramm kann dann ''(*)'' angegeben werden:

<code fortran string.F90>
program main
  CHARACTER :: a*14 = "DiesIstEinTest"
  
  write (*,*) LEN(a)
  call up ( a );
end program

subroutine up ( a )
  CHARACTER*(*) a
  
  write (*,*) LEN(a)
  write (*,*) a
end subroutine
</code>

===== Konkatenation (Aneinanderhängen) =====

Das Aneinanderhängen zweier Strings ist durch denn ''<nowiki>//</nowiki>'' Operator möglich. Bspw:

<code fortran>
  CHARACTER*11 url
  CHARACTER*7 name
  CHARACTER*4 dot
  
  name = "proggen"
  dot = ".org"
  
  url = name // dot
  write (*,*) url
  write (*,*) name // dot
</code>

===== Stringoperationen =====

Für Zeichenketten existieren vordefinierte Funktionen, die dem Programmierer einiges an Arbeit abnehmen.

^ Funktion ^ Beschreibung ^
^ Lexikalische Funktionen   ^ ^
| lge ( s1, s2 ) | gibt an, ob die Zeichenkette s1 lexikalisch vor oder gleich s2 steht (dh. gibt ''.TRUE.'' zurück, wenn s1 >= s2). Dabei wird vom ASCII Zeichensatz ausgegangen. |
| lgt ( s1, s2 ) | ''.TRUE.'', wenn s1 > s2 |
| lle ( s1, s2 ) | ''.TRUE.'', wenn s1 <nowiki><=</nowiki> s2 |
| llt ( s1, s2 ) | ''.TRUE.'', wenn s1 < s2 |
^ Sonstige Funktionen   ^ ^
| len ( s ) | Gibt die vereinbarte Länge der String-Variablen zurück |
| len_trim ( s ) | Gibt die echte Länge des String zurück (ohne abschließende Leerzeichen) |
| trim ( s ) | Gibt die Zeichenkette ohne abschließende Leerzeichen zurück |
| adjustl ( s ) | linksbündiges Ausrichten des Strings |
| adjustr ( s ) | rechtsbündiges Ausrichten des Strings | 
| repeat ( s, i ) | ''s'' wird ''i'' mal wiederholt |
| index ( s1, s2 [,back] ) | gibt die Indexposition der Startposition des ersten Auftretens von s2 in s1 zurück. Ist der Parameter ''back = .TRUE.'', dann wird das letzte Auftreten angezeigt. |
| scan ( s1, s2 [,back] ) | gibt die erste (letzte) Position zurück, wo in s1 ein Zeichen aus dem Zeichenvorrat s2 auftritt. |
| verify (s1, s2 [,back] ) | gibt die erste (letzte) Position zurück, wo in s1 ein Zeichen verwendet wird, welches **nicht** in s2 ist. |