13.15 Standard-Bibliothek <string.h> 

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.

13.15.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.

Hier klicken, um das Bild zu Vergrößern

Abbildung 13.14   strcat() – zwei Strings aneinander hängen

Hier ein Beispiel zu strcat():

/* stringcat.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   char ziel[30] = "Hallo ";
   char name[20];
   printf("Wie heissen Sie: ");
   fgets(name, 20, stdin);
   strcat(ziel, name);
   printf("%s",ziel);
   return EXIT_SUCCESS;
}

13.15.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:

/* strchr.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   char str[] = "Ein String mit Worten";
   printf("%s\n",strchr(str, (int)'W'));
   return EXIT_SUCCESS;
}

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

13.15.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:

/* strcmp.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void String_Vergleich(char s1[], char s2[]) {
   int 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(void) {
   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 EXIT_SUCCESS;
}

13.15.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:

/* strcpy.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   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 EXIT_SUCCESS;
}

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 25.1 verwiesen.

13.15.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:

/* strcspn.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   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 EXIT_SUCCESS;
}

13.15.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():

/* strlen.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   char string[] = "Das ist ein Teststring";
   size_t laenge;
   laenge = strlen(string);
   printf("Der String \"%s\" hat %d Zeichen\n",string, laenge);
   return EXIT_SUCCESS;
}

13.15.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:

/* strncat.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 15
int main(void) {
   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 EXIT_SUCCESS;
}

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

13.15.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:

/* strncmp.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   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 EXIT_SUCCESS;
}

13.15.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:

/* strncpy.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX 20
int main(void) {
   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 EXIT_SUCCESS;
}

13.15.10 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:

/* strpbrk.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   char str1[]="Das ist ein Teststring";
   char str2[]="ie";
   printf("%s\n",strpbrk(str1, str2));
   return EXIT_SUCCESS;
}

13.15.11 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:

/* strrchr.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   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 EXIT_SUCCESS;
}

13.15.12 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:

/* strspn.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   char string[] = "75301234–2123";
   int pos = strspn(string, "0123456789");
   printf("Position, welche keine Ziffer ist:");
   printf(" %d\n",pos); /* 8 */
   return EXIT_SUCCESS;
}

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

13.15.13 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:

/* strstr.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   char string[] = "Das ist ein Teststring";
   char suchstring[] = "ein";
   if( strstr(string, suchstring) != NULL)
      printf("Suchstring \"%s\" gefunden\n", suchstring);
   return EXIT_SUCCESS;
}

13.15.14 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, welches sich im s2 befindet. Ein Token ist ein String, der keine Zeichen aus s2 enthält. Ein Beispiel:

/* strtok.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main(void) {
   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 EXIT_SUCCESS;
}

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.