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.11 Strings/Zeichenketten (»char«-Array) Zur nächsten ÜberschriftZur vorigen Überschrift

Arrays vom Datentyp char werden Strings genannt. Ein String ist eine Kette von einzelnen char-Zeichen mit einer abschließenden 0 (was nicht mit dem Zeichen '0' gleichzusetzen ist). char-Arrays sind typischerweise eindimensional.

Viele Programmierer, die auf die Programmiersprache C stoßen, sind verwundert, dass es keinen eigenen Datentyp für einen String gibt. Für ein char-Array gelten nicht nur die Einschränkungen der herkömmlichen Arrays, sondern es existiert auch das Problem der maximalen Länge von Arrays. Diese scheinbare Unflexibilität kann später, wenn sie effektiv eingesetzt wird, sehr ressourcensparend und schnell sein. Belassen Sie es aber erst einmal in den nächsten Kapiteln bei den etwas eingeschränkten char-Arrays.

Mit dem char-Array können Zeichenfolgen dargestellt und verarbeitet werden. Damit können Sie Benutzerschnittstellen und Textdateien verarbeiten und erstellen.

Eine Form der Stringkonstante wurde schon öfter in diesem Buch verwendet:

printf("Ich bin die Stringkonstante");

Generell lässt sich Folgendes sagen: Alles, was sich zwischen zwei Hochkommata befindet, gilt als Stringkonstante.

Die Deklaration eines char-Arrays ist identisch mit der bisher bekannten Form der Array-Deklaration:

char string_array[100];

Im obigen Beispiel wird ein Array vom Datentyp char angelegt, das 100 einzelne Zeichen speichern kann. Dabei muss die Größe des Array-Feldes nicht mehr ausdrücklich mit angegeben werden:

const char hallo[] = { 'H', 'a', 'l', 'l', 'o', ' ',
                       'W', 'e', 'l', 't', '\n', '\0' };

Diese Schreibweise ist ebenfalls absolut korrekt, aber sehr umständlich. Daher können Sie ein char-Array auch anders, nämlich als einen String (dt. Zeichenkette), deklarieren:

const char hallo[] = { "Hallo Welt\n" };

Beide Variationen sind absolut gleichwertig. Abbildung 11.12 zeigt die rechnerinterne Darstellung des Strings.

Abbildung 11.12 Der String »Hallo Welt« ist ein einfaches »char«-Array.

Diese Zeichenkette benötigt zwölf Elemente (genauer: zwölf Bytes). Wenn Sie aber die Deklaration zu hallo[] genauer betrachten, werden Sie feststellen, dass hierfür eigentlich nur elf Zeichen erforderlich wären. Welche Bedeutung hat das zwölfte Zeichen? Bei einem String benötigen Sie immer ein Stringende-Zeichen, das das Ende eines Strings anzeigt. Das ist die Bedeutung des Zeichens '\0'. Das versehentliche Weglassen des Zeichens ist eine häufige Fehlerquelle, wenn beispielsweise Speicher für n Zeichen reserviert werden soll. Generell muss also bei einem Bedarf von n Zeichen immer für n+1 Zeichen Platz im Array reserviert werden. Hierzu ein kurzes Listing:

/* string1.c */
#include <stdio.h>
#include <stdlib.h>

char hello1[] = { "Hallo Welt\n" };
char output[] = { "Ich bin lesbar \0 Ich nicht mehr" };
char deznu[]  = { "Mich siehst du 0 Mich und die Null auch" };

int main(void) {
   printf("%s",hello1);
   printf("%s\n",output);
   printf("%s\n",deznu);
   return EXIT_SUCCESS;
}

Dieses Beispiel zeigt auch, wie Sie für die formatierte Ausgabe von Zeichenketten die Formatangabe %s verwenden können (s = String). Daher benötigt ein String ein Ende-Kennungszeichen. Bei dem String

char output[] = {"Ich bin lesbar \0 Ich nicht mehr"};

werden nur die Zeichen bis '\0' angezeigt. Der hintere Teil des Strings existiert nur im Arbeitsspeicher. Da zuvor das Zeichen für das Ende des Strings '\0' steht, wird dieser Teil nie auf dem Bildschirm ausgegeben. Im nächsten Beispiel

