Mit Arrays haben Sie die Möglichkeit, eine geordnete Folge von Werten, eines bestimmten Typs ab zu speichern und zu bearbeiten. Arrays werden manches mal auch als Vektoren, Felder oder Reihungen bezeichnet. C C++ C/C++ Arrays Felder Zeichenkette String Stringfunktionen Arrays - Zeichenkette String Stringfunktionen mehrdimensionale Arrays Kapitel 14: Arrays

14.14. Standard-Bibliothek - <string.h>            zurück  zum Inhaltsverzeichnis

Im weiteren Verlauf dieses Buchs werden Sie öfters Funktionen der Headerdatei <string.h> verwenden. Darin sind viele nützliche Funktionen enthalten, welche die Arbeit mit Strings vereinfachen. Die Headerdatei <string.h> entspricht dem ANSI C-Standard und dürfte somit im Lieferumfang der meisten Compiler vorhanden sein, sofern sie ANSI C-kompatibel sind.

Hinweis
 

Bei den String-Varbeitungsfunktionen in der Headerdatei <string.h> werden char-Zeiger verwendet, welche auf den Anfang des Strings, genauer auf das erste Zeichen verweisen. Aufgrund der Zeiger kann es auch sein, dass speziell Anfänger so ihre Probleme mit dem Kapitel haben werden (besonders mit der Syntax-Beschreibung). Über Zeiger erfahren Sie mehr im nächsten Kapitel.

14.14.1 strcat() - Strings aneinander hängen
Um einen String an einen anderen zu hängen, können Sie die Funktion strcat() (string catenation) verwenden.

char *strcat(char *s1, const char *s2); 

Damit wird s2 an das Ende von s1 angehängt, wobei (logischerweise) das Stringende-Zeichen '\0' am Ende von String s1 überschrieben wird. Voraussetzung ist auch, dass der String s2 Platz in s1 hat.

Abbildung 14.14: strcat() - zwei Strings aneinander hängen
Abbildung 14.14: strcat() - zwei Strings aneinander hängen

Hier ein Beispiel zu strcat():

#include <stdio.h>
#include <string.h>

int main()
{
   char ziel[30] = "Hallo ";
   char name[20];

   printf("Wie heissen Sie: ");
   fgets(name, 20, stdin);

   strcat(ziel, name);
   printf("%s",ziel);
   return 0;
}



Hinweis
 

Bitte beachten Sie, dass strcat() eine unsichere Funktion ist. Dies deshalb, weil die Länge des Quell-Strings nicht überprüft oder angegeben werden kann. Somit kann mit strcat() über den offiziellen Speicherbereich hinaus geschrieben werden. Es wird empfohlen, strncat() zu verwenden. Mehr dazu in Abschnitt 26.1, Buffer Overflow (Speicherüberlauf).

14.14.2 strchr() - ein Zeichen im String suchen
Wollen Sie in einem String nach einem bestimmten Zeichen suchen, eignet sich die Funktion strchr() (string char). Hier die Syntax:

char *strchr(const char *s, int ch); 

Diese Funktion gibt die Position im String s beim ersten Auftreten von ch zurück. Tritt das Zeichen ch nicht auf, wird NULL zurückgegeben. Ein Beispiel:

#include <stdio.h>
#include <string.h>

int main()
{
   char str[] = "Ein String mit Worten";
   printf("%s\n",strchr(str, (int)'W'));
   return 0;
}

Hiermit wird ab Auftreten des Buchstabens 'W' der komplette String ausgegeben.

14.14.3 strcmp() - Strings vergleichen
Für das lexographische Vergleichen zweier Strings kann die Funktion strcmp() verwendet werden. Die Syntax lautet:

int strcmp(const char *s1, const char *s2);

Sind beide Strings identisch, gibt diese Funktion 0 zurück. Ist der String s1 kleiner als s2, ist der Rückgabewert kleiner als 0, und ist s1 größer als s2, dann ist der Rückgabewert größer als 0. Ein Beispiel:

#include <stdio.h>
#include <string.h>

