Anfang   zurück   weiter

Vektoren und Felder

Bisher sind Variablen nur als einzelne Datenelemente (als Skalare) aufgetreten. Manchmal ist es aber notwendig mehrere Elemente (Vektoren und Arrays) des gleichen Datentyps zu verwenden. Wollte man z.B. in einem Programm die monatlichen Ausgaben eines Jahres erfassen, so könnte man das mit einzelnen Variablen versuchen:
float ausgaben_jaenner, ausgaben_feber, ... , ausgaben_november, ausgaben_dezember;
Ist dabei schon die Namensgebung unpraktisch, wird der Zugriff auf die Variablen noch unpraktischer. Für diese Fälle eignen sich die Feldvariablen.

Eindimensionale Arrays
Eine Variable wird als Vektor (eindimensionales Array) vereinbart, indem dem Variablennamen ein Index in eckigen Klammern nachgestellt wird.

Eine Vereinbarung wie

char s[512];
definiert 512 Datenelemente vom Typ char, die aufeinanderfolgend im Speicher angeordnet sind:

 s[0]   s[1]   s[2]    .....    s[510]   s[511] 

Zu beachten ist, daß die Indizes mit Null beginnen und bis 511 laufen und nicht von 1 bis 512 . Um sich dies zu vergegenwärtigen, ist es hilfreich das mit 0 indizierte Element nicht als "erstes Element" sondern als "Anfangselement" zu bezeichnen.
Der Speicherbedarf einer Variablen ist durch ihren Typ bestimmt. Die Größe von s ist der Speicherbedarf für einen Wert des Typs char[512]; also 512 Byte. Dies läßt sich in C auch mit Hilfe eines Operators bestimmen - des sizeof-Operators. Dabei ist sizeof() keine Funktion, sondern ein unärer Operator, der als Argument den Namen einer Variablen übernimmt und die Größe des Arguments in Byte zurückliefert. sizeof() akzeptiert als Argument auch einen Datentypnamen.

