525.txt ************************************************************************ * Edit v1.010 from 2022-12-19 to 2022-12-20 by HSc * ************************************************************************ C von A bis Z Wolf, Juergen Rheinwerk Computing 2009, 3. aktualisierte und erweiterte Auflage plus CD "1411_c_von_a_bis" ISBN 978-3-8362-1411-7 Seite Auszug ======================================================================== 0023 Vorwort ------------------------------------------------------------------------ 0023 Vorwort zur 3. Auflage ------------------------------------------------------------------------ 0025 Vorwort des Gutachters ------------------------------------------------------------------------ Bin ich hier richtig? ------------------------------------------------------------------------ 0027 1 Einstieg in C ------------------------------------------------------------------------ 0027 1.1 UEbersicht zu C ------------------------------------------------------------------------ 0028 1.2 Der ANSI-C-Standard ------------------------------------------------------------------------ 0030 1.2.1 Welcher C-Standard wird in diesem Buch verwendet? ------------------------------------------------------------------------ 0031 1.2.2 Der Vorteil des ANSI-C-Standards ------------------------------------------------------------------------ 0031 1.3 Der POSIX-Standard ------------------------------------------------------------------------ 0032 1.4 Vor- und Nachteile der Programmiersprache C ------------------------------------------------------------------------ 0033 1.5 C in diesem Buch ------------------------------------------------------------------------ 0033 1.6 Was benoetige ich fuer C? ------------------------------------------------------------------------ 0033 1.6.1 Texteditor ------------------------------------------------------------------------ 0034 1.6.2 Compiler ------------------------------------------------------------------------ 0034 1.6.3 All-in-one – die Entwicklungsumgebung ------------------------------------------------------------------------ 0035 1.7 Welcher Compiler und welches Betriebssystem? ------------------------------------------------------------------------ 0037 2 Das erste Programm ------------------------------------------------------------------------ 0037 2.1 Der beste Lernerfolg ------------------------------------------------------------------------ 0037 2.2 »Hallo Welt« in C ------------------------------------------------------------------------ 0039 2.3 Analyse des Programms ------------------------------------------------------------------------ 0043 3 Grundlagen ------------------------------------------------------------------------ 0043 3.1 Zeichensaetze ------------------------------------------------------------------------ 0043 3.1.1 Basic-Zeichensatz ------------------------------------------------------------------------ 0044 3.1.2 Ausfuehrungszeichensatz (Steuerzeichen) ------------------------------------------------------------------------ 0046 3.1.3 Trigraph-Zeichen ------------------------------------------------------------------------ ... eine Kombination aus drei Schriftzeichen, die als Einheit behandelt werden. ... wurden 9 solcher Drei-Zeichen-Sequenzen verwendet, die alle mit ?? beginnen. 0047 Tabelle 3.2 Trigraph-Zeichen in ANSI-C ??- = ~ 0048 3.2 Symbole von C ------------------------------------------------------------------------ 0048 3.2.1 Bezeichner ------------------------------------------------------------------------ 0048 3.2.2 Schluesselwoerter ------------------------------------------------------------------------ 0048 3.2.3 Literale ------------------------------------------------------------------------ 0050 3.2.4 Einfache Begrenzer ------------------------------------------------------------------------ 0051 3.2.5 Kommentare ------------------------------------------------------------------------ 0055 4 Formatierte Ein-/Ausgabe mit »scanf()« und »printf()« ------------------------------------------------------------------------ 4.1 Formatierte Eingabe mit »scanf()« ------------------------------------------------------------------------ 4.1.1 Der Adressoperator ------------------------------------------------------------------------ 4.1.2 Probleme und deren Behandlung mit »scanf()« ------------------------------------------------------------------------ 4.1.3 UEberpruefen auf das richtige Format ------------------------------------------------------------------------ 4.1.4 Zusammenfassung zu »scanf()« ------------------------------------------------------------------------ 4.2 Formatierte Ausgabe mit »printf()« ------------------------------------------------------------------------ 5 Basisdatentypen ------------------------------------------------------------------------ 5.1 Deklaration und Definition ------------------------------------------------------------------------ 5.2 Der Datentyp »int« (Integer) ------------------------------------------------------------------------ 5.3 Variablen verwenden ------------------------------------------------------------------------ 5.4 Der Datentyp »long« ------------------------------------------------------------------------ 5.5 Der Datentyp »long long« ------------------------------------------------------------------------ 5.6 Der Datentyp »short« ------------------------------------------------------------------------ 5.7 Ganzzahlige Typen mit vorgegebener Breite – ------------------------------------------------------------------------ 5.7.1 (C99) ------------------------------------------------------------------------ 5.8 Die Gleitpunkttypen »float« und »double« ------------------------------------------------------------------------ 5.8.1 Gleitpunkttypen im Detail ------------------------------------------------------------------------ 5.8.2 »float« im Detail ------------------------------------------------------------------------ 5.8.3 »double« im Detail ------------------------------------------------------------------------ 5.8.4 long double ------------------------------------------------------------------------ 5.8.5 Einiges zu n-stelliger Genauigkeit ------------------------------------------------------------------------ 5.9 Numerische Gleitpunktprobleme ------------------------------------------------------------------------ 5.10 Komplexe Gleitpunkttypen – ------------------------------------------------------------------------ 5.11 Der Datentyp »char« ------------------------------------------------------------------------ 5.12 Nationale contra internationale Zeichensaetze ------------------------------------------------------------------------ 5.13 Der Breitzeichen-Typ »wchar_t« ------------------------------------------------------------------------ 5.14 Multibyte-Zeichen ------------------------------------------------------------------------ 5.15 Boolescher Wert – ------------------------------------------------------------------------ 5.16 Vorzeichenlos und vorzeichenbehaftet ------------------------------------------------------------------------ 5.17 Limits fuer Ganzzahl- und Gleitpunktdatentypen ------------------------------------------------------------------------ 5.18 Der Typ »void« ------------------------------------------------------------------------ 5.19 Konstanten ------------------------------------------------------------------------ 5.19.1 Ganzzahlkonstanten ------------------------------------------------------------------------ 5.19.2 Gleitpunktkonstanten ------------------------------------------------------------------------ 5.19.3 Zeichenkonstanten ------------------------------------------------------------------------ 5.19.4 Stringliterale (Stringkonstante) ------------------------------------------------------------------------ 5.20 Umwandlungsvorgaben fuer formatierte Ein-/Ausgabe ------------------------------------------------------------------------ 6 Operatoren ------------------------------------------------------------------------ 6.1 Exkurs zu Operatoren ------------------------------------------------------------------------ 6.2 Arithmetische Operatoren ------------------------------------------------------------------------ 6.2.1 Dividieren von Ganzzahlen ------------------------------------------------------------------------ 6.3 Erweiterte Darstellung arithmetischer Operatoren ------------------------------------------------------------------------ 6.4 Inkrement- und Dekrement-Operatoren ------------------------------------------------------------------------ 6.5 Bit-Operatoren ------------------------------------------------------------------------ 6.5.1 Bitweises UND ------------------------------------------------------------------------ 6.5.2 Bitweises ODER ------------------------------------------------------------------------ 6.5.3 Bitweises XOR ------------------------------------------------------------------------ 6.5.4 Bitweises Komplement ------------------------------------------------------------------------ 6.5.5 Linksverschiebung ------------------------------------------------------------------------ 6.5.6 Rechtsverschiebung ------------------------------------------------------------------------ 6.5.7 Rezept fuer Fortgeschrittene ------------------------------------------------------------------------ 6.6 Makros fuer logische Operatoren und Bit-Operatoren – ------------------------------------------------------------------------ 6.7 Der »sizeof«-Operator ------------------------------------------------------------------------ 6.7.1 C versus C++ ------------------------------------------------------------------------ 7 Typumwandlung ------------------------------------------------------------------------ 7.1 Implizite Datentypumwandlung ------------------------------------------------------------------------ 7.1.1 Implizites »char« nach »int« ------------------------------------------------------------------------ 7.1.2 Implizites »float« nach »double« ------------------------------------------------------------------------ 7.1.3 Implizite Umwandlung in einen komplexen Gleitpunkttyp ------------------------------------------------------------------------ 7.1.4 UEbliche arithmetische Datentypumwandlung ------------------------------------------------------------------------ 7.2 Explizite Datentypumwandlung mit dem »cast«–Operator ------------------------------------------------------------------------ 8 Kontrollstrukturen ------------------------------------------------------------------------ 8.1 Verzweigungen mit der »if«-Bedingung ------------------------------------------------------------------------ 8.1.1 Anweisungsblock ------------------------------------------------------------------------ 8.2 Die Verzweigung mit »else if« ------------------------------------------------------------------------ 8.3 Die Verzweigung mit »else« ------------------------------------------------------------------------ 8.4 Der !-Operator (logischer Operator) ------------------------------------------------------------------------ 8.5 Logisches UND (&&) – logisches ODER (||) ------------------------------------------------------------------------ 8.6 Der Bedingungsoperator »?:« ------------------------------------------------------------------------ 8.7 Fallunterscheidung: die »switch«-Verzweigung ------------------------------------------------------------------------ 8.7.1 default ------------------------------------------------------------------------ 8.8 Die »while«-Schleife ------------------------------------------------------------------------ 8.8.1 Endlosschleife (»while«) ------------------------------------------------------------------------ 8.8.2 Fehlervermeidung bei »while«-Schleifen ------------------------------------------------------------------------ 8.9 Die »do while«-Schleife ------------------------------------------------------------------------ 8.10 Die »for«-Schleife ------------------------------------------------------------------------ 8.10.1 Einsatzmoeglichkeiten der »for«-Schleife ------------------------------------------------------------------------ 8.11 Kontrollierte Spruenge ------------------------------------------------------------------------ 8.11.1 continue ------------------------------------------------------------------------ 8.11.2 break ------------------------------------------------------------------------ 8.12 Direkte Spruenge mit »goto« ------------------------------------------------------------------------ 8.13 Notationsstil ------------------------------------------------------------------------ 8.13.1 K&R-Stil ------------------------------------------------------------------------ 8.13.2 Whitesmith-Stil ------------------------------------------------------------------------ 8.13.3 Allman-Stil ------------------------------------------------------------------------ 8.13.4 GNU EMACS-Stil ------------------------------------------------------------------------ 8.13.5 Der Stil des Autors ;) (K&R-like) ------------------------------------------------------------------------ 9 Funktionen ------------------------------------------------------------------------ 9.1 Was sind Funktionen? ------------------------------------------------------------------------ 9.2 Wozu dienen Funktionen? ------------------------------------------------------------------------ 9.3 Definition von Funktionen ------------------------------------------------------------------------ 9.4 Funktionsaufruf ------------------------------------------------------------------------ 9.5 Funktionsdeklaration ------------------------------------------------------------------------ 9.6 Lokale Variablen ------------------------------------------------------------------------ 9.7 Globale Variablen ------------------------------------------------------------------------ 9.8 Statische Variablen ------------------------------------------------------------------------ 9.9 Schluesselwoerter fuer Variablen – Speicherklassen ------------------------------------------------------------------------ 9.9.1 auto ------------------------------------------------------------------------ 9.9.2 extern ------------------------------------------------------------------------ 9.9.3 register ------------------------------------------------------------------------ 9.9.4 static ------------------------------------------------------------------------ 9.10 Typ-Qualifizierer ------------------------------------------------------------------------ 9.10.1 volatile ------------------------------------------------------------------------ 9.10.2 const ------------------------------------------------------------------------ 9.11 Geltungsbereich von Variablen ------------------------------------------------------------------------ 9.12 Speicherklassen-Spezifizierer fuer Funktionen ------------------------------------------------------------------------ 9.12.1 extern ------------------------------------------------------------------------ 9.12.2 static ------------------------------------------------------------------------ 9.12.3 volatile ------------------------------------------------------------------------ 9.13 Datenaustausch zwischen Funktionen ------------------------------------------------------------------------ 9.14 Wertuebergabe an Funktionen (call-by-value) ------------------------------------------------------------------------ 9.15 Der Rueckgabewert von Funktionen ------------------------------------------------------------------------ 9.16 Die Hauptfunktion »main()« ------------------------------------------------------------------------ 9.17 Rueckgabewert beim Beenden eines Programms ------------------------------------------------------------------------ 9.17.1 Programmende auswerten ------------------------------------------------------------------------ 9.18 Funktionen der Laufzeitbibliothek ------------------------------------------------------------------------ 9.19 Getrenntes Kompilieren von Quelldateien ------------------------------------------------------------------------ 9.20 Rekursive Funktionen (Rekursion) ------------------------------------------------------------------------ 9.20.1 Exkurs: Stack ------------------------------------------------------------------------ 9.20.2 Rekursionen und der Stack ------------------------------------------------------------------------ 9.20.3 Fakultaet ------------------------------------------------------------------------ 9.20.4 Fibonacci-Zahlen ------------------------------------------------------------------------ 9.20.5 Groeszter gemeinsamer Teiler (GGT) ------------------------------------------------------------------------ 9.21 »inline«-Funktionen ------------------------------------------------------------------------ 10 Praeprozessor-Direktiven ------------------------------------------------------------------------ 10.1 Einkopieren von Dateien mittels »#include« ------------------------------------------------------------------------ 10.2 Makros und Konstanten – »#define« ------------------------------------------------------------------------ 10.2.1 Symbolische Konstanten mit »#define« ------------------------------------------------------------------------ 10.2.2 Makros mit »#define« ------------------------------------------------------------------------ 10.3 Bedingte Kompilierung ------------------------------------------------------------------------ 10.4 Vordefinierte Praeprozessor-Direktiven (ANSI C) ------------------------------------------------------------------------ 10.5 Ersetzung eines Makroparameters durch einen String ------------------------------------------------------------------------ 10.6 »#undef« – Makronamen wieder aufheben ------------------------------------------------------------------------ 10.7 Ausgeben von Fehlermeldungen – »#error« ------------------------------------------------------------------------ 10.8 »#pragma« ------------------------------------------------------------------------ 11 Arrays ------------------------------------------------------------------------ 11.1 Arrays deklarieren ------------------------------------------------------------------------ 11.2 Initialisierung und Zugriff auf Arrays ------------------------------------------------------------------------ 11.2.1 Gueltigkeitsbereich von Arrays ------------------------------------------------------------------------ 11.3 Arrays vergleichen ------------------------------------------------------------------------ 11.4 Anzahl der Elemente eines Arrays ermitteln ------------------------------------------------------------------------ 11.5 UEbergabe von Arrays an Funktionen ------------------------------------------------------------------------ 11.6 Arrays aus Funktionen zurueckgeben ------------------------------------------------------------------------ 11.7 Programmbeispiel zu den Arrays ------------------------------------------------------------------------ 11.8 Einlesen von Array-Werten ------------------------------------------------------------------------ 11.9 Mehrdimensionale Arrays ------------------------------------------------------------------------ 11.9.1 Mehrdimensionale Arrays initialisieren ------------------------------------------------------------------------ 11.9.2 UEbergabe von zwei- bzw. mehrdimensionalen Arrays an Funktionen ------------------------------------------------------------------------ 11.10 Arrays in Tabellenkalkulation einlesen (*.CSV–Dateien) ------------------------------------------------------------------------ 11.11 Strings/Zeichenketten (»char«-Array) ------------------------------------------------------------------------ 11.11.1 Vom String zur Binaerzahl ------------------------------------------------------------------------ 11.12 Einlesen von Strings ------------------------------------------------------------------------ 11.13 Die Standard-Bibliothek ------------------------------------------------------------------------ 11.13.1 »strcat()« – Strings aneinanderhaengen ------------------------------------------------------------------------ 11.13.2 »strchr()« – ein Zeichen im String suchen ------------------------------------------------------------------------ 11.13.3 »strcmp()« – Strings vergleichen ------------------------------------------------------------------------ 11.13.4 »strcpy()« – einen String kopieren ------------------------------------------------------------------------ 11.13.5 »strcspn()« – einen Teilstring ermitteln ------------------------------------------------------------------------ 11.13.6 »strlen()« – Laenge eines Strings ermitteln ------------------------------------------------------------------------ 11.13.7 »strncat()« – String mit n Zeichen aneinanderhaengen ------------------------------------------------------------------------ 11.13.8 »strncmp()« – n Zeichen von zwei Strings miteinander vergleichen ------------------------------------------------------------------------ 11.13.9 »strncpy()« – String mit n Zeichen kopieren ------------------------------------------------------------------------ 11.13.10 »strpbrk()« – nach dem Auftreten bestimmter Zeichen suchen ------------------------------------------------------------------------ 11.13.11 »strrchr()« – das letzte Auftreten eines bestimmten Zeichens im String suchen ------------------------------------------------------------------------ 11.13.12 »strspn()« – das erste Auftreten eines Zeichens, das nicht vorkommt ------------------------------------------------------------------------ 11.13.13 »strstr()« – einen String nach dem Auftreten eines Teilstrings durchsuchen ------------------------------------------------------------------------ 11.13.14 »strtok()« – einen String anhand bestimmter Zeichen zerlegen ------------------------------------------------------------------------ 12 Zeiger (Pointer) ------------------------------------------------------------------------ 12.1 Zeiger deklarieren ------------------------------------------------------------------------ 12.2 Zeiger initialisieren ------------------------------------------------------------------------ 12.2.1 Speichergroesze von Zeigern ------------------------------------------------------------------------ 12.3 Zeigerarithmetik ------------------------------------------------------------------------ 12.4 Zeiger, die auf andere Zeiger verweisen ------------------------------------------------------------------------ 12.4.1 Subtraktion zweier Zeiger ------------------------------------------------------------------------ 12.5 Typensicherung bei der Dereferenzierung ------------------------------------------------------------------------ 12.6 Zeiger als Funktionsparameter (call–by–reference) ------------------------------------------------------------------------ 12.6.1 Zeiger als Rueckgabewert ------------------------------------------------------------------------ 12.7 Array und Zeiger ------------------------------------------------------------------------ 12.8 Zeiger auf Strings ------------------------------------------------------------------------ 12.8.1 Zeiger auf konstante Objekte (Read-only-Zeiger) ------------------------------------------------------------------------ 12.9 Zeiger auf Zeiger und Stringtabellen ------------------------------------------------------------------------ 12.9.1 Stringtabellen ------------------------------------------------------------------------ 12.10 Zeiger auf Funktionen ------------------------------------------------------------------------ 12.11 void-Zeiger ------------------------------------------------------------------------ 12.12 AEquivalenz zwischen Zeigern und Arrays ------------------------------------------------------------------------ 12.13 Der »restrict«-Zeiger ------------------------------------------------------------------------ 13 Kommandozeilenargumente ------------------------------------------------------------------------ 13.1 Argumente an die Hauptfunktion uebergeben ------------------------------------------------------------------------ 13.2 Optionen (Schalter) aus der Kommandozeile auswerten ------------------------------------------------------------------------ 14 Dynamische Speicherverwaltung ------------------------------------------------------------------------ 14.1 Das Speicherkonzept ------------------------------------------------------------------------ 14.2 Speicherallokation mit »malloc()« ------------------------------------------------------------------------ 14.3 Das NULL-Mysterium ------------------------------------------------------------------------ 14.3.1 NULL fuer Fortgeschrittene ------------------------------------------------------------------------ 14.3.2 Was jetzt – NULL, 0 oder \0 ... ? ------------------------------------------------------------------------ 14.3.3 Zusammengefasst ------------------------------------------------------------------------ 14.4 Speicherreservierung und ihre Probleme ------------------------------------------------------------------------ 14.5 »free()« – Speicher wieder freigeben ------------------------------------------------------------------------ 14.6 Die Freispeicherverwaltung ------------------------------------------------------------------------ 14.6.1 Prozessinterne Freispeicherverwaltung ------------------------------------------------------------------------ 14.7 Dynamische Arrays ------------------------------------------------------------------------ 14.8 Speicher dynamisch reservieren mit »realloc()« und »calloc()« ------------------------------------------------------------------------ 14.9 Speicher vom Stack anfordern mit »alloca()« (nicht ANSI C) ------------------------------------------------------------------------ 14.10 »free()« – Speicher wieder freigeben ------------------------------------------------------------------------ 14.11 Zweidimensionale dynamische Arrays ------------------------------------------------------------------------ 14.12 Wenn die Speicherallokation fehlschlaegt ------------------------------------------------------------------------ 14.12.1 Speicheranforderung reduzieren ------------------------------------------------------------------------ 14.12.2 Speicheranforderungen aufteilen ------------------------------------------------------------------------ 14.12.3 Einen Puffer konstanter Groesze verwenden ------------------------------------------------------------------------ 14.12.4 Zwischenspeichern auf Festplatte vor der Allokation ------------------------------------------------------------------------ 14.12.5 Nur so viel Speicher anfordern wie noetig ------------------------------------------------------------------------ 15 Strukturen ------------------------------------------------------------------------ 15.1 Struktur deklarieren ------------------------------------------------------------------------ 15.2 Initialisierung und Zugriff auf Strukturen ------------------------------------------------------------------------ 15.3 Strukturen als Wertuebergabe an eine Funktion ------------------------------------------------------------------------ 15.4 Strukturen als Rueckgabewert einer Funktion ------------------------------------------------------------------------ 15.5 Strukturen vergleichen ------------------------------------------------------------------------ 15.6 Arrays von Strukturen ------------------------------------------------------------------------ 15.7 Strukturen in Strukturen (Nested Structures) ------------------------------------------------------------------------ 15.8 Kurze Zusammenfassung zu den Strukturen ------------------------------------------------------------------------ 15.9 Unions ------------------------------------------------------------------------ 15.10 Der Aufzaehlungstyp »enum« ------------------------------------------------------------------------ 15.11 Typendefinition mit »typedef« ------------------------------------------------------------------------ 15.12 Attribute von Strukturen veraendern (nicht ANSI C) ------------------------------------------------------------------------ 15.13 Bitfelder ------------------------------------------------------------------------ 15.14 Das »offsetof«-Makro ------------------------------------------------------------------------ 16 Ein-/Ausgabe-Funktionen ------------------------------------------------------------------------ 16.1 Was ist eine Datei? ------------------------------------------------------------------------ 16.2 Formatierte und unformatierte Ein-/Ausgabe ------------------------------------------------------------------------ 16.3 Standard-Streams ------------------------------------------------------------------------ 16.4 Hoehere Ein-/Ausgabe-Funktionen ------------------------------------------------------------------------ 16.5 Datei (Stream) oeffnen – »fopen« ------------------------------------------------------------------------ 16.5.1 Modus fuer »fopen()« ------------------------------------------------------------------------ 16.5.2 Maximale Anzahl geoeffneter Dateien – »FOPEN_MAX« ------------------------------------------------------------------------ 16.6 Zeichenweise lesen und schreiben – »getchar()« und »putchar()« ------------------------------------------------------------------------ 16.6.1 Ein etwas portableres »getch()« ------------------------------------------------------------------------ 16.7 Zeichenweise lesen und schreiben – »putc()«/»fputc()« und »getc()«/»fgetc()« ------------------------------------------------------------------------ 16.8 Datei (Stream) schlieszen – »fclose()« ------------------------------------------------------------------------ 16.9 Formatiertes Einlesen/Ausgeben von Streams mit »fprintf()« und »fscanf()« ------------------------------------------------------------------------ 16.10 Standard-Streams in C ------------------------------------------------------------------------ 16.10.1 Standard-Streams umleiten ------------------------------------------------------------------------ 16.11 Fehlerbehandlung von Streams – »feof()«, »ferror()« und »clearerr()« ------------------------------------------------------------------------ 16.12 Gelesenes Zeichen in die Eingabe zurueckschieben – »ungetc()« ------------------------------------------------------------------------ 16.13 (Tastatur-)Puffer leeren – »fflush()« ------------------------------------------------------------------------ 16.14 Stream positionieren – »fseek()«, »rewind()« und »ftell()« ------------------------------------------------------------------------ 16.15 Stream positionieren – »fsetpos()«, »fgetpos()« ------------------------------------------------------------------------ 16.16 Zeilenweise Ein-/Ausgabe von Streams ------------------------------------------------------------------------ 16.16.1 Zeilenweise lesen mit »gets()«/»fgets()« ------------------------------------------------------------------------ 16.16.2 Zeilenweise schreiben mit »puts()«/»fputs()« ------------------------------------------------------------------------ 16.16.3 Zeilenweise vom Stream einlesen mit »getline()« (nicht ANSI C) ------------------------------------------------------------------------ 16.16.4 Rezepte fuer zeilenweises Einlesen und Ausgeben ------------------------------------------------------------------------ 16.17 Blockweise lesen und schreiben – »fread()« und »fwrite()« ------------------------------------------------------------------------ 16.17.1 Blockweise lesen – »fread()« ------------------------------------------------------------------------ 16.17.2 Blockweise schreiben – »fwrite()« ------------------------------------------------------------------------ 16.17.3 Big Endian und Little Endian ------------------------------------------------------------------------ 16.18 Datei (Stream) erneut oeffnen – »freopen()« ------------------------------------------------------------------------ 16.19 Datei loeschen oder umbenennen – »remove()« und »rename()« ------------------------------------------------------------------------ 16.19.1 remove() ------------------------------------------------------------------------ 16.19.2 rename() ------------------------------------------------------------------------ 16.20 Pufferung einstellen – »setbuf()« und »setvbuf()« ------------------------------------------------------------------------ 16.20.1 Die Funktion »setbuf()« ------------------------------------------------------------------------ 16.20.2 Die Funktion »setvbuf()« ------------------------------------------------------------------------ 16.21 Temporaere Dateien erzeugen – »tmpfile()« und »tmpnam()« ------------------------------------------------------------------------ 16.21.1 »mkstemp()« – sichere Alternative fuer Linux/UNIX (nicht ANSI C) ------------------------------------------------------------------------ 16.22 Fehlerbehandlung ------------------------------------------------------------------------ 16.22.1 Fehlerausgabe mit »perror()« ------------------------------------------------------------------------ 16.22.2 Fehlerausgabe mit »strerror()« ------------------------------------------------------------------------ 16.23 Formatiert in einen String schreiben und formatiert aus einem String lesen – »sscanf()« und »printf)« ------------------------------------------------------------------------ 16.24 Byte- und wide-orientierter Stream ------------------------------------------------------------------------ 16.25 Ein fortgeschrittenes Thema ------------------------------------------------------------------------ 16.26 Low-Level-Datei-I/O-Funktionen (nicht ANSI C) ------------------------------------------------------------------------ 16.26.1 Datei oeffnen – »open()« ------------------------------------------------------------------------ 16.26.2 Datei schlieszen – »close()« ------------------------------------------------------------------------ 16.26.3 Datei erzeugen – »creat()« ------------------------------------------------------------------------ 16.26.4 Schreiben und Lesen – »write()« und »read()« ------------------------------------------------------------------------ 16.26.5 File-Deskriptor positionieren – »lseek()« ------------------------------------------------------------------------ 16.26.6 File-Deskriptor von einem Stream – »fileno()« ------------------------------------------------------------------------ 16.26.7 Stream von File-Deskriptor – »fdopen()« ------------------------------------------------------------------------ 17 Attribute von Dateien und das Arbeiten mit Verzeichnissen (nicht ANSI C) ------------------------------------------------------------------------ 17.1 Attribute einer Datei ermitteln – »stat()« ------------------------------------------------------------------------ 17.1.1 »stat()« – »st_mode« ------------------------------------------------------------------------ 17.1.2 »stat()« – »st_size« ------------------------------------------------------------------------ 585 17.1.3 »stat()« – »st_atime«, »st_mtime« und »st_ctime« ------------------------------------------------------------------------ 585 st_atime st_mtime st_ctime HSc: Datei-Attribute der 3 Zeiten. 17.1.4 »stat()« – »st_gid« und »st_uid« ------------------------------------------------------------------------ 17.1.5 »stat()« – »st_nlink«, »st_ino« ------------------------------------------------------------------------ 17.1.6 »stat()« – »st_dev«, »st_rdev« ------------------------------------------------------------------------ 17.2 Pruefen des Zugriffsrechts – »access()« ------------------------------------------------------------------------ 17.3 Verzeichnisfunktionen ------------------------------------------------------------------------ 17.3.1 Verzeichnis erstellen, loeschen und wechseln – »mkdir()«, »rmdir« und »chdir« ------------------------------------------------------------------------ 17.3.2 In das Arbeitsverzeichnis wechseln – »getcwd()« ------------------------------------------------------------------------ 17.3.3 Verzeichnisse oeffnen, lesen und schlieszen – »opendir()«, »readdir()« und »closedir()« ------------------------------------------------------------------------ 18 Arbeiten mit variabel langen Argumentlisten – ------------------------------------------------------------------------ 18.1 Makros in – »va_list«, »va_arg«, »va_start« und »va_end« ------------------------------------------------------------------------ 18.2 Die Argumentliste am Anfang oder Ende kennzeichnen ------------------------------------------------------------------------ 18.3 »vprintf()«, »vsprintf()«, »vfsprintf()« und »vsnsprintf()« ------------------------------------------------------------------------ 18.4 Variadic Makros – __VA_ARGS__ ------------------------------------------------------------------------ 19 Zeitroutinen ------------------------------------------------------------------------ 19.1 Die Headerdatei ------------------------------------------------------------------------ 19.1.1 Konstanten in der Headerdatei ------------------------------------------------------------------------ 19.1.2 Datums- und Zeitfunktionen in ------------------------------------------------------------------------ 19.2 Laufzeitmessung (Profiling) ------------------------------------------------------------------------ 20 Weitere Headerdateien und ihre Funktionen (ANSI C) ------------------------------------------------------------------------ 20.1 – Testmoeglichkeiten und Fehlersuche ------------------------------------------------------------------------ 20.2 – Zeichenklassifizierung und Umwandlung ------------------------------------------------------------------------ 20.3 Mathematische Funktionen – , und ------------------------------------------------------------------------ 20.3.1 Funktionen fuer reelle und komplexe Gleitpunkttypen ------------------------------------------------------------------------ 20.3.2 Funktionen nur fuer reelle Gleitpunkttypen ------------------------------------------------------------------------ 20.3.3 Funktionen nur fuer komplexe Gleitpunkttypen ------------------------------------------------------------------------ 20.3.4 Typengenerische Makros – ------------------------------------------------------------------------ 20.3.5 Gleitpunktwerte klassifizieren ------------------------------------------------------------------------ 20.3.6 Makro zum Vergleichen von reellen Zahlen ------------------------------------------------------------------------ 20.3.7 Zugriff auf die Gleitpunkt-Umgebung – ------------------------------------------------------------------------ 20.4 ------------------------------------------------------------------------ 20.4.1 Programmbeendigung – »exit()«, »_exit()«, »atexit()« und »abort()« ------------------------------------------------------------------------ 20.4.2 Strings in numerische Werte konvertieren ------------------------------------------------------------------------ 20.4.3 Bessere Alternative – Strings in numerische Werte konvertieren ------------------------------------------------------------------------ 20.4.4 Zufallszahlen ------------------------------------------------------------------------ 20.4.5 Absolutwerte, der Quotient und der Rest von Divisionen ------------------------------------------------------------------------ 20.4.6 Suchen und Sortieren – »qsort()« und »bsearch()« ------------------------------------------------------------------------ 20.4.7 system() ------------------------------------------------------------------------ 20.5 – laenderspezifische Eigenheiten ------------------------------------------------------------------------ 20.6 Nicht-lokale Spruenge – ------------------------------------------------------------------------ 20.7 ------------------------------------------------------------------------ 20.8 – die »mem?«-Funktionen zur Speichermanipulation ------------------------------------------------------------------------ 20.8.1 »memchr()« – Suche nach einzelnen Zeichen ------------------------------------------------------------------------ 20.8.2 »memcmp()« – bestimmte Anzahl von Bytes vergleichen ------------------------------------------------------------------------ 20.8.3 »memcpy()« – bestimmte Anzahl von Bytes kopieren ------------------------------------------------------------------------ 20.8.4 »memmove()« – bestimmte Anzahl von Bytes kopieren ------------------------------------------------------------------------ 20.8.5 »memset()« – Speicherbereich mit bestimmten Zeichen auffuellen ------------------------------------------------------------------------ 21 Dynamische Datenstrukturen ------------------------------------------------------------------------ 21.1 Lineare Listen (einfach verkettete Listen) ------------------------------------------------------------------------ 21.1.1 Erstes Element der Liste loeschen ------------------------------------------------------------------------ 21.1.2 Ein beliebiges Element in der Liste loeschen ------------------------------------------------------------------------ 21.1.3 Elemente der Liste ausgeben ------------------------------------------------------------------------ 21.1.4 Eine vollstaendige Liste auf einmal loeschen ------------------------------------------------------------------------ 21.1.5 Element in die Liste einfuegen ------------------------------------------------------------------------ 717 21.2 Doppelt verkettete Listen ------------------------------------------------------------------------ 21.3 Stacks nach dem LIFO-(Last-in-First-out-)Prinzip ------------------------------------------------------------------------ 21.4 Queues nach dem FIFO-Prinzip ------------------------------------------------------------------------ 21.5 Dynamisches Array mit flexiblen Elementen ------------------------------------------------------------------------ 22 Algorithmen ------------------------------------------------------------------------ 22.1 Was sind Algorithmen? ------------------------------------------------------------------------ 22.2 Wie setze ich Algorithmen ein? ------------------------------------------------------------------------ 22.3 Sortieralgorithmen ------------------------------------------------------------------------ 22.3.1 »Selection Sort« – sortieren durch Auswaehlen ------------------------------------------------------------------------ 22.3.2 Insertion Sort ------------------------------------------------------------------------ 22.3.3 Bubble Sort ------------------------------------------------------------------------ 22.3.4 Shellsort ------------------------------------------------------------------------ 22.3.5 Quicksort ------------------------------------------------------------------------ 22.3.6 qsort() ------------------------------------------------------------------------ 22.3.7 Zusammenfassung der Sortieralgorithmen ------------------------------------------------------------------------ 22.4 Suchalgorithmen – Grundlage zur Suche ------------------------------------------------------------------------ 22.4.1 Lineare Suche ------------------------------------------------------------------------ 22.4.2 Binaere Suche ------------------------------------------------------------------------ 22.4.3 Binaere (Such-)Baeume ------------------------------------------------------------------------ 22.4.4 Elemente im binaeren Baum einordnen ------------------------------------------------------------------------ 22.4.5 Binaere Baeume traversieren ------------------------------------------------------------------------ 22.4.6 Loeschen eines Elements im binaeren Baum ------------------------------------------------------------------------ 22.4.7 Ein binaerer Suchbaum in der Praxis ------------------------------------------------------------------------ 22.4.8 Binaere Suchbaeume mit Eltern-Zeiger und Threads ------------------------------------------------------------------------ 22.4.9 Ausgeglichene Binaerbaeume ------------------------------------------------------------------------ 22.4.10 Algorithmen fuer ausgeglichene Baeume – eine UEbersicht ------------------------------------------------------------------------ 22.5 Hashing (Zerhacken) ------------------------------------------------------------------------ 22.5.1 Wann wird Hashing verwendet? ------------------------------------------------------------------------ 22.5.2 Was ist fuer das Hashing erforderlich? ------------------------------------------------------------------------ 22.5.3 Hash-Funktion ------------------------------------------------------------------------ 22.5.4 Hashing mit direkter Adressierung ------------------------------------------------------------------------ 22.5.5 Vergleich von Hashing mit binaeren Baeumen ------------------------------------------------------------------------ 22.6 String-Matching ------------------------------------------------------------------------ 22.6.1 Brute-Force-Algorithmus ------------------------------------------------------------------------ 22.6.2 Der Algorithmus von Knuth/Morris/Pratt (KMP) ------------------------------------------------------------------------ 22.6.3 Weitere String-Matching-Algorithmen ------------------------------------------------------------------------ 22.7 Pattern Matching (regulaere Ausdruecke) ------------------------------------------------------------------------ 22.8 Backtracking ------------------------------------------------------------------------ 22.8.1 Der Weg durch den Irrgarten ------------------------------------------------------------------------ 22.8.2 Das 8-Dame-Problem ------------------------------------------------------------------------ 869 23 CGI mit C ------------------------------------------------------------------------ 869 23.1 Was ist CGI? ------------------------------------------------------------------------ CGI (Common Gateway Interface) ist eine Schnittstelle, mit der Sie z.B. Anwendungen fuer das Internet schreiben koennen. Die Daten werden normal ueber die Standard-Eingabe (stdin) oder von der Umgebungsvariable empfangen und wenn noetig ueber die Standardausgabe (stdout) ausgegeben. 23.2 Vorteile von CGIs in C ------------------------------------------------------------------------ 23.3 Andere Techniken der Webprogrammierung ------------------------------------------------------------------------ 23.4 Das dreistufige Webanwendungsdesign ------------------------------------------------------------------------ 23.4.1 Darstellungsschicht ------------------------------------------------------------------------ 23.4.2 Verarbeitungsschicht ------------------------------------------------------------------------ 23.4.3 Speicherschicht ------------------------------------------------------------------------ 23.5 Clientseitige Programmierung ------------------------------------------------------------------------ 23.5.1 JavaScript ------------------------------------------------------------------------ 23.5.2 Java-Applets ------------------------------------------------------------------------ 23.6 Serverseitige Programmierung ------------------------------------------------------------------------ 23.7 Der Webserver ------------------------------------------------------------------------ 23.7.1 Das Client/Server-Modell des Internets ------------------------------------------------------------------------ 23.7.2 Serverimplementierung ------------------------------------------------------------------------ 23.7.3 Hosting-Services ------------------------------------------------------------------------ 23.7.4 Schluesselfertige Loesung ------------------------------------------------------------------------ 23.7.5 Weitere Moeglichkeiten ------------------------------------------------------------------------ 23.7.6 Apache ------------------------------------------------------------------------ 23.8 Das HTTP-Protokoll ------------------------------------------------------------------------ 23.8.1 Web-Protokolle ------------------------------------------------------------------------ 23.8.2 Wozu dienen Protokolle? ------------------------------------------------------------------------ 23.8.3 Was ist ein Protokoll? ------------------------------------------------------------------------ 23.8.4 Normen fuer die Netzwerktechnik ------------------------------------------------------------------------ 23.8.5 Das OSI-Schichtenmodell ------------------------------------------------------------------------ 23.8.6 Die Elemente einer URL ------------------------------------------------------------------------ 23.8.7 Client-Anfrage – HTTP-Request (Browser-Request) ------------------------------------------------------------------------ 23.8.8 Serverantwort (Server-Response) ------------------------------------------------------------------------ 23.8.9 Zusammenfassung ------------------------------------------------------------------------ 23.9 Das Common Gateway Interface (CGI) ------------------------------------------------------------------------ 23.9.1 Filehandles ------------------------------------------------------------------------ 23.9.2 CGI-Umgebungsvariablen ------------------------------------------------------------------------ 23.9.3 CGI-Ausgabe ------------------------------------------------------------------------ 23.10 HTML-Formulare ------------------------------------------------------------------------ 23.10.1 Die Tags und ihre Bedeutung ------------------------------------------------------------------------ 23.11 CGI-Eingabe ------------------------------------------------------------------------ 23.11.1 Die Anfrage des Clients an den Server ------------------------------------------------------------------------ 23.11.2 Eingabe parsen ------------------------------------------------------------------------ 23.12 Ein Gaestebuch ------------------------------------------------------------------------ 23.12.1 Das HTML-Formular (»guestbook.html«) ------------------------------------------------------------------------ 23.12.2 Das CGI-Programm (»auswert.cgi«) ------------------------------------------------------------------------ 23.12.3 Das HTML-Gaestebuch (»gaeste.html«) ------------------------------------------------------------------------ 23.13 Ausblick ------------------------------------------------------------------------ 24 MySQL und C ------------------------------------------------------------------------ 24.1 Aufbau eines Datenbanksystems ------------------------------------------------------------------------ 24.1.1 Warum wurde ein Datenbanksystem (DBS) entwickelt? ------------------------------------------------------------------------ 24.1.2 Das Datenbank-Management-System (DBMS) ------------------------------------------------------------------------ 24.1.3 Relationale Datenbank ------------------------------------------------------------------------ 24.1.4 Eigene Clients mit C fuer SQL mithilfe der ODBC-API entwickeln ------------------------------------------------------------------------ 24.2 MySQL installieren ------------------------------------------------------------------------ 24.2.1 Linux ------------------------------------------------------------------------ 24.2.2 Den Client »mysql« starten ------------------------------------------------------------------------ 24.3 Crashkurs (My)SQL ------------------------------------------------------------------------ 24.3.1 Was ist SQL? ------------------------------------------------------------------------ 24.3.2 Die Datentypen von (My)SQL ------------------------------------------------------------------------ 24.3.3 Eine Datenbank erzeugen ------------------------------------------------------------------------ 24.3.4 Eine Datenbank loeschen ------------------------------------------------------------------------ 24.3.5 Datenbank wechseln ------------------------------------------------------------------------ 24.3.6 Eine Tabelle erstellen ------------------------------------------------------------------------ 24.3.7 Die Tabelle anzeigen ------------------------------------------------------------------------ 24.3.8 Tabellendefinition ueberpruefen ------------------------------------------------------------------------ 24.3.9 Tabelle loeschen ------------------------------------------------------------------------ 24.3.10 Struktur einer Tabelle aendern ------------------------------------------------------------------------ 24.3.11 Datensaetze eingeben ------------------------------------------------------------------------ 24.3.12 Datensaetze auswaehlen ------------------------------------------------------------------------ 24.3.13 Ein fortgeschrittenes Szenario ------------------------------------------------------------------------ 24.3.14 Datensatz loeschen ------------------------------------------------------------------------ 24.3.15 Datensatz aendern ------------------------------------------------------------------------ 24.3.16 Zugriffsrechte in MySQL ------------------------------------------------------------------------ 24.3.17 UEbersicht ueber einige SQL-Kommandos ------------------------------------------------------------------------ 24.4 Die MySQL-C-API ------------------------------------------------------------------------ 24.4.1 Grundlagen zur Programmierung eines MySQL-Clients ------------------------------------------------------------------------ 24.4.2 Client-Programm mit dem gcc unter Linux und dem Cygwin–gcc-Compiler unter Windows ------------------------------------------------------------------------ 24.4.3 MySQL Client-Programme mit dem VC++ Compiler und dem Borland Freeware Compiler ------------------------------------------------------------------------ 24.4.4 Troubleshooting ------------------------------------------------------------------------ 24.4.5 Das erste Client-Programm – Verbindung mit dem MySQL-Server herstellen ------------------------------------------------------------------------ 24.4.6 MySQL-Kommandozeilen-Optionen ------------------------------------------------------------------------ 24.4.7 Anfrage an den Server ------------------------------------------------------------------------ 24.5 MySQL und C mit CGI ------------------------------------------------------------------------ 24.5.1 HTML-Eingabeformular ------------------------------------------------------------------------ 24.5.2 Die CGI-Anwendung »add_db.cgi« ------------------------------------------------------------------------ 24.5.3 Die CGI-Anwendung »search_db.cgi« ------------------------------------------------------------------------ 24.6 Funktionsuebersicht ------------------------------------------------------------------------ 24.7 Datentypenuebersicht der C-API ------------------------------------------------------------------------ 25 Netzwerkprogrammierung und Cross–Plattform-Entwicklung ------------------------------------------------------------------------ 25.1 Begriffe zur Netzwerktechnik ------------------------------------------------------------------------ 25.1.1 IP-Nummern ------------------------------------------------------------------------ 25.1.2 Portnummer ------------------------------------------------------------------------ 25.1.3 Host- und Domainname ------------------------------------------------------------------------ 25.1.4 Nameserver ------------------------------------------------------------------------ 25.1.5 Das IP-Protokoll ------------------------------------------------------------------------ 25.1.6 TCP und UDP ------------------------------------------------------------------------ 25.1.7 Was sind Sockets? ------------------------------------------------------------------------ 25.2 Headerdateien zur Socketprogrammierung ------------------------------------------------------------------------ 25.2.1 Linux/UNIX ------------------------------------------------------------------------ 25.2.2 Windows ------------------------------------------------------------------------ 25.3 Client/Server-Prinzip ------------------------------------------------------------------------ 25.3.1 Loopback-Interface ------------------------------------------------------------------------ 25.4 Erstellen einer Client-Anwendung ------------------------------------------------------------------------ 25.4.1 »socket()« – Erzeugen eines Kommunikationsendpunktes ------------------------------------------------------------------------ 25.4.2 »connect()« – ein Client stellt eine Verbindung zum Server her ------------------------------------------------------------------------ 25.4.3 Senden und Empfangen von Daten ------------------------------------------------------------------------ 25.4.4 »close()« und »closesocket()« ------------------------------------------------------------------------ 25.5 Erstellen einer Server-Anwendung ------------------------------------------------------------------------ 25.5.1 »bind()« – Festlegen einer Adresse aus dem Namensraum ------------------------------------------------------------------------ 25.5.2 »listen()« – Warteschlange fuer eingehende Verbindungen einrichten ------------------------------------------------------------------------ 25.5.3 »accept()« und die Serverhauptschleife ------------------------------------------------------------------------ 25.6 (Cross-Plattform-)TCP-Echo-Server ------------------------------------------------------------------------ 25.6.1 Der Client ------------------------------------------------------------------------ 25.6.2 Der Server ------------------------------------------------------------------------ 25.7 Cross-Plattform-Development ------------------------------------------------------------------------ 25.7.1 Abstraction Layer ------------------------------------------------------------------------ 25.7.2 Headerdatei fuer Linux/UNIX ------------------------------------------------------------------------ 25.7.3 Linux/UNIX-Quellcodedatei ------------------------------------------------------------------------ 25.7.4 Headerdatei fuer MS-Windows ------------------------------------------------------------------------ 25.7.5 Windows-Quellcodedatei ------------------------------------------------------------------------ 25.7.6 All together – die »main«-Funktionen ------------------------------------------------------------------------ 25.7.7 Ein UDP-Beispiel ------------------------------------------------------------------------ 25.7.8 Mehrere Clients gleichzeitig behandeln ------------------------------------------------------------------------ 25.8 Weitere Anmerkungen zur Netzwerkprogrammierung ------------------------------------------------------------------------ 25.8.1 Das Datenformat ------------------------------------------------------------------------ 25.8.2 Der Puffer ------------------------------------------------------------------------ 25.8.3 Portabilitaet ------------------------------------------------------------------------ 25.8.4 Von IPv4 nach IPv6 ------------------------------------------------------------------------ 25.8.5 RFC-Dokumente (Request for Comments) ------------------------------------------------------------------------ 25.8.6 Sicherheit ------------------------------------------------------------------------ 26 Paralleles Rechnen ------------------------------------------------------------------------ 26.1 Parallelitaet ------------------------------------------------------------------------ 26.1.1 Single-Prozessorsysteme ------------------------------------------------------------------------ 26.1.2 Hyperthreading ------------------------------------------------------------------------ 26.2 Programmiertechniken der Parallelisierung ------------------------------------------------------------------------ 26.2.1 Automatische Parallelisierung ------------------------------------------------------------------------ 26.2.2 Halbautomatische Parallelisierung ------------------------------------------------------------------------ 26.2.3 Echte Parallelisierung ------------------------------------------------------------------------ 26.3 Vom Prozess zum Thread ------------------------------------------------------------------------ 26.4 Mit den POSIX-Threads programmieren ------------------------------------------------------------------------ 26.4.1 Ein serielles Beispiel ------------------------------------------------------------------------ 26.4.2 Das Grundgeruest fuer ein Programm mit mehreren Threads ------------------------------------------------------------------------ 26.4.3 Zusammenfassung ------------------------------------------------------------------------ 27 Sicheres Programmieren ------------------------------------------------------------------------ 27.1 Buffer-Overflow (Speicherueberlauf) ------------------------------------------------------------------------ 27.1.1 Speicherverwaltung von Programmen ------------------------------------------------------------------------ 27.1.2 Der Stack-Frame ------------------------------------------------------------------------ 27.1.3 Ruecksprungadresse manipulieren ------------------------------------------------------------------------ 27.1.4 Gegenmasznahmen zum Buffer-Overflow waehrend der Programmerstellung ------------------------------------------------------------------------ 27.1.5 Gegenmasznahmen zum Buffer-Overflow, wenn das Programm fertig ist ------------------------------------------------------------------------ 27.1.6 Programme und Tools zum Buffer-Overflow ------------------------------------------------------------------------ 27.1.7 Ausblick ------------------------------------------------------------------------ 27.2 Memory Leaks (Speicherlecks) ------------------------------------------------------------------------ 27.2.1 Bibliotheken und Tools zu Memory Leaks ------------------------------------------------------------------------ 27.3 Tipps zu Sicherheitsproblemen ------------------------------------------------------------------------ 1113 28 Wie geht’s jetzt weiter? ------------------------------------------------------------------------ 1114 28.1 GUI-Programmierung – grafische Oberflaechen ------------------------------------------------------------------------ 1114 28.1.1 Low-Level-Grafikprogrammierung ------------------------------------------------------------------------ 1115 28.1.2 High-Level-Grafikprogrammierung ------------------------------------------------------------------------ 1116 28.1.3 Multimedia-Grafikprogrammierung ------------------------------------------------------------------------ A Operatoren ------------------------------------------------------------------------ A.1 Rangfolge der Operatoren ------------------------------------------------------------------------ A.2 ASCII-Code-Tabelle ------------------------------------------------------------------------ A.3 Reservierte Schluesselwoerter in C ------------------------------------------------------------------------ A.4 Standard-Headerdateien der ANSI-C-Bibliothek ------------------------------------------------------------------------ A.5 Weiterfuehrende Links ------------------------------------------------------------------------ B Die C-Standard-Bibliothek ------------------------------------------------------------------------ B.1 ------------------------------------------------------------------------ B.2 (C99) ------------------------------------------------------------------------ B.3 ------------------------------------------------------------------------ B.4 ------------------------------------------------------------------------ B.5 (C99) ------------------------------------------------------------------------ B.6 ------------------------------------------------------------------------ B.7 (C99) ------------------------------------------------------------------------ B.8 (NA1) ------------------------------------------------------------------------ B.9 ------------------------------------------------------------------------ B.10 ------------------------------------------------------------------------ B.11 ------------------------------------------------------------------------ B.12 ------------------------------------------------------------------------ B.13 ------------------------------------------------------------------------ B.14 ------------------------------------------------------------------------ B.15 (C99) ------------------------------------------------------------------------ B.16 ------------------------------------------------------------------------ B.17 (C99) ------------------------------------------------------------------------ B.18 ------------------------------------------------------------------------ B.19 ------------------------------------------------------------------------ B.20 ------------------------------------------------------------------------ B.21 (C99) ------------------------------------------------------------------------ B.22 ------------------------------------------------------------------------ B.23 (NA1) ------------------------------------------------------------------------ B.24 (NA1) ------------------------------------------------------------------------ Abkuerzungen ======================================================================== PM = ProjektManager ******* EOF ************************************************************