525.txt ************************************************************************ * Edit v1.020 from 2022-12-19 to 2023-03-28 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 ======================================================================== >> 0BBH durch >> ersetzen, analog << 0ABH durch <<. 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) ------------------------------------------------------------------------ 0280 11.11 Strings/Zeichenketten (>>char<<-Array) ------------------------------------------------------------------------ 0283 11.11.1 Vom String zur Binaerzahl ------------------------------------------------------------------------ 0286 11.12 Einlesen von Strings ------------------------------------------------------------------------ 0288 11.13 Die Standard-Bibliothek ------------------------------------------------------------------------ 0289 11.13.1 >>strcat()<< – Strings aneinanderhaengen ------------------------------------------------------------------------ 0289 11.13.2 >>strchr()<< – ein Zeichen im String suchen ------------------------------------------------------------------------ 0290 11.13.3 >>strcmp()<< – Strings vergleichen ------------------------------------------------------------------------ 0291 11.13.4 >>strcpy()<< – einen String kopieren ------------------------------------------------------------------------ 0292 11.13.5 >>strcspn()<< – einen Teilstring ermitteln ------------------------------------------------------------------------ 0292 11.13.6 >>strlen()<< – Laenge eines Strings ermitteln ------------------------------------------------------------------------ 0293 11.13.7 >>strncat()<< – String mit n Zeichen aneinanderhaengen ------------------------------------------------------------------------ 0294 11.13.8 >>strncmp()<< – n Zeichen von zwei Strings miteinander vergleichen ------------------------------------------------------------------------ 0294 11.13.9 >>strncpy()<< – String mit n Zeichen kopieren ------------------------------------------------------------------------ 0296 11.13.10 >>strpbrk()<< – nach dem Auftreten bestimmter Zeichen suchen ------------------------------------------------------------------------ 0296 11.13.11 >>strrchr()<< – das letzte Auftreten eines bestimmten Zeichens im String suchen ------------------------------------------------------------------------ 0296 11.13.12 >>strspn()<< – das erste Auftreten eines Zeichens, das nicht vorkommt ------------------------------------------------------------------------ 0297 11.13.13 >>strstr()<< – einen String nach dem Auftreten eines Teilstrings durchsuchen ------------------------------------------------------------------------ 0297 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 ------------------------------------------------------------------------ 0552 16.26 Low-Level-Datei-I/O-Funktionen (nicht ANSI C) ------------------------------------------------------------------------ 0553 16.26.1 Datei oeffnen – >>open()<< ------------------------------------------------------------------------ 0559 16.26.2 Datei schlieszen – >>close()<< ------------------------------------------------------------------------ 0560 16.26.3 Datei erzeugen – >>creat()<< ------------------------------------------------------------------------ 0561 16.26.4 Schreiben und Lesen – >>write()<< und >>read()<< ------------------------------------------------------------------------ 0571 16.26.5 File-Deskriptor positionieren – >>lseek()<< ------------------------------------------------------------------------ 0572 16.26.6 File-Deskriptor von einem Stream – >>fileno()<< ------------------------------------------------------------------------ 0574 16.26.7 Stream von File-Deskriptor – >>fdopen()<< ------------------------------------------------------------------------ 0577 17 Attribute von Dateien und das Arbeiten mit Verzeichnissen (nicht ANSI C) ------------------------------------------------------------------------ 0577 17.1 Attribute einer Datei ermitteln – >>stat()<< ------------------------------------------------------------------------ 0578 17.1.1 >>stat()<< – >>st_mode<< ------------------------------------------------------------------------ Tabelle 17.2 Dateimodus (Dateyp erfragen) S_IFREG egulaere Datei S_IFDIR Verzeichnis 0583 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<< ------------------------------------------------------------------------ 601 17.3.2 In das Arbeitsverzeichnis wechseln – >>getcwd()<< ------------------------------------------------------------------------ 603 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. 869 23.2 Vorteile von CGIs in C ------------------------------------------------------------------------ 870 23.3 Andere Techniken der Webprogrammierung ------------------------------------------------------------------------ 871 23.4 Das dreistufige Webanwendungsdesign ------------------------------------------------------------------------ 871 23.4.1 Darstellungsschicht ------------------------------------------------------------------------ 872 23.4.2 Verarbeitungsschicht ------------------------------------------------------------------------ 872 23.4.3 Speicherschicht ------------------------------------------------------------------------ 873 23.5 Clientseitige Programmierung ------------------------------------------------------------------------ 873 23.5.1 JavaScript ------------------------------------------------------------------------ 873 23.5.2 Java-Applets ------------------------------------------------------------------------ 873 23.6 Serverseitige Programmierung ------------------------------------------------------------------------ 874 23.7 Der Webserver ------------------------------------------------------------------------ 874 23.7.1 Das Client/Server-Modell des Internets ------------------------------------------------------------------------ 875 23.7.2 Serverimplementierung ------------------------------------------------------------------------ 876 23.7.3 Hosting-Services ------------------------------------------------------------------------ 876 23.7.4 Schluesselfertige Loesung ------------------------------------------------------------------------ 875 23.7.5 Weitere Moeglichkeiten ------------------------------------------------------------------------ 877 23.7.6 Apache ------------------------------------------------------------------------ 886 1. time.exe, 2. time.exe -> time.cgi, 3. time.cgi -> cgi-bin, 4. chmod a+x time.cgi, 5. Webserver starten, 6. Im Webserver http://localhost/cgi-bin/time.cgi aufrufen. 887 Troubleshooting 888 23.8 Das HTTP-Protokoll ------------------------------------------------------------------------ 888 23.8.1 Web-Protokolle ------------------------------------------------------------------------ 888 23.8.2 Wozu dienen Protokolle? ------------------------------------------------------------------------ 889 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 ************************************************************