/* sizes.c - gibt die Groesse einiger Typen und Ausdruecke aus
 *
#include <stdio.h>
int main(void)
 {
 char c;
 char s[512];
 int n;
 int m[40];

 printf("\nDie Variable c benoetigt%3d Byte\n", sizeof(c));
 printf("Eine char Variable benoetigt%3d Byte\n", sizeof(char));
 printf("Die Variable s benoetigt%4d Byte\n", sizeof(s));
 printf("Eine char[512] Variable benoetigt%4d Byte\n", sizeof(char[512]));
 printf("Die Variable n benoetigt%3d Byte\n", sizeof(n));
 printf("Eine int Variable benoetigt%3d Byte\n", sizeof(int));
 printf("Die Variable m benoetigt%3d Byte\n", sizeof(m));
 printf("Eine int[40] Variable benoetigt%3d Byte\n", sizeof(int[40]));
 return 0;
 }
Die Variable s ist ein Vektor, der aus 512 Elementen besteht, jedes Element wird durch einen ganzzahligen Index angesprochen. Dieser Index kann auch durch einen ganzzahligen Ausdruck bestimmt sein. s[1], s[5] und s[500] sind Elemente von s, genauso wie s[i], wenn i eine Integervariable ist, oder s[a[i]], wenn a[i] die i-te Komponente eines Integerarrays bedeutet. Achtung: Der C-Compiler überprüft nicht, ob der Index innerhalb der "erlaubten" Grenzen liegt. Ist der Index außerhalb des deklarierten Bereiches wird das Programm trotzdem kompiliert und gelinkt, nur bei der Ausführung ist das Ergebnis unvorhersehbar.
In manchen Fällen möchte man den Index eines Arrays von n Elementen von 1 bis n laufen lassen. Die einfachste Lösung in so einem Fall ist ein Array zu deklarieren, das gerade ein Element mehr als notwendig aufweist und das überzählige Element zu ignorieren oder zur Speicherung eines anderen Wertes zu verwenden. Um z.B. die monatlichen Ausgaben eines Jahres in einem Vektor zu speichern, deklariert man
float ausgaben[13];
und kann in ausgaben[1] die Ausgaben für Jänner in ausgaben[2] die Ausgaben für Februar usw. ablegen und ausgaben[0] z.B. dazu verwenden, die Gesamtausgaben des Jahres aufzunehmen.

Mehrdimensionale Arrays
Die Deklaration mehrdimensionaler Arrays unterscheidet sich nicht wesentlich von der Deklaration von Vektoren, nur daß entsprechend mehr Indizes auftreten. Zum Beispiel wäre ein Spielfeld mit 4 Reihen und 4 Spalten als zweidimensionales Feld so zu repräsentieren:

int board[4][4];
Das resultierende Array hat 16 Elemente: board[0][0], board[0][1], board[0][2], board[0][3],board[1][0], ... , board[3][2], board[3][3]. Die Struktur ist unten illustriert:

board[0][0] board[0][1] board[0][2] board[0][3]
board[1][0] board[1][1] board[1][2] board[1][3]
board[2][0] board[2][1] board[2][2] board[2][3]
board[3][0] board[3][1] board[3][2] board[3][3]

Die Ablegung der Werte im Speicher erfolgt sequentiell zeilenweise. Dies gilt sinngemäß auch für Arrays höherer Dimension. Bei der Ablegung der Werte im Speicher läuft der am weitesten rechts stehende Index am schnellsten durch, der am weitesten links stehende am langsamsten.

Bei der Deklaration von Arrays kann die Anzahl der Elemente außer über eine Zahl auch über eine symbolische Konstante angegeben werden.

#define MONATE 12
int array[MONATE];
ist äquivalent zu
int array[12];
Diese Methode ist in vielen Fällen der direkten Dimensionsangabe vorzuziehen, da eine spätere Änderung der Dimension im Programm wesentlich leichter erfolgen kann.

Initialisierung von Arrays
Bei der Deklaration von Arrays kann gleichzeitig das gesamte Array, oder auch nur ein Teil initialisiert werden. Für die Initialisierung folgt der Array Deklaration ein Gleichheitszeichen und eine durch Komma getrennte Liste von Werten in geschwungenen Klammern.

int reihe[4] = { 100, 200, 300, 400 };
weist die Zahl 100 an reihe[0], Zahl 200 an reihe[1] usw. zu. Wird die Dimension ausgelassen, so wird das Array gerade so groß angelegt um die Initialisierungswerte aufzunehmen.
int reihe[] = { 100, 200, 300, 400 };
hat denselben Effekt wie die vorher angeführte Array Deklaration. Sind zu wenig Werte angegeben um das gesamte Array zu initialisieren, sind bei lokalen Variablen die Variableninhalte der nichtinitialisierten Komponenten des Arrays unbestimmt. Mehrdimensionale Arrays können ebenfalls initialisiert werden. Die Werteliste wird den Arrayelementen in der Reihenfolge ihrer Ablegung im Speicher zugeordnet.
int matrix[3][3] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 };
ergibt die folgende Zuweisung:

matrix[0][0] enthält den Wert 1
matrix[0][1] enthält den Wert 2
matrix[0][2] enthält den Wert 3
matrix[1][0] enthält den Wert 4
matrix[1][1] enthält den Wert 5
matrix[1][2] enthält den Wert 6
matrix[2][0] enthält den Wert 7
matrix[2][1] enthält den Wert 8
matrix[2][2] enthält den Wert 9

Bei der Initialisierung mehrdimensionaler Arrays kann das Programm übersichtlicher gestaltet werden, wenn extra Klammern in der Werteliste verwendet werden und diese auch über mehrere Zeilen ausgedehnt wird. Die folgende Initialisierung ist der vorhergehenden äquivalent:

int matrix[3][3] = { {1, 2, 3 },
   {4, 5, 6},
   {7, 8, 9 } };

Maximale Array Größe
Auf PC's stehen meist für alle Daten ein Bereich von 64KByte zur Verfügung. Die Größe eines Arrays in Bytes hängt von der Anzahl der Elemente und der Elementgröße ab, woraus die Maximalgröße für ein Array folgt. Im folgenden ist der Speicherbedarf für die verschiedenen Datentypen angegeben (gültig auf den meisten PC's).

Datentyp Größe (Byte)
int 2
short 2
long 4
float 4
double 8

Es sei nochmals in Erinnerung gerufen, daß der Speicherbedarf einer Variablen oder eines Datentyps in einem C-Programm mittels des sizeof() Operators bestimmt werden kann.

 

Zeichenketten

Die Programmiersprache C kennt keinen eigenen Datentyp für Zeichenketten. Zeichenketten werden in C als Vektor von einzelnen Zeichen (Characters) deklariert.

Characters

Ein Character (Zeichen) ist ein einzelner Buchstabe, eine Ziffer, ein Interpunktionszeichen oder sonst ein derartiges Symbol. Ein String ist jede Reihe von Zeichen. Strings werden zur Speicherung von Textdaten verwendet, welche eben diese Zeichen (Buchstaben, Ziffern usw.) umfassen. In C wird der char Typ zur Speicherung von Zeichen verwendet, der gleichzeitig auch einen numerischen Datentyp darstellt. Die Zuordnung der einzelnen Zeichen zu den numerischen Werten erfolgt über eine entsprechende Codetabelle. Der am meisten verwendete Code ist der sogenannte ASCII (American Standard Code for Information Interchange) Code. ASCII weist Werte zwischen 0 und 255 den verschiedenen Zeichen zu. Der Code für das Zeichen A ist z.B. 65, und das ist auch genau der Wert, der im Speicher abgelegt wird. Das heißt aber auch: Wie bei den anderen Variablen müssen Zeichen auch vor dem Gebrauch deklariert werden. Genauso wie bei den anderen Variablen kann bei der Deklaration auch gleich eine Initialisierung erfolgen. Um eine Zeichenkonstante zu erzeugen, wird das Zeichen in einfache Hochkomma eingeschlossen. Mit der #define Direktive können auch symbolische Zeichenkonstanten erstellt werden.
/* char.c
   Demonstration der numerischen Natur von char Variablen
 */
