Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
Vorwort des Gutachters
1 Einstieg in C
2 Das erste Programm
3 Grundlagen
4 Formatierte Ein-/Ausgabe mit »scanf()« und »printf()«
5 Basisdatentypen
6 Operatoren
7 Typumwandlung
8 Kontrollstrukturen
9 Funktionen
10 Präprozessor-Direktiven
11 Arrays
12 Zeiger (Pointer)
13 Kommandozeilenargumente
14 Dynamische Speicherverwaltung
15 Strukturen
16 Ein-/Ausgabe-Funktionen
17 Attribute von Dateien und das Arbeiten mit Verzeichnissen (nicht ANSI C)
18 Arbeiten mit variabel langen Argumentlisten – <stdarg.h>
19 Zeitroutinen
20 Weitere Headerdateien und ihre Funktionen (ANSI C)
21 Dynamische Datenstrukturen
22 Algorithmen
23 CGI mit C
24 MySQL und C
25 Netzwerkprogrammierung und Cross–Plattform-Entwicklung
26 Paralleles Rechnen
27 Sicheres Programmieren
28 Wie geht’s jetzt weiter?
A Operatoren
B Die C-Standard-Bibliothek
Stichwort

Download:
- ZIP, ca. 10,6 MB
Buch bestellen
Ihre Meinung?

Spacer
<< zurück
C von A bis Z von Jürgen Wolf
Das umfassende Handbuch
Buch: C von A bis Z

C von A bis Z
3., aktualisierte und erweiterte Auflage, geb., mit CD und Referenzkarte
1.190 S., 39,90 Euro
Galileo Computing
ISBN 978-3-8362-1411-7
Pfeil 11 Arrays
Pfeil 11.1 Arrays deklarieren
Pfeil 11.2 Initialisierung und Zugriff auf Arrays
Pfeil 11.2.1 Gültigkeitsbereich von Arrays
Pfeil 11.3 Arrays vergleichen
Pfeil 11.4 Anzahl der Elemente eines Arrays ermitteln
Pfeil 11.5 Übergabe von Arrays an Funktionen
Pfeil 11.6 Arrays aus Funktionen zurückgeben
Pfeil 11.7 Programmbeispiel zu den Arrays
Pfeil 11.8 Einlesen von Array-Werten
Pfeil 11.9 Mehrdimensionale Arrays
Pfeil 11.9.1 Mehrdimensionale Arrays initialisieren
Pfeil 11.9.2 Übergabe von zwei- bzw. mehrdimensionalen Arrays an Funktionen
Pfeil 11.10 Arrays in Tabellenkalkulation einlesen (*.CSV–Dateien)
Pfeil 11.11 Strings/Zeichenketten (»char«-Array)
Pfeil 11.11.1 Vom String zur Binärzahl
Pfeil 11.12 Einlesen von Strings
Pfeil 11.13 Die Standard-Bibliothek <string.h>
Pfeil 11.13.1 »strcat()« – Strings aneinanderhängen
Pfeil 11.13.2 »strchr()« – ein Zeichen im String suchen
Pfeil 11.13.3 »strcmp()« – Strings vergleichen
Pfeil 11.13.4 »strcpy()« – einen String kopieren
Pfeil 11.13.5 »strcspn()« – einen Teilstring ermitteln
Pfeil 11.13.6 »strlen()« – Länge eines Strings ermitteln
Pfeil 11.13.7 »strncat()« – String mit n Zeichen aneinanderhängen
Pfeil 11.13.8 »strncmp()« – n Zeichen von zwei Strings miteinander vergleichen
Pfeil 11.13.9 »strncpy()« – String mit n Zeichen kopieren
Pfeil 11.13.10 »strpbrk()« – nach dem Auftreten bestimmter Zeichen suchen
Pfeil 11.13.11 »strrchr()« – das letzte Auftreten eines bestimmten Zeichens im String suchen
Pfeil 11.13.12 »strspn()« – das erste Auftreten eines Zeichens, das nicht vorkommt
Pfeil 11.13.13 »strstr()« – einen String nach dem Auftreten eines Teilstrings durchsuchen
Pfeil 11.13.14 »strtok()« – einen String anhand bestimmter Zeichen zerlegen


