11.13 Die Standard-Bibliothek <string.h> 

Im weiteren Verlauf dieses Buchs werden Sie öfter Funktionen der Headerdatei <string.h> verwenden. Darin sind viele nützliche Funktionen enthalten, die 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-Verarbeitungsfunktionen in der Headerdatei <string.h> werden char-Zeiger verwendet, die auf den Anfang des Strings, genauer gesagt auf das erste Zeichen, verweisen. Aufgrund der Zeiger kann es auch sein, dass speziell Anfänger ihre Probleme mit dem Kapitel haben werden (besonders mit der Syntax-Beschreibung). Über Zeiger erfahren Sie mehr im nächsten Kapitel. |
11.13.1 »strcat()« – Strings aneinanderhä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 11.14 » strcat()« – zwei Strings aneinanderhängen
Hier sehen Sie 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; }
Hinweis |
Bitte beachten Sie, dass strcat() eine unsichere Funktion ist, weil die Länge des Quellstrings 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 folgt in Abschnitt 27.1, »Buffer-Overflow (Speicherüberlauf)«. |
11.13.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 ist ihre 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 dem Auftreten des Buchstabens 'W' der komplette String ausgegeben.
11.13.3 »strcmp()« – Strings vergleichen 

Für das lexikografische 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; }
11.13.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 aneinanderzuhä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, mit denen wieder auf 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 27.1, »Buffer-Overflow (Speicherüberlauf)«, verwiesen.
11.13.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, das 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; }
11.13.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; }
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. |
11.13.7 »strncat()« – String mit n Zeichen aneinanderhängen 

strncat() 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.
Hinweis |
size_t ist ein primitiver Datentyp, der meistens als unsigned int oder unsigned long deklariert ist. |
11.13.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 lexikografisch 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); /* Weitere Vergleiche sind nicht mehr nötig */ break; } } return EXIT_SUCCESS; }
11.13.9 »strncpy()« – String mit n Zeichen kopieren 

Die sicherere Alternative zur Funktion strcpy() lautet strncpy(), die 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, der laenger" " als 20 Zeichen ist"; /* MAX-Zeichen in str1 kopieren */ strncpy(str1, str2, MAX-1); /* Wichtig, String am Ende terminieren !! */ str1[MAX-1] = '\0'; printf("%s\n",str1); return EXIT_SUCCESS; }
11.13.10 »strpbrk()« – nach dem Auftreten bestimmter Zeichen suchen 

Die Funktion strpbrk() arbeitet ähnlich wie strcspn(), nur dass hierbei nicht die Länge eines Teilstrings ermittelt wird, sondern das erste Auftreten eines Zeichens in einem String, das 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; }
11.13.11 »strrchr()« – das letzte Auftreten eines bestimmten Zeichens im String suchen 

Die Funktion strrchr() ähnelt der Funktion strchr(), nur dass hierbei das erste Auftreten des Zeichens von hinten, genauer gesagt des letzten Zeichens, 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; }
11.13.12 »strspn()« – das erste 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, das keine Ziffer ist.
11.13.13 »strstr()« – einen String nach dem Auftreten eines Teilstrings durchsuchen 

Mit der Funktion strstr() können Sie einen String daraufhin untersuchen, ob ein bestimmter Teilstring auftritt. 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; }
11.13.14 »strtok()« – einen String anhand bestimmter Zeichen zerlegen 

Mit der Funktion strtok() können Sie einen String anhand von Tokens in einzelne Teilstrings zerlegen. Die Syntax sieht so aus:
char *strtok(char *s1, const char *s2);
Damit wird der String s1 durch das Token getrennt, das sich in 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 zu Ende, wenn strtok() den NULL-Zeiger zurückliefert.
Allmählich ist es an der Zeit, dass Sie lernen, mit Zeigern zu arbeiten. Lesen Sie in Kapitel 12 weiter.
Hinweis |
Zu den in der Headerdatei <string.h> deklarierten Funktionen für die Verarbeitung von Strings vom Typ char gibt es in der Headerdatei <wchar.h> die entsprechenden Funktionen für Breitzeichen mit dem Typ wchar_t. Die Verwendung der Funktionen für Breitzeichen-Strings unterscheidet sich nicht von den Funktionen für normale Byte-Strings. Nur der Funktionsname lautet immer ein wenig anders. Eine Übersicht über die Stringfunktionen für Breitzeichen in <wchar.h> finden Sie in Anhang B.23. |
Ihre Meinung
Wie hat Ihnen das Openbook gefallen? Wir freuen uns immer über Ihre Rückmeldung. Schreiben Sie uns gerne Ihr Feedback als E-Mail an kommunikation@rheinwerk-verlag.de.