Galileo Computing < openbook > Galileo Computing - Professionelle Bücher. Auch für Einsteiger.
Professionelle Bücher. Auch für Einsteiger.

Inhaltsverzeichnis
Vorwort
Vorwort des Gutachters
1 Einstieg in C
2 Das erste Programm
3 Grundlagen
4 Formatierte Ein-/Ausgabe mit »scanf()« und »printf()«
5 Basisdatentypen
6 Operatoren
7 Typumwandlung
8 Kontrollstrukturen
9 Funktionen
10 Präprozessor-Direktiven
11 Arrays
12 Zeiger (Pointer)
13 Kommandozeilenargumente
14 Dynamische Speicherverwaltung
15 Strukturen
16 Ein-/Ausgabe-Funktionen
17 Attribute von Dateien und das Arbeiten mit Verzeichnissen (nicht ANSI C)
18 Arbeiten mit variabel langen Argumentlisten – <stdarg.h>
19 Zeitroutinen
20 Weitere Headerdateien und ihre Funktionen (ANSI C)
21 Dynamische Datenstrukturen
22 Algorithmen
23 CGI mit C
24 MySQL und C
25 Netzwerkprogrammierung und Cross–Plattform-Entwicklung
26 Paralleles Rechnen
27 Sicheres Programmieren
28 Wie geht’s jetzt weiter?
A Operatoren
B Die C-Standard-Bibliothek
Stichwort

Download:
- ZIP, ca. 10,3 MB
Buch bestellen
Ihre Meinung?

Spacer
C von A bis Z von Jürgen Wolf
Das umfassende Handbuch
Buch: C von A bis Z

C von A bis Z
3., aktualisierte und erweiterte Auflage, geb., mit CD und Referenzkarte
1.190 S., 39,90 Euro
Galileo Computing
ISBN 978-3-8362-1411-7
Hier bekommen Sie C-Wissen pur. Egal, ob Sie gerade anfangen, C zu lernen oder ein kompetentes Nachschlagewerk für Fragen rund um C benötigen, mit diesem Buch sind Sie bestens beraten.

Ausführlich werden die Grundlagen von C dargestellt, angefangen von den elementaren Datentypen bis hin zu Arrays, Zeigern und dynamischer Speicherverwaltung. Auch fortgeschrittene Themen wie das Programmieren von Webanwendungen mit der CGI-Schnittstelle und eigenen Datenbank-Clients mit der C-API von MySQL, Netzwerk- und Cross-Plattform-Entwicklung kommen nicht zu kurz. Die Website zum Buch (www.pronix.de) bietet ein Forum und jede Menge zusätzliches Know-how.

Nutzen Sie die HTML-Version (inkl. Syntax-Highlighting) zum Reinschnuppern oder als immer verfügbare Ergänzung zu Ihrem Buch.

Auf unserer Katalogseite steht Ihnen ab sofort zusätzlich eine Volltextsuche im Buch zur Verfügung.

Die gedruckte Version des Buches erhalten Sie in unserem Online-Shop - versandkostenfrei innerhalb Deutschlands und Österreichs.
Zum Online-Shop

Inhaltsverzeichnis

Vorwort

Vorwort zur 3. Auflage

Galileo Computing

Vorwort des Gutachters

Bin ich hier richtig?

Galileo Computing

1 Einstieg in C

1.1 Übersicht zu C

1.2 Der ANSI-C-Standard

1.2.1 Welcher C-Standard wird in diesem Buch verwendet?
1.2.2 Der Vorteil des ANSI-C-Standards

1.3 Der POSIX-Standard

1.4 Vor- und Nachteile der Programmiersprache C

1.5 C in diesem Buch

1.6 Was benötige ich für C?

1.6.1 Texteditor
1.6.2 Compiler
1.6.3 All-in-one – die Entwicklungsumgebung

1.7 Welcher Compiler und welches Betriebssystem?

Galileo Computing

2 Das erste Programm

2.1 Der beste Lernerfolg

2.2 »Hallo Welt« in C

2.3 Analyse des Programms

Galileo Computing

3 Grundlagen

3.1 Zeichensätze

3.1.1 Basic-Zeichensatz
3.1.2 Ausführungszeichensatz (Steuerzeichen)
3.1.3 Trigraph-Zeichen

3.2 Symbole von C

3.2.1 Bezeichner
3.2.2 Schlüsselwörter
3.2.3 Literale
3.2.4 Einfache Begrenzer
3.2.5 Kommentare
Galileo Computing

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 Überprüfen auf das richtige Format
4.1.4 Zusammenfassung zu »scanf()«

4.2 Formatierte Ausgabe mit »printf()«

