Zeichenkette

Eine Zeichenkette ist eine Folge von Zeichen (Buchstaben, Ziffern, Sonderzeichen, Steuerzeichen und Leerzeichen sind z.B. Zeichen) aus einem vorab definierten Zeichensatz. Zeichen können sich in einer Zeichenkette wiederholen, die Reihenfolge der Zeichen ist definiert. Zeichenketten sind Symbolsequenzen endlicher Länge.

Mit Zeichenkette wird in der Programmierung auch ein Datentyp bezeichnet, der Zeichenketten (Texte) fester oder variabler Länge enthalten kann. Fast jede Programmiersprache besitzt einen derartigen Datentyp. Er wird auch mit dem englischen Namen (character) string bezeichnet.

Manche Programmiersprachen arbeiten ausschließlich mit diesem Datentyp: Beispiele sind sed, awk und bash.

Repräsentation

Syntax

Im allgemeinen wird eine Zeichenkette in den Programmiersprachen durch das einfache Aneinanderfügen von Zeichen repräsentiert. Sie wird durch einfache oder doppelte Anführungsstriche eingeschlossen:

• "Wikipedia"
• 'Dieser Satz ist eine Zeichenkette.'
• "123"
• "Erste Lösung, um das begrenzende Zeichen \" als Teil der Zeichenkette aufzunehmen."
  (z. B. in C; C-Strings werden stets durch Gänsefüßchen begrenzt)
• 'Zweite Lösung, um ein '' aufzunehmen'
  (Verdoppelung des Begrenzers, z. B. in Pascal oder Rexx; Pascal-Strings werden stets durch Hochkommata begrenzt)
• "Dritte Lösung, um ein ' aufzunehmen":
  (Verwendung eines bzw. des anderen Begrenzers, z. B. in Rexx oder Python)

Solche Strings müssen normalerweise in einer einzigen Zeile notiert werden. In manchen Programmiersprachen wie etwa Python können jedoch Strings, die durch verdreifachte Anführungszeichen begrenzt werden, auch mehrere Zeilen umfassen.

Intern

In Programmiersprachen wie C werden die Zeichenketten fortlaufend im Speicher abgelegt und mit dem ASCII-Zeichen NUL abgeschlossen. Das folgende Beispiel zeigt, wie eine Zeichenkette mit 5 Zeichen in einem Buffer von 10 Byte Länge abgelegt wird.

F	R	A	N	K	NUL	k	e	f	w
46	52	41	4E	4B	00	6B	65	66	77

Die Länge der obigen Zeichenkette ist 5; sie benötigt aber 6 Bytes im Buffer. Buchstaben nach dem NUL-Zeichen zählen nicht mehr zur Zeichenkette; sie können zu einer neuen Zeichenkette gehören oder einfach ungenutzt sein. Eine Zeichenkette in C ist ein Array vom Typ char, wobei die Zeichenkette als Endekennung eine Null (ASCII-Zeichen NUL) enthält. Deswegen heißen solche Zeichenketten auch nullterminiert. Da das Nullzeichen selbst auch noch einen Speicherplatz benötigt, den die Zeichenkette belegt, ist der Speicherbedarf einer Zeichenkette immer mindestens 1 Zeichen größer als die nutzbare Länge der Zeichenkette. Als "Länge der Zeichenkette" wird die Anzahl der Zeichen vor der Endekennung bezeichnet. Sie wird von der C-Funktion strlen() ermittelt.

Der Vorteil dieser Methode ist, dass die Länge eines Strings praktisch nur durch den verfügbaren Speicher begrenzt ist; ein Nachteil ist, dass er keine Null-Zeichen enthalten kann, und dass der Umgang vergleichsweise schwierig ist.

Eine andere Art, Zeichenketten abzulegen, wird in den Programmiersprachen Pascal, BASIC, PL/1 u. a. verwendet:

length	F	R	A	N	K	k	e	f	w
05	46	52	41	4E	4B	6B	65	66	77

Der Vorteil dieser Methode ist, dass zum Umgang mit so abgelegten Strings keine Zeigeroperationen nötig sind; der Nachteil ist, dass die maximale Länge durch das Längen-Byte auf 255 Zeichen limitiert ist. Deshalb unterstützen moderne Pascal-Dialekte wie etwa Delphi auch C-Strings; in Rexx wird die Länge in vier Bytes gespeichert, wodurch die maximale Länge für die meisten praktischen Zwecke quasi unbegrenzt ist.

Noch offen: Hinweis auf MBCS/UTF-8

Basisoperationen mit Zeichenketten

Die Basisoperationen mit Zeichenketten, die in fast allen Programmiersprachen vorkommen, sind die Deklaration, das Kopieren und das Konkatenieren (Aneinanderhängen) von Zeichenketten.

BASIC

text$ = "FRANK";
text2$ = text$;

Das nachgestellte Dollarzeichen gibt an, dass es sich um eine Zeichenkettenvariable handelt. Zeichenketten werden mit dem Pluszeichen kombiniert (konkateniert):

text2$ = "***" + text$ + "***"

C

Ein C-Programm definiert zwei Zeichenketten-Variablen mit 5 Zeichen Länge und weist beiden den gleichen Wert (Inhalt) zu: Um das Nullzeichen abzuspeichern, muss man Arrays mit 6 Zeichen deklarieren.

int main(void)
{
  char[6] text1;
  char[6] text2;

  strcpy ( text1, "FRANK" );
  strcpy ( text2, text1 );

  return 0;
}

Die einfache Zuweisung

text2 = text1;