Galileo Computing - Zum Seitenanfang

11.13 Die Standard-Bibliothek <string.h> Zur nächsten ÜberschriftZur vorigen Überschrift

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.



Galileo Computing - Zum Seitenanfang

11.13.1 »strcat()« – Strings aneinanderhängen Zur nächsten ÜberschriftZur vorigen Überschrift

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)«.



Galileo Computing - Zum Seitenanfang

11.13.2 »strchr()« – ein Zeichen im String suchen Zur nächsten ÜberschriftZur vorigen Überschrift

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.


Galileo Computing - Zum Seitenanfang

11.13.3 »strcmp()« – Strings vergleichen Zur nächsten ÜberschriftZur vorigen Überschrift

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;
}

Galileo Computing - Zum Seitenanfang

11.13.4 »strcpy()« – einen String kopieren Zur nächsten ÜberschriftZur vorigen Überschrift

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.


Galileo Computing - Zum Seitenanfang

11.13.5 »strcspn()« – einen Teilstring ermitteln Zur nächsten ÜberschriftZur vorigen Überschrift

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;
}

Galileo Computing - Zum Seitenanfang

11.13.6 »strlen()« – Länge eines Strings ermitteln Zur nächsten ÜberschriftZur vorigen Überschrift

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.



Galileo Computing - Zum Seitenanfang

11.13.7 »strncat()« – String mit n Zeichen aneinanderhängen Zur nächsten ÜberschriftZur vorigen Überschrift

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.



Galileo Computing - Zum Seitenanfang

11.13.8 »strncmp()« – n Zeichen von zwei Strings miteinander vergleichen Zur nächsten ÜberschriftZur vorigen Überschrift

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;
}

Galileo Computing - Zum Seitenanfang

11.13.9 »strncpy()« – String mit n Zeichen kopieren Zur nächsten ÜberschriftZur vorigen Überschrift

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;
}

Galileo Computing - Zum Seitenanfang

11.13.10 »strpbrk()« – nach dem Auftreten bestimmter Zeichen suchen Zur nächsten ÜberschriftZur vorigen Überschrift

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;
}

Galileo Computing - Zum Seitenanfang

11.13.11 »strrchr()« – das letzte Auftreten eines bestimmten Zeichens im String suchen Zur nächsten ÜberschriftZur vorigen Überschrift

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;
}

Galileo Computing - Zum Seitenanfang

11.13.12 »strspn()« – das erste Auftreten eines Zeichens, das nicht vorkommt Zur nächsten ÜberschriftZur vorigen Überschrift

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.


Galileo Computing - Zum Seitenanfang

11.13.13 »strstr()« – einen String nach dem Auftreten eines Teilstrings durchsuchen Zur nächsten ÜberschriftZur vorigen Überschrift

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;
}

Galileo Computing - Zum Seitenanfang

11.13.14 »strtok()« – einen String anhand bestimmter Zeichen zerlegen topZur vorigen Überschrift

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.




Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen.






<< zurück
  
  Zum Katalog
Zum Katalog: C von A bis Z

 C von A bis Z
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Einstieg in C++






 Einstieg in C++


Zum Katalog: C++ von A bis Z






 C++ von A bis Z


Zum Katalog: C/C++






 C/C++


Zum Katalog: Shell-Programmierung






 Shell-Programmierung


Zum Katalog: Linux-UNIX-Programmierung






 Linux-UNIX-
 Programmierung


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Katalog: Ubuntu GNU/Linux






 Ubuntu GNU/Linux


Zum Katalog: Coding for Fun







 Coding for Fun 


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Galileo Press 2009
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de