C in a Nutshell, 2. Auflage

Table of contents

1. Vorwort
   1. Wie dieses Buch organisiert ist
      1. Teil I
      2. Teil II
      3. Teil III
   2. Weitere Lektüre
   3. In diesem Buch verwendete Konventionen
   4. Code-Beispiele verwenden
   5. Safari® Bücher Online
   6. Wie du uns kontaktierst
   7. Danksagungen
      1. Peter
      2. Tony
2. I. Sprache
3. 1. Grundlagen der Sprache
   1. Merkmale von C
   2. Die Struktur von C-Programmen
   3. Quelldateien
   4. Kommentare
   5. Zeichensätze
      1. Breitzeichen und Multibyte-Zeichen
      2. Universelle Zeichennamen
      3. Digraphen und Trigraphen
   6. Identifikatoren
      1. Kennung Name Leerzeichen
      2. Kennung Geltungsbereich
   7. Wie der C-Compiler funktioniert
      1. Die Übersetzungsphasen des C-Compilers
      2. Wertmarken
4. 2. Typen
   1. Typologie
   2. Integer-Typen
      1. Integer-Typen, die in Standard-Headern definiert sind
   3. Fließkomma-Typen
   4. Komplexe Fließkomma-Typen
   5. Aufgezählte Typen
   6. Der Typ Leere
      1. void in Funktionsdeklarationen
      2. Ausdrücke vom Typ void
      3. Zeiger auf void
   7. Die Ausrichtung von Objekten im Speicher
5. 3. Literale
   1. Ganzzahlige Konstanten
   2. Fließkomma-Konstanten
      1. Dezimale Fließkomma-Konstanten
      2. Hexadezimale Fließkommakonstanten
   3. Zeichen-Konstanten
      1. Typen und Werte von Zeichenkonstanten
      2. Flucht-Sequenzen
   4. String-Literale
6. 4. Typ Konvertierungen
   1. Umwandlung von arithmetischen Typen
      1. Hierarchie der Typen
      2. Ganzzahlige Förderung
      3. Übliche arithmetische Umrechnungen
      4. Andere implizite Typkonvertierungen
      5. Die Ergebnisse der arithmetischen Typkonvertierung
   2. Umwandlung von nichtarithmetischen Typen
      1. Array- und Funktionsbezeichner
      2. Explizite Zeigerumwandlungen
      3. Implizite Zeigerumwandlungen
      4. Konvertierungen zwischen Zeiger- und Ganzzahltypen
7. 5. Ausdrücke und Operatoren
   1. Wie Ausdrücke ausgewertet werden
      1. Generische Auswahlen (C11)
      2. LWerte
      3. Nebenwirkungen und Sequenzpunkte
      4. Operatorpriorität und Assoziativität
   2. Betreiber im Detail
      1. Arithmetische Operatoren
      2. Zuweisungsoperatoren
      3. Inkrement- und Dekrement-Operatoren
      4. Vergleichende Operatoren
      5. Logische Operatoren
      6. Bitweise Operatoren
      7. Speicheradressierungsoperatoren
      8. Andere Betreiber
   3. Konstante Ausdrücke
      1. Ganzzahlige konstante Ausdrücke
      2. Andere konstante Ausdrücke
8. 6. Aussagen
   1. Ausdrucksweisen
   2. Blockanweisungen
   3. Schleifen
      1. while Anweisungen
      2. für Aussagen
      3. do...while Anweisungen
      4. Verschachtelte Schleifen
   4. Auswahl Aussagen
      1. if-Anweisungen
      2. switch Anweisungen
   5. Bedingungslose Sprünge
      1. Das Break Statement
      2. Die Fortsetzung der Erklärung
      3. Die goto-Anweisung
      4. Die Rückgabeerklärung