Galileo Computing

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 – <stdint.h>

5.7.1 <inttypes.h> (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 – <complex.h>

5.11 Der Datentyp »char«

5.12 Nationale contra internationale Zeichensätze

5.13 Der Breitzeichen-Typ »wchar_t«

5.14 Multibyte-Zeichen

5.15 Boolescher Wert – <stdbool.h>

5.16 Vorzeichenlos und vorzeichenbehaftet

5.17 Limits für 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 für formatierte Ein-/Ausgabe

Galileo Computing

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 für Fortgeschrittene

6.6 Makros für logische Operatoren und Bit-Operatoren – <iso646.h>

6.7 Der »sizeof«-Operator

6.7.1 C versus C++
Galileo Computing

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 Übliche arithmetische Datentypumwandlung

7.2 Explizite Datentypumwandlung mit dem »cast«–Operator

Galileo Computing

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 Einsatzmöglichkeiten der »for«-Schleife

8.11 Kontrollierte Sprünge

8.11.1 continue
8.11.2 break

8.12 Direkte Sprünge 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)
Galileo Computing

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 Schlüsselwörter für 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 für Funktionen

9.12.1 extern
9.12.2 static
9.12.3 volatile

9.13 Datenaustausch zwischen Funktionen

9.14 Wertübergabe an Funktionen (call-by-value)

9.15 Der Rückgabewert von Funktionen

9.16 Die Hauptfunktion »main()«

9.17 Rückgabewert 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 Fakultät
9.20.4 Fibonacci-Zahlen
9.20.5 Größter gemeinsamer Teiler (GGT)

9.21 »inline«-Funktionen

Galileo Computing

10 Präprozessor-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 Präprozessor-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«

Galileo Computing

11 Arrays

11.1 Arrays deklarieren

11.2 Initialisierung und Zugriff auf Arrays

11.2.1 Gültigkeitsbereich von Arrays

11.3 Arrays vergleichen

11.4 Anzahl der Elemente eines Arrays ermitteln

11.5 Übergabe von Arrays an Funktionen

11.6 Arrays aus Funktionen zurückgeben

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 Übergabe 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 Binärzahl

11.12 Einlesen von Strings

11.13 Die Standard-Bibliothek <string.h>

11.13.1 »strcat()« – Strings aneinanderhängen
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()« – Länge eines Strings ermitteln
11.13.7 »strncat()« – String mit n Zeichen aneinanderhängen
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
Galileo Computing

12 Zeiger (Pointer)

12.1 Zeiger deklarieren

12.2 Zeiger initialisieren

12.2.1 Speichergröße 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 Rückgabewert

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 Äquivalenz zwischen Zeigern und Arrays

12.13 Der »restrict«-Zeiger

Galileo Computing

13 Kommandozeilenargumente

13.1 Argumente an die Hauptfunktion übergeben

13.2 Optionen (Schalter) aus der Kommandozeile auswerten

Galileo Computing

14 Dynamische Speicherverwaltung

14.1 Das Speicherkonzept

14.2 Speicherallokation mit »malloc()«

14.3 Das NULL-Mysterium

14.3.1 NULL für 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 fehlschlägt

14.12.1 Speicheranforderung reduzieren
14.12.2 Speicheranforderungen aufteilen
14.12.3 Einen Puffer konstanter Größe verwenden
14.12.4 Zwischenspeichern auf Festplatte vor der Allokation
14.12.5 Nur so viel Speicher anfordern wie nötig
Galileo Computing

15 Strukturen

15.1 Struktur deklarieren

15.2 Initialisierung und Zugriff auf Strukturen

15.3 Strukturen als Wertübergabe an eine Funktion

15.4 Strukturen als Rückgabewert 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 Aufzählungstyp »enum«

15.11 Typendefinition mit »typedef«

15.12 Attribute von Strukturen verändern (nicht ANSI C)

15.13 Bitfelder

15.14 Das »offsetof«-Makro

Galileo Computing

16 Ein-/Ausgabe-Funktionen

16.1 Was ist eine Datei?

16.2 Formatierte und unformatierte Ein-/Ausgabe

16.3 Standard-Streams

16.4 Höhere Ein-/Ausgabe-Funktionen

16.5 Datei (Stream) öffnen – »fopen«

16.5.1 Modus für »fopen()«
16.5.2 Maximale Anzahl geöffneter 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) schließen – »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 zurückschieben – »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 für 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 öffnen – »freopen()«

16.19 Datei löschen 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 Temporäre Dateien erzeugen – »tmpfile()« und »tmpnam()«