void String_Vergleich(char s1[], char s2[])
{
   int ret;
   ret =  strcmp (s1, s2);
   if(ret == 0)
      printf("%s == %s\n",s1, s2);
   else
      printf("%s %c %s\n",s1,( (ret < 0)?'<':'>'), s2);
}

int main()
{
   char str1[] = "aaa";
   char str2[] = "aab";
   char str3[] = "abb";

   String_Vergleich(str1, str2);
   String_Vergleich(str1, str3);
   String_Vergleich(str3, str2);
   String_Vergleich(str1, str1);
   return 0;
}

14.14.4 strcpy() - einen String kopieren
Wollen Sie einen String in einen adressierten char-Vektor kopieren, können Sie die Funktion strcpy() (string copy) nutzen. Die Syntax lautet:

char *strcpy(char *s1, const char *s2); 

Dass hierbei der String-Vektor s1 groß genug sein muss, versteht sich von selbst. Bitte beachten Sie dabei, dass das Ende-Zeichen '\0' auch Platz in s1 benötigt. Hierzu ein Beispiel:

#include <stdio.h>
#include <string.h>

int main()
{
   char ziel_str[50];
   char str1[] = "Das ist ";
   char str2[] = "ein ";
   char str3[] = "Teststring";

   strcpy(ziel_str, str1);
   /* Ein umständliches Negativbeispiel */
   strcpy(&ziel_str[8], str2);
   /* So ist es einfacher und sicherer */
   strcat(ziel_str, str3);
   printf("%s\n",ziel_str);
   return 0;
}

In diesem Beispiel haben Sie gesehen, dass es auch möglich ist, mit strcpy() Strings aneinander zu hängen:

strcpy(&ziel_str[8], str2);

Nur ist das umständlich, und schließlich gibt es dafür die Funktion strcat(). Beim Betrachten der Funktion strcpy() fällt außerdem auf, dass hierbei ebenfalls nicht überprüft wird, wie viele Zeichen in den Zielstring kopiert werden, womit wieder in einen undefinierten Speicherbereich zugegriffen werden kann. Daher ist auch die Funktion strcpy() eine gefährliche Funktion, wenn diese falsch eingesetzt wird. Hierzu sei wieder auf den Abschnitt 26.1 verwiesen.

14.14.5 strcspn() - einen Teilstring ermitteln
Wollen Sie die Länge eines Teilstrings bis zum Auftreten eines bestimmten Zeichens ermitteln, eignet sich die Funktion strcspn(). Die Syntax lautet:

int strcspn(const char *s1, const char *s2);

Sobald ein Zeichen, welches in s2 angegeben wurde, im String s1 vorkommt, liefert diese Funktion die Position dazu zurück. Ein Beispiel:

#include <stdio.h>
#include <string.h>

int main()
{
   char string[] = "Das ist ein Teststring";
   int  pos;
   pos = strcspn( string, "Ttg" );
   printf("Erstes Auftreten von T, t oder g an Pos.: %d\n",pos);
   return 0;
}

14.14.6 strlen() - Länge eines Strings ermitteln
Um die Länge eines Strings zu ermitteln, kann die Funktion strlen() (string length) eingesetzt werden. Die Syntax lautet:

size_t strlen(const char *s1);

Damit wird die Länge des adressierten Strings s1 ohne das abschließende Stringende-Zeichen zurückgegeben. Das Beispiel zu strlen():

#include <stdio.h>
#include <string.h>

int main()
{
   char string[] = "Das ist ein Teststring";
   size_t laenge;

   laenge = strlen(string);
   printf("Der String \"%s\" hat %d Zeichen\n",string, laenge);
   return 0;
}



Hinweis
 

Dass die Funktion strlen() das Stringende-Zeichen '\0' nicht mitzählt, ist eine häufige Fehlerquelle, wenn es darum geht, dynamisch Speicher für einen String zu reservieren. Denken Sie daran, dass Sie immer Platz für ein Zeichen mehr bereithalten.