#include <stdio.h>

#define EX 'x'

/* Deklariere und initialisiere drei char Variable */
char c1 = 'a';
char c2 = 90;
char c3 = EX;

int main(void)
{
  /* Gebe Variable c1 zuerst als ein Zeichen, dann als Zahl aus */
  printf("\nAls Zeichen ist Variable c1 : %c", c1);
  printf("\nAls Zahl ist Variable c1    : %d\n", c1);

  /* Und nun dasselbe mit c2 */
  printf("\nAls Zeichen ist Variable c1 : %c", c2);
  printf("\nAls Zahl ist Variable c1    : %d\n", c2);

  /* Dasselbe Spiel mit c3 */
  printf("\nAls Zeichen ist Variable c3 : %c", c1);
  printf("\nAls Zahl ist Variable c3    : %d\n", c1);
  return 0;
}

Strings

Variablen vom Typ char können nur ein einzelnes Zeichen aufnehmen, sind also nur von limitiertem Nutzen. Man möchte aber auch Zeichenketten (Strings) wie z.B. Namen oder Adressen speichern. In C gibt es keinen eigenen Datentyp für Strings, diese Art der Information wird, wie schon erwähnt, vielmehr in Form von Zeichenvektoren abgehandelt. Um eine Zeichenkette der Länge n zu speichern, ist es notwendig, ein Characterfeld der Länge n+1 anzulegen.
char string[10];
deklariert ein Array mit 10 Elementen vom Typ char. Dieses Feld kann eine Zeichenkette von 9 oder weniger Zeichen aufnehmen. Der Grund dafür liegt in der Tatsache, daß in dem Feld von einzelnen Zeichen auf irgendeine Weise das Ende des Strings gekennzeichnet werden muß. Dies wird in C durch das spezielle Zeichen \0, das den ASCII Code Null besitzt, erreicht. Wird der String "Zeichen" gespeichert, so werden die sieben Character Z, e, i, c, h, e, n, gefolgt vom Nullzeichen \0, also insgesamt acht, im Speicher abgelegt.

Auch Strings können bei ihrer Deklaration gleich initialisiert werden. Da Strings Zeichenvektoren sind, kann ihre Initialisierung wie bei Feldern Element für Element erfolgen:

char string[10] = {'Z', 'e', 'i', 'c', 'h', 'e', 'n', '\0'};
Angenehmerweise kann die Initialisierung auch in der Form als Zeichenfolge zwischen doppelten Anführungszeichen geschehen.
char string[10] = "Zeichen";
Der Compiler hängt automatisch das Terminierungszeichen ans Ende des Strings. Wird bei der Initialisierung die Größe des Feldes nicht angegeben, so reserviert der Compiler gerade so viel Platz um den String mit Endzeichen aufzunehmen.
char string[] = "Zeichen";
erzeugt und initialisiert einen Vektor mit acht Elementen.