16.21.1 »mkstemp()« – sichere Alternative für 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 »sprintf()«

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 öffnen – »open()«
16.26.2 Datei schließen – »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()«
Galileo Computing

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«
17.1.3 »stat()« – »st_atime«, »st_mtime« und »st_ctime«
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 Prüfen des Zugriffsrechts – »access()«

17.3 Verzeichnisfunktionen

17.3.1 Verzeichnis erstellen, löschen und wechseln – »mkdir()«, »rmdir« und »chdir«
17.3.2 In das Arbeitsverzeichnis wechseln – »getcwd()«
17.3.3 Verzeichnisse öffnen, lesen und schließen – »opendir()«, »readdir()« und »closedir()«
Galileo Computing

18 Arbeiten mit variabel langen Argumentlisten – <stdarg.h>

18.1 Makros in <stdarg.h> – »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__

Galileo Computing

19 Zeitroutinen

19.1 Die Headerdatei <time.h>

19.1.1 Konstanten in der Headerdatei <time.h>
19.1.2 Datums- und Zeitfunktionen in <time.h>

19.2 Laufzeitmessung (Profiling)

Galileo Computing

20 Weitere Headerdateien und ihre Funktionen (ANSI C)

20.1 <assert.h> – Testmöglichkeiten und Fehlersuche

20.2 <ctype.h> – Zeichenklassifizierung und Umwandlung

20.3 Mathematische Funktionen – <math.h>, <tgmath.h> und <complex.h>

20.3.1 Funktionen für reelle und komplexe Gleitpunkttypen
20.3.2 Funktionen nur für reelle Gleitpunkttypen
20.3.3 Funktionen nur für komplexe Gleitpunkttypen
20.3.4 Typengenerische Makros – <tgmath.h>
20.3.5 Gleitpunktwerte klassifizieren
20.3.6 Makro zum Vergleichen von reellen Zahlen
20.3.7 Zugriff auf die Gleitpunkt-Umgebung – <fenv.h>

20.4 <stdlib.h>

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 <locale.h> – länderspezifische Eigenheiten

20.6 Nicht-lokale Sprünge – <setjmp.h>

20.7 <signal.h>

20.8 <string.h> – 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 auffüllen
Galileo Computing

21 Dynamische Datenstrukturen

21.1 Lineare Listen (einfach verkettete Listen)

21.1.1 Erstes Element der Liste löschen
21.1.2 Ein beliebiges Element in der Liste löschen
21.1.3 Elemente der Liste ausgeben
21.1.4 Eine vollständige Liste auf einmal löschen
21.1.5 Element in die Liste einfügen

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

Galileo Computing

22 Algorithmen

22.1 Was sind Algorithmen?

22.2 Wie setze ich Algorithmen ein?

22.3 Sortieralgorithmen

22.3.1 »Selection Sort« – sortieren durch Auswählen
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 Binäre Suche
22.4.3 Binäre (Such-)Bäume
22.4.4 Elemente im binären Baum einordnen
22.4.5 Binäre Bäume traversieren
22.4.6 Löschen eines Elements im binären Baum
22.4.7 Ein binärer Suchbaum in der Praxis
22.4.8 Binäre Suchbäume mit Eltern-Zeiger und Threads
22.4.9 Ausgeglichene Binärbäume
22.4.10 Algorithmen für ausgeglichene Bäume – eine Übersicht

22.5 Hashing (Zerhacken)

22.5.1 Wann wird Hashing verwendet?
22.5.2 Was ist für das Hashing erforderlich?
22.5.3 Hash-Funktion
22.5.4 Hashing mit direkter Adressierung
22.5.5 Vergleich von Hashing mit binären Bäumen

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 (reguläre Ausdrücke)

22.8 Backtracking

22.8.1 Der Weg durch den Irrgarten
22.8.2 Das 8-Dame-Problem
Galileo Computing

23 CGI mit C

23.1 Was ist CGI?

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 Schlüsselfertige Lösung
23.7.5 Weitere Möglichkeiten
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 für 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 Gästebuch

23.12.1 Das HTML-Formular (»guestbook.html«)
23.12.2 Das CGI-Programm (»auswert.cgi«)
23.12.3 Das HTML-Gästebuch (»gaeste.html«)

23.13 Ausblick

Galileo Computing

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 für 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 löschen
24.3.5 Datenbank wechseln
24.3.6 Eine Tabelle erstellen
24.3.7 Die Tabelle anzeigen
24.3.8 Tabellendefinition überprüfen
24.3.9 Tabelle löschen
24.3.10 Struktur einer Tabelle ändern
24.3.11 Datensätze eingeben
24.3.12 Datensätze auswählen
24.3.13 Ein fortgeschrittenes Szenario
24.3.14 Datensatz löschen
24.3.15 Datensatz ändern
24.3.16 Zugriffsrechte in MySQL
24.3.17 Übersicht über 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 Funktionsübersicht