9. 7. Funktionen
   1. Funktionsdefinitionen
      1. Funktionen und Spezifizierungen der Speicherklassen
      2. K&R-Stil Funktionsdefinitionen
      3. Funktionsparameter
      4. Arrays als Funktionsparameter
      5. Die main()-Funktion
   2. Funktionsdeklarationen
      1. Optionale Parameter deklarieren
      2. Deklaration von Array-Parametern mit variabler Länge
   3. Wie die Funktionen ausgeführt werden
   4. Zeiger als Argumente und Rückgabewerte
   5. Inline-Funktionen
   6. Nicht-zurückkehrende Funktionen
   7. Rekursive Funktionen
   8. Variable Anzahl von Argumenten
10. 8. Arrays
    1. Arrays definieren
       1. Arrays mit fester Länge
       2. Arrays mit variabler Länge
    2. Zugriff auf Array-Elemente
    3. Arrays initialisieren
       1. Initialisierungslisten schreiben
       2. Initialisierung bestimmter Elemente
    4. Strings
    5. Mehrdimensionale Arrays
       1. Matrizen
       2. Mehrdimensionale Arrays deklarieren
       3. Initialisierung mehrdimensionaler Arrays
    6. Arrays als Argumente von Funktionen
11. 9. Zeiger
    1. Deklarieren von Zeigern
       1. Null-Zeiger
       2. void Zeiger
       3. Zeiger initialisieren
    2. Operationen mit Zeigern
       1. Zeiger zum Lesen und Ändern von Objekten verwenden
       2. Ändern und Vergleichen von Zeigern
    3. Zeiger und Typbezeichner
       1. Konstante Zeiger und Zeiger auf konstante Objekte
       2. Eingeschränkte Zeiger
    4. Zeiger auf Arrays und Arrays von Zeigern
       1. Array-Zeiger
       2. Zeiger-Arrays
    5. Zeiger auf Funktionen
12. 10. Strukturen, Unions und Bit-Felder
    1. Strukturen
       1. Strukturtypen definieren
       2. Struktur-Objekte und typedef Namen
       3. Unvollständige Strukturtypen
       4. Zugriff auf Strukturmitglieder
       5. Strukturen initialisieren
       6. Initialisierung bestimmter Mitglieder
       7. Strukturmitglieder im Speicher
       8. Flexible Struktur Mitglieder
       9. Zeiger als Strukturmitglieder
    2. Gewerkschaften
       1. Unionsarten definieren
       2. Initialisierung von Gewerkschaften
    3. Anonyme Strukturen und Gewerkschaften
    4. Bit-Felder
13. 11. Erklärungen
    1. Objekt- und Funktionsdeklarationen
       1. Beispiele
       2. Spezifizierer von Speicherklassen
       3. Typ Qualifier
       4. Erklärungen und Definitionen
       5. Komplexe Deklaratoren
    2. Typennamen
    3. typedef Deklarationen
    4. _Static_assert Deklarationen
    5. Verknüpfung von Identifikatoren
       1. Externe Verknüpfung
       2. Interne Verknüpfung
       3. Keine Verknüpfung
    6. Dauer der Speicherung von Objekten
       1. Dauer der statischen Speicherung
       2. Dauer der Speicherung des Gewindes
       3. Automatische Speicherung Dauer
    7. Initialisierung
       1. Implizite Initialisierung
       2. Explizite Initialisierung
14. 12. Dynamische Speicherverwaltung
    1. Dynamische Speicherzuweisung
    2. Merkmale des zugewiesenen Speichers
    3. Größe ändern und Speicher freigeben
    4. Ein universeller Binärbaum
    5. Eigenschaften
    6. Umsetzung
       1. Einen leeren Baum generieren
       2. Neue Daten einfügen
       3. Daten im Baum finden
       4. Daten aus dem Baum entfernen
       5. Einen Baum überqueren
       6. Ein Anwendungsbeispiel