char deznu[] = {"Mich siehst du 0 Mich und die Null auch"};

wird der ganze String ausgegeben, weil das Zeichen '0' nicht gleichzusetzen ist mit dem Zeichen '\0'.

Es wurde bereits erwähnt, dass es auch möglich ist, auf die einzelnen Zeichen eines Strings zuzugreifen. Wenn Sie einen String beispielsweise mithilfe einer for-Schleife auf seine Länge hin überprüfen wollen, prüfen Sie lediglich auf das Zeichen '\0'. Hier ein Beispiel dazu:

/* string2.c */
#include <stdio.h>
#include <stdlib.h>

char hello1[] = { "Hallo Welt" };
char output[] = { "Ich bin lesbar \0 Ich nicht mehr" };
char deznu[]  = { "Mich siehst du 0 Mich und die Null auch" };


int main(void) {
   int i;

   printf("%c", output[0]);      /* I */
   printf("%c'", hello1[9]);     /* t */
   printf("%c ", deznu[5]);      /* s */
   printf("%c", hello1[7]);      /* Gibt das Zeichen 'e' aus */
   printf("%c", output[12]);     /* a */
   printf("%c", deznu[5]);       /* s */
   deznu[1] = 'y';               /* aus 'i' wird 'y' */
   printf("%c\n", deznu[1]);     /* y */

   for(i=0; hello1[i] != '\0'; i++);
   printf("Länge von '%s' = %d Zeichen\n", hello1, i);

   for(i=0; output[i] != '\0'; i++);
   printf("Länge von '%s' = %d Zeichen\n", output, i);

   for(i=0; deznu[i] != '\0'; i++);
   printf("Länge von '%s' = %d Zeichen\n", deznu, i);
   return EXIT_SUCCESS;
}

Hier werden mit dem Feldindex einzelne Zeichen ausgegeben, genau wie bei den Arrays mit Zahlen. In diesem Fall wird der Text »It's easy« ausgegeben. Es ist natürlich auch möglich, den Inhalt zu verändern, etwa so wie in der Zeile

deznu[1] = 'y';

Anschließend wird mit

for(i=0; hello1[i] != '\0'; i++);

die Anzahl der Zeichen hochgezählt, die sich im String hello1[ ] ohne \0 befinden. Die Abbruchbedingung

hello1[i] != '\0';

ist so lange wahr, bis der Inhalt von hello1[i] == '\0' ist. In diesem Beispiel wäre das bei hello1[11]der Fall, da sich hier das Zeichen '\0' befindet. Beachten Sie hier, dass hinter der for-Schleife ein Semikolon steht. Es gibt in diesem Fall keinen Anweisungsblock zur for-Schleife. Hier wird die Variable i so lange hochgezählt, bis das Stringende-Zeichen '\0' erreicht wird. Gleiches gilt für die anderen beiden Strings.


Galileo Computing - Zum Seitenanfang

11.11.1 Vom String zur Binärzahl topZur vorigen Überschrift

Oben habe ich behauptet, dass es in C keine Datentypen gibt, die Zeichen darstellen können. Die Zeichen wurden mithilfe der ASCII-Code-Tabelle kodiert. Wie verhält sich dies jetzt mit der folgenden Stringkonstante?

char str[] = { "Hallo!\n" };

Wird dieser String in seine einzelnen Zeichen zerlegt, ergibt sich die Zeile:

/* gleichwertig zu "Hallo!\n" */
char str[] = { 'H', 'a', 'l', 'l', 'o', '!', '\n', '\0' };

Werden die einzelnen Zeichen jetzt anhand der ASCII-Code-Tabelle dekodiert, sieht der String schon anders aus:

char str[] = { 72, 97, 108, 108, 111, 33, 10, 0 };

Theoretisch könnten Sie den String auch so angeben und ausgeben lassen, wie das folgende Listing demonstriert:

/* string3.c */
#include <stdio.h>
#include <stdlib.h>