Behalten Sie im Auge, daß Strings den Nullcharacter als Terminierungszeichen benötigen. Da Strings aber Characterarrays sind, ist es natürlich auch möglich, den String direkt zu manipulieren. Wird dabei das Terminierungszeichen überschrieben, so kann das fatale Folgen nach sich ziehen. Alle C-Funktionen, die Strings bearbeiten, suchen nach diesem Zeichen bei der Bearbeitung des Strings. Ist es nicht vorhanden, geht die Bearbeitung auch über das durch die Definition festgelegte Ende hinaus, bis im Speicher ein Nullcharacter angetroffen wird.

Stringfunktionen

Manipulationen von Strings waren bisher nur durch den direkten Zugriff auf das Characterarray, in dem diese Zeichenketten abgespeichert sind, möglich. Die Definitionsdatei string.h enthält eine Reihe von Funktionen zur Bearbeitung von Zeichenketten.

Stringlänge

Um die aktuelle Länge eines Strings zu bestimmen, wird die Funktion strlen() verwendet. Die Funktionsdeklaration lautet:
size_t strlen(char *str);
Sie liefert als Ergebnis den Wert der Stringlänge, ohne das abschließende Terminierungszeichen (\0) mitzuzählen. size_t bezeichnet dabei eine Größe, die als unsigned definiert ist.
/* length.c
   Beispiel fuer die Feststellung der Laenge eines Strings.
 */
#include <stdio.h>
#include <string.h>

int main(void)
{
  char *message1 = "If anything can go wrong, it will.";
  char *message2 = "Es arbeitet besser, wenn man es einschaltet.";

  printf("\n\nDie Laenge des Strings: \"%s\"", message1);
  printf(" ist %d\n", strlen(message1));
  
  printf("\n\nDie Laenge des Strings: \"%s\"", message2);
  printf(" ist %d\n", strlen(message2));
  
  return 0;
}

Kopieren von Strings

Auf Grund der Art wie in C Strings gehandhabt werden, ist es nicht möglich, einen String auf einen anderen zuzuweisen, wie das in anderen Programmiersprachen gemacht werden kann. Die Zeichenkette muß von der Stelle des Quellstrings an die Stelle im Speicher, wo der Zielstring liegt, kopiert werden. Die Kopierfunktionen sind strcpy() und strncpy(). Die Funktion strcpy() kopiert den gesamten String an einen anderen Speicherplatz. Der Funktionsprototyp lautet:
char *strcpy(char *destination, char *source);
Die Funktion strcpy() kopiert den gesamten String (inklusive des abschließenden Nullzeichens \0), von der mit source angezeigten Stelle, an die Stelle, auf die mit destination gezeigt wird. Der notwendige Speicherplatz muß vorher reserviert worden sein. Die Funktion ist nicht in der Lage zu überprüfen, ob ausreichend Platz reserviert wurde. Ist kein Platz reserviert worden, so werden strlen(source) Bytes Speicher, anfangend mit destination , überschrieben. Der Rückgabewert der Funktion ist ein Zeiger auf den neuen String.

Die Funktion strncpy() ist zur Funktion strcpy() ähnlich, außer daß sie die Möglichkeit bietet, die Anzahl der zu kopierenden Zeichen anzugeben. Ihre Deklaration lautet

char *strncpy(char *destination, char *source, size_t n);
Die Argumente source und destination sind wieder Zeiger auf den Quell und Ziel String. Es werden maximal die ersten n Zeichen des Quellstrings auf den Zielstring kopiert. Ist der Quellstring kürzer als n Zeichen, so werden ausreichend viele Nullcharacter an das Ende des Quellstrings angehängt um auf n Zeichen für den Kopiervorgang zu kommen. Ist der Quellstring länger als n Zeichen, so wird keine abschließende \0 an das Ziel angefügt. Der Rückgabewert der Funktion ist ein Zeiger auf destination.
/* kopstr.c
   Zeigt die Verwendung von strcpy().
 */
 
#include <stdio.h>
#include <string.h>
   
char source[] = "Der Quell String.";
    