15. 13. Eingabe und Ausgabe
    1. Streams
       1. Textströme
       2. Binäre Ströme
    2. Dateien
       1. Datei Position
       2. Puffer
       3. Die Standardströme
    3. Öffnen und Schließen von Dateien
       1. Eine Datei öffnen
       2. Zugriffsmodi
       3. Eine Datei schließen
    4. Lesen und Schreiben
       1. Byte-orientierte und breit angelegte Streams
       2. Fehlerbehandlung
       3. Unformatierte E/A
       4. Formatierte Ausgabe
       5. Formatierte Eingabe
    5. Zufälliger Dateizugriff
       1. Abrufen der aktuellen Dateiposition
       2. Einstellen der Dateizugriffsposition
16. 14. Multithreading
    1. Themen
       1. Threads erstellen
       2. Andere Gewindefunktionen
    2. Zugriff auf freigegebene Daten
       1. Gegenseitiger Ausschluss
       2. Atomare Objekte
       3. Atomare Operationen
       4. Speicher bestellen
       5. Zäune
    3. Kommunikation zwischen Threads: Bedingungsvariablen
    4. Thread-lokale Objekte und Thread-spezifische Speicherung
       1. Thread-lokale Objekte verwenden
       2. Thread-spezifische Speicherung verwenden
17. 15. Vorverarbeitungsrichtlinien
    1. Einfügen des Inhalts von Header-Dateien
       1. Wie der Präprozessor die Header-Dateien findet
       2. Verschachtelte #include Direktiven
    2. Makros definieren und verwenden
       1. Makros ohne Parameter
       2. Makros mit Parametern
       3. Makros innerhalb von Makros verwenden
       4. Makroumfang und Neudefinition
    3. Typ-generische Makros
    4. Bedingte Kompilierung
       1. Die #if und #elif Direktiven
       2. Der definierte Operator
       3. Die Direktiven #ifdef und #ifndef
    5. Zeilennummern festlegen
    6. Fehlermeldungen generieren
    7. Die #pragma-Richtlinie
    8. Der _Pragma-Operator
    9. Vordefinierte Makros
       1. Bedingt definierte Makros
18. II. Standard-Bibliothek
19. 16. Die Standard-Kopfzeilen
    1. Verwendung der Standardkopfzeilen
       1. Ausführungsumgebungen
       2. Funktions- und Makroaufrufe
       3. Reservierte Bezeichner
    2. Funktionen mit Bound-Checking
       1. Verfügbarkeit
       2. Laufzeitbeschränkungen
    3. Inhalt der Standardkopfzeilen
       1. assert.h
       2. complex.h
       3. ctype.h
       4. errno.h
       5. fenv.h
       6. float.h
       7. inttypes.h
       8. iso646.h
       9. limits.h
       10. locale.h
       11. math.h
       12. setjmp.h
       13. signal.h
       14. stdalign.h
       15. stdarg.h
       16. stdatomic.h
       17. stdbool.h
       18. stddef.h
       19. stdint.h
       20. stdio.h
       21. stdlib.h
       22. stdnoreturn.h
       23. string.h
       24. tgmath.h
       25. threads.h
       26. time.h
       27. uchar.h
       28. wchar.h
       29. wctype.h
20. 17. Funktionen im Überblick
    1. Eingabe und Ausgabe
    2. Mathematische Funktionen
       1. Mathematische Funktionen für Integer-Typen
       2. Fließkommafunktionen
       3. Funktionsähnliche Makros
       4. Pragmas für arithmetische Operationen
       5. Die Fließkomma-Umgebung
       6. Fehlerbehandlung
    3. Klassifizierung und Umwandlung von Zeichen
       1. Charakter-Klassifizierung
       2. Case Mapping
    4. String-Verarbeitung
    5. Multibyte-Zeichen
    6. Konvertierung zwischen Zahlen und Strings
    7. Suchen und Sortieren
    8. Handhabung von Speicherblöcken
    9. Dynamische Speicherverwaltung
    10. Datum und Uhrzeit
    11. Prozesskontrolle
        1. Kommunikation mit dem Betriebssystem
        2. Signale
    12. Internationalisierung
    13. Nicht-lokale Sprünge
    14. Multithreading (C11)
        1. Gewindefunktionen
        2. Atomare Operationen
    15. Fehlersuche
    16. Fehlermeldungen