24.7 Datentypenübersicht der C-API

Galileo Computing

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 für 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 für Linux/UNIX
25.7.3 Linux/UNIX-Quellcodedatei
25.7.4 Headerdatei für 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 Portabilität
25.8.4 Von IPv4 nach IPv6
25.8.5 RFC-Dokumente (Request for Comments)
25.8.6 Sicherheit
Galileo Computing

26 Paralleles Rechnen

26.1 Parallelität

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 Grundgerüst für ein Programm mit mehreren Threads
26.4.3 Zusammenfassung
Galileo Computing

27 Sicheres Programmieren

27.1 Buffer-Overflow (Speicherüberlauf)

27.1.1 Speicherverwaltung von Programmen
27.1.2 Der Stack-Frame
27.1.3 Rücksprungadresse manipulieren
27.1.4 Gegenmaßnahmen zum Buffer-Overflow während der Programmerstellung
27.1.5 Gegenmaßnahmen 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

Galileo Computing

28 Wie geht’s jetzt weiter?

28.1 GUI-Programmierung – grafische Oberflächen

28.1.1 Low-Level-Grafikprogrammierung
28.1.2 High-Level-Grafikprogrammierung
28.1.3 Multimedia-Grafikprogrammierung
Galileo Computing

A Operatoren

A.1 Rangfolge der Operatoren

A.2 ASCII-Code-Tabelle

A.3 Reservierte Schlüsselwörter in C

A.4 Standard-Headerdateien der ANSI-C-Bibliothek

A.5 Weiterführende Links

Galileo Computing

B Die C-Standard-Bibliothek

B.1 <assert.h>

B.2 <complex.h> (C99)

B.3 <ctype.h>

B.4 <errno.h>

B.5 <fenv.h> (C99)

B.6 <float.h>

B.7 <inttypes.h> (C99)

B.8 <iso646.h> (NA1)

B.9 <limits.h>

B.10 <locale.h>

B.11 <math.h>

B.12 <setjmp.h>

B.13 <signal.h>

B.14 <stdarg.h>

B.15 <stdbool.h> (C99)

B.16 <stddef.h>

B.17 <stdint.h> (C99)

B.18 <stdio.h>

B.19 <stdlib.h>

B.20 <string.h>

B.21 <tgmath.h> (C99)

B.22 <time.h>

B.23 <wchar.h> (NA1)

B.24 <wctype.h> (NA1)



Ihr Kommentar

Wie hat Ihnen das <openbook> gefallen? Wir freuen uns immer über Ihre freundlichen und kritischen Rückmeldungen. >> Zum Feedback-Formular
  
  Zum Katalog
Zum Katalog: C von A bis Z

 C von A bis Z
Jetzt bestellen


 Ihre Meinung?
Wie hat Ihnen das <openbook> gefallen?
Ihre Meinung

 Buchtipps
Zum Katalog: Spielend C++ lernen






 Spielend C++ lernen


Zum Katalog: C++ von A bis Z






 C++ von A bis Z


Zum Katalog: Schrödinger programmiert C++






 Schrödinger
 programmiert C++


Zum Katalog: C++11 programmieren






 C++11 programmieren


Zum Katalog: Computergeschichte(n) – nicht nur für Geeks






 Computergeschichte(n)
 nicht nur für Geeks


Zum Katalog: IT-Handbuch für Fachinformatiker






 IT-Handbuch für
 Fachinformatiker


Zum Katalog: Java ist auch eine Insel






 Java ist auch
 eine Insel


Zum Katalog: Java 7 – Mehr als eine Insel







 Java 7 –
 Mehr als eine Insel


 Shopping
Versandkostenfrei bestellen in Deutschland und Österreich
InfoInfo




Copyright © Galileo Press 2009
Für Ihren privaten Gebrauch dürfen Sie die Online-Version natürlich ausdrucken. Ansonsten unterliegt das <openbook> denselben Bestimmungen, wie die gebundene Ausgabe: Das Werk einschließlich aller seiner Teile ist urheberrechtlich geschützt. Alle Rechte vorbehalten einschließlich der Vervielfältigung, Übersetzung, Mikroverfilmung sowie Einspeicherung und Verarbeitung in elektronischen Systemen.


[Galileo Computing]

Galileo Press, Rheinwerkallee 4, 53227 Bonn, Tel.: 0228.42150.0, Fax 0228.42150.77, info@galileo-press.de