int main(void) {
   /* Hallo!\n ... */
   char str[] = { 72, 97, 108, 108, 111, 33, 10, 0 };
   printf("%s\n",str);
   return EXIT_SUCCESS;
}

Wenn Sie jetzt noch die einzelnen Werte in Binärzahlen umrechnen, können Sie den String aus der Sicht des Computers betrachten:

0100100001100001011011000110110001101111001000010000101000000000

Diese Erklärung soll Ihnen nur zeigen, dass Zeichenketten nicht magischer sind als ganz normale Zahlen-Arrays und in gewisser Hinsicht auch solche sind. Sie wollen einen Beweis? Bitte sehr:

/* string4.c */
#include <stdio.h>
#include <stdlib.h>

int main(void) {
   int i;
   int str[] = { 72, 97, 108, 108, 111, 33, 10, 0 };

   for(i = 0; i < sizeof(str) / sizeof(int); i++)
      printf("%c", str[i]);
   return EXIT_SUCCESS;
}

Ein kleines Programm demonstriert im Folgenden den Umgang mit Strings. Das Programm durchläuft eine Zeichenkette und wandelt alle Stringfolgen "und" in Großbuchstaben um:

/* string5.c */
#include <stdio.h>
#include <stdlib.h>

char undbig[] = {
   "Hund und Katze sind nicht ohne "
   "Grund des Menschen beste Freunde\n"
};

int main(void) {
  int i;

  for(i=0; undbig[i] != '\0'; i++) {
     if(undbig[i-1]==' '&& (undbig[i]=='u' ||undbig[i]=='U')) {
        if(undbig[i+1]=='n'&&undbig[i+2]=='d'&&undbig[i+3]==' '){
           undbig[i] = 'U';
           /* n in Großbuchstaben konvertieren (N) */
           undbig[i+1] -= 32;
           /* d in Großbuchstaben konvertieren  (D) */
           undbig[i+2] -= 32;
        }
      }
   }
   printf("%s", undbig);
   return EXIT_SUCCESS;
}

Zu Beginn des Programms sehen Sie, wie Sie eine Stringkonstante über mehrere Zeilen schreiben können:

char array[] = {
   "Eine Zeichenkette über"
   "2 Zeilen\n"
};

/* Alternative */
char array[] = {
   "Eine Zeichenkette über \
2 Zeilen"};

Beide Schreibweisen erfüllen den gleichen Zweck. Fahren wir mit der ersten for-Schleife des Programms fort:

for(i=0; undbig[i] != '\0'; i++)

Hier wird der String zeichenweise durchlaufen, bis das Stringende-Zeichen '\0' gefunden wird. Bei der nächsten Anweisung

if(undbig[i-1] == ' ' && (undbig[i]=='u' || undbig[i]=='U'))

wird überprüft, ob das Zeichen, bei dem sich der Feldindex gerade befindet, ein kleines 'u' oder ein großes 'U' und das Zeichen davor ein Whitespace-Zeichen (Leerzeichen) ist. Falls nicht, wird i in der for-Schleife um den Wert 1 inkrementiert. Wird ein 'u' oder 'U' gefunden, folgt die Überprüfung

if(undbig[i+1]=='n' && undbig[i+2]=='d' && undbig[i+3]==' ')

daraufhin, ob die nächsten beiden Zeichen 'n' und 'd' sind und ob sich dahinter ebenfalls ein Whitespace-Zeichen befindet. Falls dies ebenso zutrifft, wurde eine Zeichenfolge "und" gefunden. Dann werden die einzelnen Zeichen geändert:

undbig[i] = 'U';
undbig[i+1] -= 32;  /* 'n' - 32 */
undbig[i+2] -= 32;  /* 'd' - 32 */

Sehen Sie sich zum besseren Verständnis auch die ASCII-Tabelle in Anhang A.2 an. Sehen Sie nach, welche Dezimalwerte die Zeichen 'n' und 'd' haben. In Dezimalwerten würden die Subtraktionen der Werte so aussehen:

110-32=78 und 100-32=68

In der ASCII-Tabelle sind 'N' = 78 und 'D' = 68.



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