21. 18. Funktionen der Standardbibliothek
22. III. Grundlegende Werkzeuge
23. 19. Kompilieren mit GCC
    1. Die GNU Compiler-Sammlung
    2. Beziehen und Installieren des GCC
    3. C-Programme mit dem GCC kompilieren
       1. Schritt für Schritt
       2. Mehrere Eingabedateien
       3. Dynamisches Linken und Shared Object Files
       4. Freistehende Programme
    4. C Dialekte
    5. Compiler-Warnungen
    6. Optimierung
       1. Die -O-Stufen
       2. Die -f Flaggen
       3. Fließkomma-Optimierung
       4. Architektur-spezifische Optimierung
       5. Warum nicht optimieren?
    7. Fehlersuche
    8. Profiling
    9. Zusammenfassung der Optionen und Umgebungsvariablen
       1. Kommandozeilen-Optionen
       2. Umgebungsvariablen
24. 20. Mit make C-Programme erstellen
    1. Ziele, Voraussetzungen und Befehle
    2. Das Makefile
    3. Regeln
       1. Das Befehlsskript
       2. Musterregeln
       3. Suffix-Regeln
       4. Eingebaute Regeln
       5. Implizite Regelketten
       6. Doppelpunkt-Regeln
    4. Kommentare
    5. Variablen
       1. Zuweisungsoperatoren
       2. Variablen und Whitespace
       3. Zielspezifische variable Zuweisungen
       4. Die automatischen Variablen
       5. Andere eingebaute Variablen
       6. Umgebungsvariablen
    6. Falsche Ziele
    7. Andere Zielattribute
    8. Makros
    9. Funktionen
       1. Eingebaute Funktionen
       2. Benutzerdefinierte Funktionen
    10. Richtlinien
        1. Konditionale
        2. Inklusive
        3. Andere Richtlinien
    11. Laufende Marke
        1. Kopfzeilen-Abhängigkeiten generieren
        2. Rekursive make-Befehle
        3. Kommandozeilen-Optionen
        4. Spezielle Ziele, die als Laufzeitoptionen verwendet werden
        5. GCC-Optionen für die Erzeugung von Makefile-Regeln
25. 21. C-Programme mit GDB debuggen
    1. GDB installieren
    2. Ein Beispiel für eine Debugging-Sitzung
       1. Symbol Informationen
       2. Einen Fehler finden
    3. GDB starten
       1. Befehlszeilen-Argumente
       2. Kommandozeilen-Optionen
       3. Initialisierungsdateien
    4. GDB-Befehle verwenden
       1. Befehlsabschluß
       2. Anzeige der Hilfe für Befehle
       3. Status-Informationen
       4. Ein Programm im Debugger ausführen
       5. Anzeige des Quellcodes
       6. Arbeiten mit Haltepunkten
       7. Wiederaufnahme der Ausführung nach einer Unterbrechung
       8. Analysieren des Stapels
       9. Daten anzeigen
       10. Beobachtungspunkte: Beobachtung von Operationen auf Variablen
    5. Analysieren von Kerndateien in GDB
26. 22. Verwendung einer IDE mit C
    1. IDEs für C
    2. Die Eclipse IDE für C/C++
       1. Eclipse CDT installieren
       2. Eclipse ausführen
       3. Perspektiven und Ansichten
    3. Ein C-Programm mit Eclipse entwickeln
       1. Ein neues C-Projekt erstellen
       2. Editieren
       3. Kompilieren und Ausführen eines Programms
       4. Projekt Eigenschaften
    4. Debuggen eines C-Programms in Eclipse
       1. Den Debugger starten
       2. Haltepunkte setzen
       3. Kontrolle der Programmausführung im Debugger
    5. Weitere Informationen zu Eclipse
27. Index