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 20 Weitere Headerdateien und ihre Funktionen (ANSI C)
Pfeil 20.1 <assert.h> – Testmöglichkeiten und Fehlersuche
Pfeil 20.2 <ctype.h> – Zeichenklassifizierung und Umwandlung
Pfeil 20.3 Mathematische Funktionen – <math.h>, <tgmath.h> und <complex.h>
Pfeil 20.3.1 Funktionen für reelle und komplexe Gleitpunkttypen
Pfeil 20.3.2 Funktionen nur für reelle Gleitpunkttypen
Pfeil 20.3.3 Funktionen nur für komplexe Gleitpunkttypen
Pfeil 20.3.4 Typengenerische Makros – <tgmath.h>
Pfeil 20.3.5 Gleitpunktwerte klassifizieren
Pfeil 20.3.6 Makro zum Vergleichen von reellen Zahlen
Pfeil 20.3.7 Zugriff auf die Gleitpunkt-Umgebung – <fenv.h>
Pfeil 20.4 <stdlib.h>
Pfeil 20.4.1 Programmbeendigung – »exit()«, »_exit()«, »atexit()« und »abort()«
Pfeil 20.4.2 Strings in numerische Werte konvertieren
Pfeil 20.4.3 Bessere Alternative – Strings in numerische Werte konvertieren
Pfeil 20.4.4 Zufallszahlen
Pfeil 20.4.5 Absolutwerte, der Quotient und der Rest von Divisionen
Pfeil 20.4.6 Suchen und Sortieren – »qsort()« und »bsearch()«
Pfeil 20.4.7 system()
Pfeil 20.5 <locale.h> – länderspezifische Eigenheiten
Pfeil 20.6 Nicht-lokale Sprünge – <setjmp.h>
Pfeil 20.7 <signal.h>
Pfeil 20.8 <string.h> – die »mem…«-Funktionen zur Speichermanipulation
Pfeil 20.8.1 »memchr()« – Suche nach einzelnen Zeichen
Pfeil 20.8.2 »memcmp()« – bestimmte Anzahl von Bytes vergleichen
Pfeil 20.8.3 »memcpy()« – bestimmte Anzahl von Bytes kopieren
Pfeil 20.8.4 »memmove()« – bestimmte Anzahl von Bytes kopieren
Pfeil 20.8.5 »memset()« – Speicherbereich mit bestimmten Zeichen auffüllen


Galileo Computing - Zum Seitenanfang

20.2 <ctype.h> – Zeichenklassifizierung und Umwandlung topZur vorigen Überschrift

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.



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