würde keine echte Kopie erzeugen, sondern lediglich einen zweiten Zeiger auf denselben String; verändert man in diesem Fall einen der beiden, ändert sich der "andere" mit, da es ja eigentlich derselbe ist. Nur durch das Kopieren kann dies verhindert werden.

Eine einfache Methode zwei Strings aneinanderzuhängen, bietet die Standardfunktion strcat:

#include <string.h>

int main(void)
{
  char puffer[128];

  strcpy(puffer, "FRANK");
  strcat(puffer, "ENSTEIN");
}

Pascal

(Streng genommen funktioniert das folgende erst seit Turbo Pascal, da die ursprüngliche von Niklaus Wirth geschaffene Pascal nur packed arrays of char kannte, die etwas umständlicher zu handhaben waren)

var s1, s2: string;
 (...)
s1 := 'FRANK';
s2 := s1;
s2 := '***' + s1 + '***';

Perl

Zum Vergleich das Gleiche in Perl

$text  = "FRANK";
$text2 = $text;

Das vorgestellte Dollarzeichen gibt an, dass es sich um Skalare Variablen handelt. Auch Zahlen könnten in diesen Variablen gespeichert werden.

PHP

Bei PHP verhält es sich ähnlich wie bei Perl

$text = "FRANK";
$text2 = $text; // $text2 ergibt "FRANK"

Text werden mit einem Punkt konkateniert.

$text = "FRANK";
$text = "FRANK" . "ENSTEIN"; // $text ergibt "FRANKENSTEIN"

$text = "FRANK";
$text .= "ENSTEIN"; // $text ergibt "FRANKENSTEIN"

Rexx

In Rexx wird alles, incl. Zahlen, als String repräsentiert. So wird einer Variablen ein String-Wert zugewiesen:

a = "Ottos Mops"

Die folgenden Ausdrücke ergeben jeweils den Wert "Ottos Mops":

• "Ottos" "Mops"
  (implizit verkettet; genau ein Leerzeichen wird automatisch eingefügt)
• "Ottos" || ' Mops'
  (explizit verkettet, kein Einfügen eines Leerzeichens)
• "Ottos"' Mops'
  (implizit verkettet durch unmittelbares Anfügen eines weiteren Strings, der durch das andere Begrenzungszeichen begrenzt wird)

Weitere Operationen

Substrings ermitteln

Angenommen, die Variable s enthalte die Zeichenkette Ottos Mops hopst fort. Dann lassen sich das erste Zeichen (O), die ersten fünf Zeichen (Ottos), das siebte bis zehnte (Mops) sowie die letzten vier (fort) wie folgt ermitteln:

Python

• s[0] => O
• s[:4] oder s[0:4] => Otto
• s[6:10] => Mops
• s[-4:] => fort

Dieses Verfahren wird Slicing genannt. Das erste Zeichen hat den Index 0.

Rexx

• SubStr(s, 1, 1) oder Left(s, 1) => O
• Left(s, 4) oder Word(s, 1) => Ottos
• SubStr(s, 7, 4) oder Word(s, 2) => Mops
• Right(s, 4) oder Word(s, 4) => fort

Rexx kann Strings auch wortweise verarbeiten, wobei Wörter durch (beliebig viele) Leerzeichen getrennt werden. Das erste Zeichen hat, wie bei Pascal-Strings, den Index 1.

Beispiele

awk

Das folgende Beispielprogramm konvertiert eine Zahl von der Dezimaldarstellung in eine Darstellung mit einer anderen Basis. Die erste Zeile ist dabei die Zahl, die Zweite die gewünschte Basis, wobei letztere zwischen 2 und 36 liegen muss, um eine sinnvolle Ausgabe zu erhalten.

BEGIN {
       getline zahl
       getline basis
       print zahl " = " convert(zahl, basis) 
      }

function convert (n, b) {
  nstart = n
  z = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"
  conv = ")" substr(z, (b + 1), 1)
  while (n > 0) {
                 p = n % b 
                 conv = substr(z, (p + 1), 1) conv
                 n = ((n - (n % b)) / b)
                }
  conv = "(" conv
  return conv
}

Algorithmen

Verschiedene Algorithmen arbeiten vorwiegend mit Zeichenketten:

• Suche einer Teilzeichenkette mit Algorithmen wie Boyer-Moore, Knuth-Morris-Pratt oder Boyer-Moore-Horspool
• Bestimmen von Teilzeichenketten, die mit einem regulären Ausdruck beschrieben sind.
• Sortieralgorithmen
• Parser
• Codeumwandlungen (Unicode, usw.)

Heute schreibt ein Programmierer diese Art Algorithmen meist nicht mehr selbst, sondern benutzt Konstrukte einer Sprache oder Bibliotheksfunktionen.

Anmerkungen

Zu den häufigsten Fehlerquellen und damit zu der häufigsten Angriffsquelle auf Servern zählen Pufferüberläufe. Dabei wird versucht, einer Zeichenkettenvariablen einen Inhalt zuzuweisen, dessen Länge die Länge der Variablen übersteigt. Dadurch werden andere, benachbarte Variablen im Speicher überschrieben. Bei geschickter Ausnutzung dieses Effekts kann ein auf einem Server laufendes Programm manipuliert und für Angriffe auf den Server missbraucht werden.

Zur sicheren Programmierung sollten Zeichenketten-Operationen nur mit Funktionen durchgeführt werden, bei denen die maximale Länge der Zeichenkette überprüft wird. In C wären das Funktionen wie z.B. strncpy(), snprintf(), … (anstelle von strcpy(), sprintf(), …).