14.14.7 strncat() - String mit n Zeichen aneinander hängen
Es ist die gleiche Funktion wie strcat(), nur dass hiermit n Zeichen angehängt werden. Die Syntax lautet:

char *strncat(char *s1, const char *s2, size_t n);

Diese Funktion ist aus Sicherheitsgründen der Funktion strcat() vorzuziehen. Ein Beispiel:

#include <stdio.h>
#include <string.h>
#define MAX 15

int main()
{
   char string[MAX] = "Hallo ";
   char puffer[20];
   /* Vorhandenen Platz in string ermitteln*/
   size_t len = MAX - strlen(string)+1;

   printf("Ihr Name: ");
   fgets(puffer, 20, stdin);
   strncat(string, puffer, len);
   printf("%s",string);
   return 0;
}

Damit ist sichergestellt, dass nicht mehr in einen undefinierten Speicherbereich geschrieben wird.

Hinweis
 

size_t ist ein primitiver Datentyp, der meistens als unsigned int oder unsigned long deklariert ist.

14.14.8 strncmp() - n Zeichen von zwei Strings miteinander vergleichen
Diese Funktion arbeitet genauso wie die Funktion strcmp(), nur mit dem Unterschied, dass n Zeichen miteinander verglichen werden. Die Syntax lautet:

int strncmp(const char *s1, const char *s2, size_t n);

Hiermit werden also die ersten n Zeichen von s1 und die ersten n Zeichen von s2 lexikographisch miteinander verglichen. Der Rückgabewert ist dabei derselbe wie schon bei strcmp(). Ein Beispiel:

#include <stdio.h>
#include <string.h>

int main()
{
   char str1[] = "aaaa";
   char str2[] = "aabb";
   int i;

   for(i = strlen(str1); i > 0; i--)
      {
         if(strncmp( str1, str2, i) != 0)
            printf("Die ersten %d Zeichen der Strings "\
                   "sind nicht gleich\n",i);
         else
            {
               printf("Ab Zeichen %d sind "\
                      "beide Strings gleich\n",i);
               /* Weiter vergleich sind nicht mehr nötig */
               break;
            }
      }
   return 0;
}

14.14.9 strncpy() - String mit n Zeichen kopieren
Die sicherere Alternative zur Funktion strcpy() lautet strncpy(), welche n Zeichen kopiert. Der Ablauf der Funktion ist hingegen wieder derselbe wie bei strcpy(). Die Syntax lautet:

char *strncpy(char *s1, const char *s2, size_t n);

Hier werden n Zeichen aus dem String s2 in den String s1 ohne das '\0'-Zeichen kopiert. Das Beispiel:

#include <stdio.h>
#include <string.h>
#define MAX 20

int main()
{
   char str1[MAX];
   char str2[] = "Ein Teststring welcher laenger"\
                 " als 20 Zeichen ist";
   /* MAX-Zeichen in str1 kopieren */
   strncpy(str1, str2, MAX);
   /* Wichtig, String am Ende terminieren !! */
   str1[MAX] = '\0';
   printf("%s\n",str1);
   return 0;
}

14.14.9.1 strpbrk() - Auftreten bestimmter Zeichen suchen
Diese Funktion arbeitet ähnlich wie strcspn(), nur dass hierbei nicht die Länge eines Teilstrings ermittelt wird, sondern das erste Auftreten eines Zeichens in einem String, welches im Suchstring enthalten ist. Die Syntax lautet:

char *strpbrk( const char *s1, const char *s2);

Ein Beispiel dazu:

#include <stdio.h>
#include <string.h>

int main()
{
   char str1[]="Das ist ein Teststring";
   char str2[]="ie";

   printf("%s\n",strpbrk(str1, str2));
   return 0;
}

14.14.9.2 strrchr() - das letzte Auftreten eines bestimmten Zeichens im String suchen
Diese Funktion ist der Funktion strchr() ähnlich, nur dass hierbei das erste Auftreten des Zeichens von hinten, genauer das letzte ermittelt wird. Die Syntax lautet:

char *strrchr(const char *s, int ch);

Die Funktion fgets() hängt beim Einlesen eines Strings immer das Newline-Zeichen am Ende an. Manchmal ist das nicht erwünscht. Wir suchen mit strrchr() danach und überschreiben diese Position mit dem '\0'-Zeichen:

#include <stdio.h>
#include <string.h>

int main()
{
   char string[20];
   char *ptr;

   printf("Eingabe machen: ");
   fgets(string, 20 , stdin);
   /* Zeiger auf die Adresse des Zeichens \n */
   ptr = strrchr(string, '\n');
   /* Zeichen mit \0 überschreiben */
   *ptr = '\0';
   printf("%s",string);
   return 0;
}

14.14.9.3 strspn() - erstes Auftreten eines Zeichens, das nicht vorkommt
Die Funktion strspn() gibt die Position des ersten Auftretens eines Zeichens an, das nicht vorkommt. Die Syntax lautet:

int strspn(const char *s1, const char *s2); 

Ein Beispiel dazu:

#include <stdio.h>
#include <string.h>

int main()
{
   char string[] = "75301234-2123";
   int pos = strspn(string, "0123456789");
   printf("Position, welche keine Ziffer ist:");
   printf(" %d\n",pos); /* 8 */
   return 0;
}

Dieses Beispiel liefert Ihnen die Position des Zeichens zurück, welches keine Ziffer ist.

14.14.9.4 strstr() - String nach Auftreten eines Teilstrings durchsuchen
Mit der Funktion strstr() können Sie einen String nach Auftreten eines Teilstrings durchsuchen. Die Syntax ist:

char *strstr(const char *s1, const char *s2);

Damit wird der String s1 nach einem String mit der Teilfolge s2 ohne '\0' durchsucht. Ein Beispiel:

#include <stdio.h>
#include <string.h>

int main()
{
   char string[] = "Das ist ein Teststring";
   char suchstring[] = "ein";
   if( strstr(string, suchstring) != NULL)
      printf("Suchstring \"%s\" gefunden\n",suchstring);
   return 0;
}

14.14.9.5 strtok() - String anhand bestimmter Zeichen zerlegen
Mit der Funktion strtok() können Sie einen String in einzelne Teilstrings anhand von Tokens zerlegen. Zuerst die Syntax:

char *strtok(char *s1, const char *s2);

Damit wird der String s1 durch das Token getrennt, welche sich im s2 befinden. Ein Token ist ein String, der keine Zeichen aus s2 enthält. Ein Beispiel:

#include <stdio.h>
#include <string.h>

int main()
{
   char string[] = "Ein Teststring mit mehreren Worten\n"
                   "und mehreren Zeilen.\t Ende\n";
   int i=1;
   char *ptr;

   ptr = strtok(string, "\n\t ");
   while(ptr != NULL)
      {
         printf("% d. Wort: %s\n",i++,ptr);
         ptr = strtok(NULL, "\n\t ");
      }
   return 0;
}

Mit der Zeile

ptr = strtok(string, "\n\t "); 

würde nur das erste Wort anhand eines der Whitspace-Zeichen Newline, Tabulator oder Space getrennt werden. Der String wird jetzt von der Funktion strtok() zwischengespeichert. Wollen Sie jetzt den String mit weiteren Aufrufen zerlegen, müssen Sie NULL verwenden.

ptr = strtok(NULL, "\n\t ");

Dabei gibt jeder Aufruf das Token zurück. Das jeweilige Trennzeichen wird dabei mit '\0' überschrieben. In diesem Beispiel ist die Schleife am Ende, wenn strtok() den NULL-Zeiger zurückliefert.

Allmählich ist es an der Zeit, dass Sie lernen, mit Zeigern zu arbeiten.

Hinweis
 

In der Headerdatei <string.h> sind noch weitere Funktionen deklariert, auf die im Verlauf des Buchs noch eingegangen wird.

Weiter mit Kapitel 15: Zeiger (Pointer)            zum Inhaltsverzeichnis