Rheinwerk Computing :: C von A bis Z – 20.2 <ctype.h> – Zeichenklassifizierung und Umwandlung

20.2 <ctype.h> – Zeichenklassifizierung und Umwandlung

In der Headerdatei <ctype.h> befinden sich Funktionen, mit denen einzelne Zeichen überprüft oder umgewandelt werden können. Die Headerdatei <wchar.h> hingegen enthält die Deklarationen der Gegenstücke für Breitzeichen. In Tabelle 20.1 finden Sie die Syntax der einzelnen Funktionen und die Beschreibungen:

**Tabelle 20.1** Funktionen zur Zeichenklassifizierung und Zeichenumwandlung
Funktion in <ctype.h>	Funktion in <wctype.h>	Beschreibung
int isalnum(int c);	int iswalnum(wint_t wc);	Testet, ob ein Zeichen ein alphanumerisches Zeichen ist.
int isalpha(int c);	int iswalpha(wint_t wc);	Testet, ob ein Zeichen ein Buchstabe ist.
int iscntrl(int c);	int iswcntrl(wint_t wc);	Testet, ob ein Zeichen ein Steuerzeichen ist (z. B. (Strg) + (B)).
int isdigit(int c);	int iswdigit(wint_t wc);	Testet, ob ein Zeichen eine Dezimalziffer ist.
int isgraph(int c);	int iswgraph(wint_t wc);	Testet, ob ein Zeichen ein druckbares Zeichen ist.
int islower(int c);	int iswlower(wint_t wc);	Testet, ob ein Zeichen ein Kleinbuchstabe ist.
int isprint(int c);	int iswprint(wint_t wc);	Testet, ob ein Zeichen ein druckbares Zeichen ist, aber kein Leerzeichen.
int ispunct(int c);	int iswpunct(wint_t wc);	Testet, ob ein Zeichen ein Interpunktionszeichen ist.
int isspace(int c);	int iswspace(wint_t wc);	Testet, ob ein Zeichen ein Leerzeichen (Zwischenraumzeichen) ist.
int isupper(int c);	int iswupper(wint_t wc);	Testet, ob ein Zeichen ein Großbuchstabe ist.
int isxdigit(int c);	int iswxdigit( wint_t wc);	Testet, ob ein Zeichen eine hexadezimale Ziffer ist.
int isascii(int c);		Das Makro isascii prüft, ob das Zeichen c ein normiertes Zeichen des ASCII-Zeichensatzes ist (0–127). Wenn nicht, kann es mit toascii umgewandelt werden.
int isblank(int c);	int iswblank(wint_t wc);	Ist c ein Leerzeichen, wird 1 zurückgegeben, sonst 0 (nur bei ANSI-C99-Compilern vorhanden).
int tolower(int c);	int towlower(wint_t wc);	Wandelt Groß- in Kleinbuchstaben um.
int toupper(int c);	int towupper(wint_t wc);	Wandelt Klein- in Großbuchstaben um.
int toascii(int c);		toascii ist ein Makro, das den übergebenen Wert c (durch Löschen aller Bits außer den 7 niederwertigsten) auf den Bereich 0 bis 127 begrenzt und das Ergebnis dieser Operation zurückliefert. Dadurch werden aber nationale Zeichen wie etwa 'ä', 'ü', 'ö' ... falsch dargestellt.

Alle Funktionen in der Tabelle erwarten ein int- bzw. wint_t-Argument, dessen Wert als EOF (bzw. WEOF) oder unsigned char bzw. wchar_t darstellbar sein muss. Bei Erfolg geben diese Funktionen einen Wert ungleich 0 zurück. Tritt ein Fehler auf, ist der Rückgabewert immer 0.

Hinweis

Abgesehen von den Funktionen isdigit() und iswdigit() ist das Ergebnis abhängig von der Einstellung der lokalen Umgebung für die Kategorie LC_CTYPE. Diese Umgebung können Sie mit setlocale() abfragen und ändern (siehe Abschnitt 20.5, »<locale.h> – länderspezifische Eigenheiten«).

In der Headerdatei <wctype.h> sind außerdem noch zwei erweiterbare Funktionen vorhanden, um breite Zeichen zu überprüfen. Die Syntax dieser Funktionen lautet:

int iswctype(wint_t wc, wctype_t desc);
wctype_t wctype(const char *property);

Mit diesen Funktionen können Sie mindestens dieselben Tests wie in Tabelle 20.1 durchführen. Hierbei müssen Sie lediglich für property das Präfix isw weglassen. Somit ist eine Überprüfung für ein Breitzeichen wc gleichwertig mit den Tests im Kommentar dahinter:

iswctype(wc, wctype("alnum")) // iswalnum(wc)
iswctype(wc, wctype("alpha")) // iswalpha(wc)
iswctype(wc, wctype("blank")) // iswblank(wc)
iswctype(wc, wctype("cntrl")) // iswcntrl(wc)
iswctype(wc, wctype("digit")) // iswdigit(wc)
iswctype(wc, wctype("graph")) // iswgraph(wc)
iswctype(wc, wctype("lower")) // iswlower(wc)
iswctype(wc, wctype("print")) // iswprint(wc)
iswctype(wc, wctype("punct")) // iswpunct(wc)
iswctype(wc, wctype("space")) // iswspace(wc)
iswctype(wc, wctype("upper")) // iswupper(wc)
iswctype(wc, wctype("xdigit")) // iswxdigit(wc)

Der Vorteil dieser Implementierung liegt auf der Hand. Es ist ohne größeren Aufwand möglich, zusätzliche Strings für property zu definieren, die für bestimmte locale-spezifische Zeichen nötig sind.

So, wie es Funktionen für die Klassifizierung von breiten Zeichen gibt, existieren auch Funktionen für die Umwandlung von Breitzeichen. Die Syntax dieser Funktionen lautet:

wint_t towctrans(wint_t wc, wctrans_t desc);
wctrans_t wctrans(const char *property);

Hierbei können Sie für property die Strings tolower und toupper verwenden. Somit ist eine Umwandlung für ein Breitzeichen wc gleichwertig mit der Umwandlung im Kommentar dahinter:

towctrans(wc, wctrans("tolower")) // towlower(wc)
towctrans(wc, wctrans("toupper")) // towupper(wc)

Zur Demonstration der einzelnen Funktionen folgt jetzt ein Listing, das normale byte-orientierte Zeichen verwendet:

/* big_small.c */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>

/* Prototypen */
void grosschrift(char *, char *);
void kleinschrift(char *, char *);
void international(char *,char *);
void oeffne_dateien(char *, char *, FILE **, FILE **);

void grosschrift(char *arg2, char *arg3) {
   FILE *in,*out;
   int c;

   oeffne_dateien(arg2,arg3,&in,&out);
   while((c=getc(in)) != EOF) {
      if(islower(c))
         putc(toupper(c),out);
      else
         putc(c,out);
   }
}

void kleinschrift(char *arg2, char *arg3) {
   FILE *in,*out;
   int c;

   oeffne_dateien(arg2,arg3,&in,&out);
   while((c=getc(in)) != EOF) {
      if(isupper(c))
         putc(tolower(c),out);
      else
         putc(c,out);
   }
}

void international(char *arg2, char *arg3) {
   FILE *in,*out;
   int c;

   oeffne_dateien(arg2,arg3,&in,&out);
   while((c=getc(in)) != EOF) {
      if(isascii(c)==0)
         putc(toascii(c),out);
      else
         putc(c,out);
   }
}

void oeffne_dateien(char *quelle, char *ziel,
                    FILE **input, FILE **output) {
   if((*input=fopen(quelle,"r+")) == NULL) {
      printf("Fehler beim Oeffnen (Lesen) von %s\n", quelle);
      exit(EXIT_FAILURE);
   }
   if((*output=fopen(ziel,"w+")) == NULL) {
      printf("Fehler beim Oeffnen (Schreiben) von %s\n", ziel);
      exit(EXIT_FAILURE);
   }
}

int main(int argc, char *argv[]) {
   if(argc<4) {
      printf("Verwendung: "
      "Programmname -[Schalter] datei.txt Zieldatei.txt\n"
      "für -[Schalter] : -b (komplette Textdatei in Grossschrift)\n"
      "                  -s (komplette Textdatei in Kleinschrift)\n"
      "                  -i (nationale Zeichen zu ASCII-Zeichen\n");
         return EXIT_FAILURE;
   }
   if(strcmp(argv[1],"-b")==0)
      grosschrift(argv[2],argv[3]);
   else if(strcmp(argv[1],"-s")==0)
      kleinschrift(argv[2],argv[3]);
   else if(strcmp(argv[1],"-i")==0)
      international(argv[2],argv[3]);
   else {

      printf("Verwendung: "
      "Programmname -[Schalter] datei.txtZieldatei.txt\n"
      "für -[Schalter] : -b (komplette Textdatei in Grossschrift)\n"
      "                  -s (komplette Textdatei in Kleinschrift)\n"
      "                  -i (nationale Zeichen zu ASCII-Zeichen\n");
         return EXIT_SUCCESS;
   }
   return EXIT_SUCCESS;
}

Mit diesem Code können Sie bei einer Textdatei jeden Buchstaben in einen großen, einen kleinen oder ein ASCII-Zeichen umwandeln.

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.