int main(void)
{
  char dest1[81];
  char *dest2, *dest3;
                
  printf("\nsource: %s", source );
                     
  /* Kopieren auf dest1 ist okay, da dest1 */
  /* auf 80 Byte allozierten Speicher zeigt. */
                               
  strcpy(dest1, source);
  printf("\ndest1:  %s", dest1);
                                         
  /* Um auf dest2 zu kopieren muss Speicher reserviert werden. */
                                              
  dest2 = (char *)malloc(strlen(source) +1);
  strcpy(dest2, source);
  printf("\ndest2:  %s", dest2);
                                                             
  /* Ein Kopiervorgang ohne Platzreservierung fuer das Ziel kann */
  /* zu schwerwiegenden Problemen fuehren. */
                                                                       
  /* strcpy(dest3, source); */
  return 0;
}
Um beim kopieren von Strings die Notwendigkeit der Platzreservierung für den Zielstring nicht beachten zu müssen, gibt es in vielen C-Dialekten die Funktion strdup(). Sie entspricht nicht dem ANSI Standard, ist aber zur Funktion strcpy() sehr ähnlich. Sie führt ihre eigene Speicherreservierung für den Zielstring mit einem Aufruf von malloc() durch. Der Prototyp von strndup() ist
char *strdup(char *source);
Das Argument source ist ein Zeiger auf den Quellstring. Die Funktion gibt einen Zeiger auf den kopierten String zurück - oder NULL, falls der notwendige Platz nicht reserviert werden konnte.

Aneinanderfügen von Strings

Neben dem Kopieren ist auch die Möglichkeit, Strings aneinanderzufügen, von Interesse. Diese Möglichkeit bieten die Funktionen strcat() und strncat(). Der Prototyp von strcat() ist
char *strcat(char *str1, char *str2);
Diese Funktion hängt eine Kopie von str2 an das Ende von str1, wobei das Terminierungszeichen an das Ende des neuen Strings geschoben wird. str1 muß genügend Platz aufweisen, um den Gesamtstring aufzunehmen. Der Rückgabewert der Funktion ist ein Zeiger auf str1.

Im Unterschied zu strcat() erlaubt die Funktion strncat() die Angabe der Anzahl der Zeichen, die aus dem Quellstring an den Zielstring angefügt werden. Die Deklaration ist:

char *strncat(char *str1, char *str2, size_t n);
Falls str2 mehr als n Zeichen enthält, werden die ersten n Zeichen an das Ende von str1 hinzugefügt. Hat str2 weniger als n Zeichen, wird der gesamte str2 an das Ende von str1 angeschlossen. Auf jeden Fall wird ein Nullzeichen angehängt. Die Speicherplatzreservierung ist auch hier Aufgabe des Programmierers. Der Rückgabewert dieser Funktion ist ebenfalls ein Zeiger auf str1.
/* concat.c
   Die strncat() Funktion.
 */

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

char str2[] = "abcdefghijklmnopqrstuvwxyz";

int main(void)
{
  char str1[27];
  int n;

  for (n=1; n < 27; n++)
  {
    strcpy(str1, "");
    strncat(str1, str2, n);
    puts(str1);
  }
  return 0;
}

Vergleich von Strings

Strings werden verglichen um festzustellen, ob sie gleich oder ungleich sind. Sind sie nicht gleich, kann ein String "größer" oder "kleiner" als der andere sein. Die Festlegung von "größer" und "kleiner" wird über den ASCII Code der Zeichen getroffen. Die Vergleichsfunktionen sind:
int strcmp(char *str1, char *str2);
und
int strncmp(char *str1, char *str2, size_t n);
Der Rückgabewert der Funktionen ist:
   
Rückgabewert     Bedeutung
< 0     str1 ist "kleiner" als str2
0 str1 ist gleich str2
> 0     str1 ist "größer" als str2

Die Funktion strncmp() vergleicht einen Teilstring, nämlich n Zeichen von str2 mit str1. Beide Funktionen unterscheiden bei ihrem Vergleich zwischen Großschreibung und Kleinschreibung.

/* comparst.c
   The strncmp() function.
 */

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

char str1[] = "Der String Nummer eins.";
char str2[] = "Der String Nummer zwei.";

int main(void)
{
  size_t n, x;

  puts(str1);
  puts(str2);

  while (1)
  {
    printf("\n\nGeben Sie die Zahl zu vergleichender Zeichen ein. ");
    printf("Ende mit 0.\n");
    scanf("%d", &n);

    if (n == 0)
      break;

    x = strncmp(str1, str2, n);

    printf("\nBeim Vergleich von %d Zeichen, liefert strncmp() %d.", n, x);
  }
  return 0;
}

Durchsuchen von Strings

Die C Bibliothek enthält eine Anzahl von Funktionen zum Durchsuchen von Strings. In der Suche wird festgestellt, ob und wo in einem String ein Zeichen oder ein anderer String vorkommt. Die drei wichtigsten Funktionen sind:
char *strchr(char *str, int ch);

char *strrchr(char *str, int ch);

char *strstr(char *str1, char *str2);
Die Funktionen strchr() und strrchr() durchsuchen einen String nach dem Vorkommen eines Zeichens ch, bis das abschließende Nullzeichen gefunden wird. Wird das Zeichen gefunden, wird ein Zeiger auf dieses Zeichen zurückgegeben. Wird das Zeichen nicht gefunden erfolgt die Rückgabe von NULL. strchr() unterscheidet sich von strrchr() dadurch, daß strchr() nach dem ersten Vorkommen von ch sucht, während strrchr() den String nach dem letzten Auftreten des Zeichens ch durchsucht.
/* strsrch.c
   Durchsuchen einer Zeichenkette nach einem einzelnen Zeichen 
   mit strchr().
 */
 
#include <stdio.h>
#include <string.h>
   
int main(void)
{
  char *loc, buf[81];
  int ch;
               
  /* Eingabe des Strings und des Zeichens. */
                    
  printf("\n\nGeben Sie den zu durchsuchen String ein:\n");
  gets(buf);
  printf("\nGeben Sie das zu suchende Zeichen ein: ");
  ch = getchar();
                                        
  /* Suche durchfuehren. */
                                             
  loc = strchr(buf, ch);
                                                  
  if ( loc == NULL )
    printf("\nDas Zeichen %c wurde nicht gefunden.\n", ch);
  else
    printf("\nDas Zeichen %c wurde an Position %d gefunden.\n", ch, loc-buf);
  getch();
  return 0;
}
Die Funktion strstr() sucht nicht nach einem einzelnen Zeichen, sondern nach dem Auftreten einer ganzen Zeichenkette. Die Funktion gibt ebenfalls einen Zeiger auf das erste Auftreten des Strings str2 innerhalb von str1 zurück. Bei keiner Übereinstimmung wird wieder NULL retourniert. Wird eine Übereinstimmung gefunden, kann der Offset von str2 innerhalb von str1 durch Zeiger- Subtraktion ermittelt werden. Bei der Feststellung einer Übereinstimmung wird auf Groß- und Klein- Schreibung geachtet.

Konversionsroutinen und Zeichen-Testfunktionen

Es kommt vor, daß die Umwandlung einer Zeichenketten, die eine Zahl darstellt, in eine Zahl mit dem entsprechenden Wert gewünscht wird. So kann z.B. der String "123" in eine Integer Variable mit dem Wert 123 umgewandelt werden. In <stdlib.h> gibt es drei Funktionen die einen String in eine Zahl umwandeln.
int atoi(char *ptr);

long atol(char *ptr);

double atof(char *ptr);
Alle Funktionen wandeln ASCII (a) Character in (to) Zahlen entsprechenden Typs (int, long und float (double)).

Eine Reihe von Funktionen isxxxxx() dienen zur Klassifikation und Umwandlung von Zeichen. Diese Funktionen sind in Wirklichkeit Makros definiert in <ctype.h>. Dabei werden Umlaute und nationale Zeichen nicht zu den Buchstaben gezählt. Die isxxxxx() Makros haben alle denselben Prototyp:

int isxxxxx(int ch);
wobei ch das zu testenden Zeichen ist. Der Rückgabewert der Funktion ist TRUE (nicht Null), falls die Bedingung zutrifft, oder FALSE (Null), falls nicht.

isalpha(c)liefert TRUE, falls c ein Buchstabe ist.
isupper(c)liefert TRUE, falls c ein Großbuchstabe ist.
islower(c)liefert TRUE, falls c ein Kleinbuchstabe ist.
isdigit(c)liefert TRUE, falls c eine Ziffer ist.
isalnum(c)liefert TRUE, falls isalpha(c) oder isdigit(c) TRUE liefert.
isspace(c)liefert TRUE, falls c ein Leerzeichen, Tabulator, Zeilentrenner,
Wagenrücklauf, Seitenvorschub oder Vertikal-Tabulator ist.

Für die Umwandlung von Zeichen existieren zwei Makros

int tolower(int c);

int toupper(int c);
die das Zeichen umgewandelt in Klein- und Groß- Buchstaben liefern.


Zeiger