Sprache C. Programmierschule. Ausgabe 5 - Stephen Prata

Warnung!

Der Verkauf dieses Buches ist beendet - sehen Sie sich unsere anderen Artikel an .

Inhalt

Vorwort (19)

Über den Autor (21)

Kapitel 1. Erste Schritte (23)

• Woher kommt das C? (23)
• Warum C? (24)
  
  • Leistung (25)
  • Effizienz (25)
  • Portabilität (25)
  • Kraft und Flexibilität (25)
  • Programmiererzentriertheit (26)
  • Schwächen (26)
• Wohin geht C? (26)
• Was machen Computer? (28)
• Hochsprachen und Compiler (29)
• Verwenden von C: Sieben Schritte (29)
  
  • Schritt 1: Programmziele definieren (30)
  • Schritt 2: Entwerfen des Programms (30)
  • Schritt 3: Schreiben des Codes (31)
  • Schritt 4: Zusammenstellung (31)
  • Schritt 5: Ausführen des Programms (32)
  • Schritt 6: Testen und Debuggen (32)
  • Schritt 7: Pflegen und ändern Sie das Programm (33)
  • Kommentar (33)
• Programmiermechanik (33)
  
  • Objektcodedateien, ausführbare Dateien und Bibliotheken (34)
  • UNIX (36)
  • Linux (38)
  • Integrierte Entwicklungsumgebungen (Windows) (38)
  • DOS Compiler für IBM PCs (40)
  • C und Macintosh (40)
• Sprachstandards (40)
  
  • ANSI / ISO C-Norm (41)
  • Standard-C99 (42)
• Aufbau dieses Buches (43)
• Schreibmethoden (43)
  
  • Schriftart (43)
  • Bildschirmtext (43)
• Kapitelzusammenfassung (45)
• Wiederholungsfragen 45
• Übung (45)

Kapitel 2. Einführung in C (47)

• Ein einfaches Beispiel für die Sprache C
• Erklärung (48)
  
  • Ansatz 1: Kurzzusammenfassung (48)
  • Ansatz 2: Details (50)
• Erstellen eines einfachen Programms (59)
• Wie machen Sie Ihr Programm lesbar? (60)
• Der nächste Schritt (60)
  
  • Dokumentation (61)
  • Mehrere Deklarationen
  • Multiplikation (61)
  • Anzeigen mehrerer Werte
• Mehrere Funktionen
• Fehlerbehebung (64)
  
  • Syntaxfehler
  • Semantische Fehler 65
  • Programmstatus (67)
• Schlüsselwörter (67)
• Schlüsselthemen (68)
• Kapitelzusammenfassung (69)
• Wiederholungsfragen 69
• Übungen (70)

Kapitel 3. Daten in C

• Beispielprogramm (74)
  
  • Was gibt's Neues? (75)
• Variablen und Konstanten (76)
• Schlüsselwörter für Datentypen
  
  • Ganzzahltypen und Fließkommatypen
  • Ganzzahl (78)
  • Fließkommazahl (79)
• Datentypen in C
  
  • Der int-Typ (80)
  • Andere Integer-Typen (84)
  • Verwenden von Zeichen: Geben Sie Char ein
  • Der _Bool-Typ (95)
  • Übertragbare Typen: inttypes.h 96
  • Float, Double und Long Double
  • Komplexe und imaginäre Typen 103
  • Andere Typen (103)
  • Schriftgrößen (105)
• Verwendung von Datentypen 107
• Argumentationsnotiz 107
• Noch ein Beispiel 109
  
  • Was ist los (110)
  • Mögliches Problem (111)
• Schlüsselbegriffe 111
• Kapitelzusammenfassung 112
• Wiederholungsfragen 113
• Übungen

Kapitel 4. Strings und formatierte Ein-/Ausgabe 117

• Für den Anfang ... das Programm (118)
• Streicher: Eine Einführung 119
  
  • Char-Arrays und das Null-Zeichen 119
  • Verwendung von Ketten (120)
  • Die strlen() Funktion 121
• Konstanten und der C-Präprozessor 123
  
  • Konstantenmodifikator 127
  • Standardkonstanten (127)
• printf() und scanf() kennen und verwenden (129)
  
  • Die printf()-Funktion 130
  • Verwendung von printf () 130
  • Konvertierungsspezifizierer-Modifikatoren für printf () 132
  • Bedeutung der Bekehrung 138
  • Verwenden der Funktion scanf () 144
  • Der Modifikator * in den Funktionen printf() und scanf() (150)
• Praxistipps (151)
• Schlüsselbegriffe 152
• Kapitelzusammenfassung 153
• Wiederholungsfragen 154
• Übungen

Kapitel 5. Operatoren, Ausdrücke und Anweisungen 159

• Einführung in die Schleife (160)
• Grundlegende Operatoren
  
  • Zuweisungsoperator: = (162)
  • Additionsoperator: + (164)
  • Subtraktionsoperator: - (165)
  • Vorzeichenoperatoren: - und + 165
  • Der Multiplikationsoperator: * (166)
  • Divisionsoperator: / (168)
  • Bedienerpriorität
  • Priorität und Reihenfolge der Berechnungen
• Einige andere Operatoren 172
  
  • Der sizeof-Operator und der size_t-Typ 172
  • Der Modulo-Operator:% (173)
  • Die Inkrement- und Dekrementoperatoren: ++ und - 175
  • Abnahme - (179)
  • Priorität (180)
  • Versuchen Sie nicht, zu schlau zu sein (181)
• Ausdrücke und Anweisungen 182
  
  • Ausdrücke 182
  • Handbücher (183)
  • Zusammengesetzte Anweisungen (Blöcke) 186
• Typumwandlungen
  
  • Der Cast-Operator 190
• Funktionen mit Argumenten 192
• Beispielprogramm (194)
• Schlüsselthemen (195)
• Kapitelzusammenfassung 196
• Wiederholungsfragen 197
• Übungen (200)

Kapitel 6. Die Kontrollanweisungen C: Schleifen 203

• Beispiel (204)
  
  • Kommentar (205)
  • Leseschleife im C-Stil (207)
• Die While-Anweisung 207
  
  • Ende der While-Schleife 208
  • Wann endet die Schleife? (208)
  • while als Schleife mit einer Eintrittsbedingung 209
  • Syntaxhinweise
• Was ist größer: Verwenden von Vergleichsoperatoren und Ausdrücken 211
  
  • Was ist Wahrheit? (213)
  • Was ist noch wahr? (214)
  • Probleme mit der Wahrheit (215)
  • Der neue _Bool-Typ 218
  • Priorität von Vergleichsoperatoren 219
• Undefinierte Schleifen und Zählschleifen 221
• Für Schleife
  
  • Die Flexibilität der for-Schleife
• Andere Zuweisungsoperatoren: + =, - =, * =, / =, % = (228)
• Der Komma-Operator:, (229)
  
  • Zeno von Elea gegen die for-Schleife
• Eine Exit-Condition-Schleife: do while 233
• Welche Schleife verwenden? (236)
• Verschachtelte Schleifen 237
  
  • Übersicht (238)
  • Andere Variante (238)
• Arrays (239)
  
  • Für Array- und Loop-Interoperabilität 240
• Ein Beispiel mit einer Schleife und einem Funktionsrückgabewert 242
  
  • Programmübersicht 245
  • Verwenden von Funktionen, die Werte zurückgeben 246
• Kernthemen (246)
• Kapitelzusammenfassung 247
• Wiederholungsfragen 248
• Übungen

Kapitel 7. C-Steueranweisungen: Verzweigungen und Sprünge 257

• Die if-Anweisung (258)
• Wir fügen sonst (260)
  
  • Ein weiteres Beispiel: die Funktionen getchar () und putchar () 262
  • Die ctype.h-Familie von Zeichenfunktionen 264
  • Wahl unter vielen Möglichkeiten: sonst wenn (266)
  • Sonst verbinden mit if 269
  • Mehr über verschachtelte If-Anweisungen 271
• Seien wir logisch (275)
  
  • Alternative Schreibweise: iso646.h Header 277
  • Priorität (277)
  • Berechnungsreihenfolge 278
  • Bereiche
• Ein Wortzählprogramm 280
• Bedingungsoperator:?: (284)
• Schleifenzusätze: Continue und Break 286
  
  • Die Continue-Anweisung 286
  • Die Break-Anweisung 289
• Auswahl aus vielen Möglichkeiten: Schalten und Brechen (291)
  
  • Verwendung einer switch-Anweisung 293
  • Nur das erste Zeichen in einer Zeile erhalten 294
  • Mehrere Etiketten (295)
  • Schalten Sie ein, wenn sonst (298)
• Die goto-Anweisung 298
  
  • Gehe zu 298 vermeiden
• Schlüsselthemen (301)
• Kapitelzusammenfassung 302
• Wiederholungsfragen 303
• Übungen

Kapitel 8. Zeichen I/O und Weiterleitung 309

• Einzelzeichen I/O: getchar () und putchar () (310)
• Puffer (311)
• Tastatureingabe abschließen
  
  • Dateien, Streams und Tastatureingaben
  • Dateiende (314)
• Umleitung und Dateien
  
  • Umleitung unter UNIX, Linux und DOS
• Erstellen einer freundlicheren Benutzeroberfläche 322
  
  • Betrieb mit gepufferter Eingabe (322)
  • Kombinieren von Zahlen- und Zeicheneingaben 325
  • Validieren der Eingabe 328
  • Programmanalyse (332)
  • Eingabeströme und Zahlen 333
• Menü (334)
  
  • Aufgaben (334)
  • Agilität (335)
  • Kombinieren von Zeichen- und numerischen Daten 337
• Schlüsselthemen (340)
• Kapitelzusammenfassung 340
• Wiederholungsfragen 341
• Übungen

Kapitel 9. Funktionen 345

• Erinnerung (345)
  
  • Erstellen und Verwenden einer einfachen Funktion 347
  • Programmanalyse (347)
  • Funktionsargumente
  • Eine Funktion definieren, die ein Argument akzeptiert: Formale Argumente 351
  • Der Prototyp einer Funktion, die Argumente akzeptiert 352
  • Aufrufen einer Funktion, die ein Argument akzeptiert: Tatsächliche Argumente 353
  • Black-Box-Sicht (354)
  • Zurückgeben eines Werts mit der Return-Anweisung 354
  • Funktionstypen 357
• ANSI C-Prototypen (358)
  
  • Das Problem (359)
  • ANSI zur Rettung! (360)
  • Keine Argumente und Argumente undefiniert 361
• Die Macht des Prototyping 362
• Rekursion (362)
  
  • Rekursion ohne Geheimnisse (363)
  • Die Grundlagen der Rekursion
  • Letzte Rekursion 365
  • Rekursion und umgekehrte Sequenz
  • Für und gegen Rekursion
• Kompilieren von Programmen mit mehr als einer Funktion 371
  
  • UNIX (371)
  • Linux (371)
  • DOS (Befehlszeilen-Compiler) (372)
  • Windows- und Macintosh-Compiler (372)
  • Verwenden von Header-Dateien 372
• Adressen abrufen: Der &-Operator 376
• Ändern von Variablen in der aufrufenden Funktion 377
• Hinweise: Ein erster Blick 379
  
  • Dereferenzierungsoperator: * (380)
  • Deklarieren von Zeigern 381
  • Verwendung von Zeigern zur Kommunikation zwischen Funktionen 382
• Schlüsselbegriffe 386
• Kapitelzusammenfassung 387
• Wiederholungsfragen 387
• Übungen

Kapitel 10. Arrays und Zeiger 391

• Arrays (391)
• Initialisierung 392
  
  • Verwendung von const mit Arrays 393
  • Eine Anmerkung zu Variablenklassen
  • Designierte Initialisierung (C99) 397
  • Arrays Werte zuweisen 398
  • Array-Bereich 398
  • Bestimmen der Größe eines Arrays
• Mehrdimensionale Arrays 401
• Initialisieren eines zweidimensionalen Arrays
  
  • Weitere Abmessungen 405
• Zeiger auf Arrays 405
• Funktionen, Arrays und Zeiger 408
  
  • Verwenden von Zeigerargumenten 411
  • Kommentar: Zeiger und Arrays 414
• Arbeiten an Indikatoren (414)
• Schützen des Inhalts eines Arrays
  
  • Verwenden des Schlüsselworts const in formalen Parametern
  • Mehr über const 421
• Zeiger und mehrdimensionale Arrays 423
  
  • Zeiger auf mehrdimensionale Arrays 426
  • Zeigerkompatibilität
  • Funktionen und mehrdimensionale Arrays 429
  • Arrays mit variabler Länge (VLA) (433)
  • Komplexe Literale 437
• Kernfragen 439
• Kapitelzusammenfassung 440
• Wiederholungsfragen 441
• Übungen

Kapitel 11. Zeichenketten und Zeichenkettenfunktionen 447

• Stellt Strings und String I/O 447 dar
• Zeichenfolgen definieren 449
  
  • Kettenkonstanten (449)
  • String-Arrays und Initialisierung 450
  • Array vs. Zeiger 452
  • Arrays von Strings 455
  • Zeiger und Strings 456
• Strings laden 458
  
  • Einen Ort erstellen (458)
  • Die gets()-Funktion 459
  • Die fgets()-Funktion 461
  • Die scanf()-Funktion 462
• Strings anzeigen (464)
  
  • Die puts () Funktion 464
  • Die fputs() Funktion 465
  • Die printf()-Funktion 466
• Selber machen (466)
• Zeichenkettenfunktionen 469
  
  • Die strlen() Funktion 469
  • Die strcat()-Funktion 471
  • Die strncat()-Funktion 472
  • Die strcmp()-Funktion 473
  • Die Funktionen strcpy() und strncpy() 478
  • Die sprintf () Funktion 483
  • Andere Zeichenkettenfunktionen 484
• Anwendungsbeispiel: Zeichenfolgen sortieren 486
  
  • Pointer statt Strings sortieren 487
  • Auswahlsortieralgorithmus 488
• Zeichenfolgen und Zeichenfunktionen der ctype.h-Familie 489
• Befehlszeilenargumente 491
  
  • Befehlszeilenargumente in integrierten Umgebungen
  • Macintosh-Befehlszeilenargumente 493
• Strings in Zahlen umwandeln 494
• Schlüsselprobleme
• Kapitelzusammenfassung 497
• Wiederholungsfragen 498
• Übungen

Kapitel 12. Variablenklassen, Konnektivität und Speicherverwaltung 503

• Klassen von Variablen
  
  • Variabler Umfang (504)
  • Variable Konnektivität
  • Variable Dauer (507)
  • Automatische Variablen 507
  • Variablen registrieren
  • Statische Variablen mit Blockbereich 513
  • Statische Variablen mit externer Verknüpfung 514
  • Statische Variablen mit interner Verknüpfung 519
  • Multifile-Programme
  • Variable Klassenbezeichner
• Klassen von Variablen und Funktionen
  
  • Welche Klasse wählen? (524)
• Pseudozufallsfunktionen und statische Variablen
• Würfeln (528)
• Speicherzuweisung: Malloc () und free () 532
  
  • Die Free()-Funktion verstehen 536
  • Die calloc()-Funktion 537
  • Dynamische Speicherzuweisung und Arrays variabler Größe 538
  • Variable Klassen und dynamische Speicherzuweisung
• ANSI C Type Qualifier (540)
  
  • Const Type Qualifier (540)
  • Der flüchtige Type Qualifier 543
  • Der einschränkende Typqualifizierer 544
  • Alte Keywords an neuen Orten (545)
  • Schlüsselbegriffe 546
• Kapitelzusammenfassung 547
• Wiederholungsfragen 548
• Übungen

Kapitel 13. Umgang mit Dateien 553

• Austausch von Informationen mit Dateien (553)
  
  • Was ist die Datei? (554)
  • Eingangs- / Ausgangspegel (555)
  • Standarddateien (556)
• Standard-Eingabe / Ausgabe (556)
  
  • Überprüfen von Befehlszeilenargumenten 557
  • Die fopen()-Funktion 558
  • Die Funktionen getc () und putc () 559
  • Dateiende (EOF) (560)
  • Die fclose()-Funktion 561
  • Zeiger auf Standarddateien
• Einfacher Dateikompressor 562
• Datei-E/A: fprintf (), fscanf (), fgets () und fputs () 564
  
  • Die Funktionen fprintf() und fscanf() 564
  • Die Funktionen fgets () und fputs () 565
• Abenteuer im wahlfreien Zugriff: fseek () und ftell () 568
  
  • Wie funktionieren die Funktionen fseek() und ftell()? (569)
  • Binär- versus Textmodus 571
  • Portabilität
  • Die Funktionen fgetpos () und fsetpos () 572
• Hinter den Kulissen der Standardeingabe/-ausgabe (573)
• Weitere Standard-I/O-Funktionen 574
  
  • Die Int ungetc (int c, FILE * fp)-Funktion 574
  • Die int fflush () Funktion 574
  • Die int setvbuf () Funktion 575
  • Binäre I/O: fread() und fwrite() 575
  • Die size_t fwrite-Funktion 577
  • Die size_t fread-Funktion (void * ptr, size_t size, size_t nmemb, FILE * fp) 578
  • Die Funktionen int feof (FILE * fp) und int ferror (FILE * fp) 578
  • Beispiel (578)
  • Wahlfreier Zugriff auf binäre Eingabe / Ausgabe (581)
• Kernthemen (583)
• Kapitelzusammenfassung 583
• Wiederholungsfragen 584
• Übungen

Kapitel 14. Strukturen und andere Datenformen

• Beispielaufgabe: Erstellen eines Bücherinventars (590)
• Strukturdeklaration
• Strukturvariable definieren 592
  
  • Strukturinitialisierung 593
• Zugreifen auf Strukturmitglieder 594
  
  • Strukturbeschriftete Initialisierer 595
• Arrays von Strukturen
  
  • Deklarieren eines Arrays von Strukturen 598
  • Identifizieren der Mitglieder eines Arrays von Strukturen 599
  • Programmdetails (599)
• Verschachtelte Strukturen
• Zeiger auf Strukturen 602
  
  • Deklarieren und Initialisieren eines Zeigers auf eine Struktur 603
  • Zugreifen auf Zutaten unter Verwendung eines Zeigers 604
• Strukturen vs. Funktionen 604
  
  • Bestehen der Komponenten von Strukturen 605
  • Verwenden einer Strukturadresse 606
  • Übergeben einer Struktur als Argument 607
  • Mehr zum neuen und verbesserten Zustand der Struktur (607)
  • Strukturen oder Verweise auf Strukturen? (611)
  • Zeichenarrays oder Zeiger auf Zeichen in einer Struktur 612
  • Strukturen, Zeiger und das malloc () 613
  • Zusammengesetzte Literale und Strukturen (C99) 615
  • Flexible Array-Mitglieder (C99) 617
  • Funktionen, die Arrays von Strukturen verwenden 619
• Schreiben des Inhalts einer Struktur in eine Datei
  
  • Programmübersicht 624
• Strukturen: Wie geht es weiter? (625)
• Unie: Ein kurzer Blick (625)
• Aufzählungstypen 628
  
  • Feste Aufzählung (629)
  • Standardwerte (630)
  • Zugewiesene Werte (630)
  • Verwendung von Aufzählungen
  • Der gemeinsame Namensraum 632
• typedef: ein kurzer Blick (632)
• Skurrile Erklärungen (635)
• Funktionen und Zeiger 637
• Schlüsselkonzepte (644)
• Kapitelzusammenfassung (644)
• Wiederholungsfragen 645
• Übungen

Kapitel 15. Bits manipulieren 653

• Binärzahlen, Bits und Bytes 654
  
  • Binäre ganze Zahlen (654)
  • Vorzeichenbehaftete ganze Zahlen (655)
  • Binärer Gleitpunkt 656
• Andere Zahlensysteme (657)
  
  • Das Oktalsystem (657)
  • Hexadezimalsystem 657
• Bitweise Operatoren 659
  
  • Bitweise logische Operatoren 659
  • Anwendung: Masken (660)
  • Verwendung: Drehmeißel 661
  • Verwendung: Bits 662 deaktivieren
  • Verwendung: Reverse-Bits 662
  • Verwendung: Prüfen des Wertes eines Bits (663)
  • Die bitweisen Verschiebungsoperatoren 663
  • Beispiel (665)
  • Ein weiteres Beispiel (666)
• Bitfelder 668
  
  • Beispiel (670)
  • Bitfelder und bitweise Operatoren
• Schlüsselbegriffe 680
• Kapitelzusammenfassung 680
• Wiederholungsfragen 681
• Übungen

Kapitel 16. Der Präprozessor und die C-Bibliothek

• Erste Schritte beim Übersetzen eines Programms
• Symbolische Konstanten: #define (687)
  
  • Jetons (691)
  • Konstanten neu definieren 691
• #define und Argumente 692
  
  • Makroargumente in Strings
  • Präprozessor-Konnektor: Operator ## (696)
  • Makros für Variablennummern: ... und __VA_ARGS__ (697)
• Makro oder Funktion? (698)
• Dateien einschließen: #include (699)
  
  • Header-Dateien: Beispiel (700)
  • Verwendungen für Header-Dateien 702
• Andere Richtlinien (704)
  
  • Die #undef-Richtlinie (704)
  • Definiert: Aus der C-Präprozessor-Perspektive
  • Bedingte Zusammenstellung (705)
  • Vordefinierte Makros 710
  • #line und #error (711)
  • #pragma (712)
  • Inline-Funktionen 713
• Die C-Bibliothek 715
  
  • Zugriff auf die C-Bibliothek 716
  • Funktionsbeschreibungen verwenden 716
• Die Mathematikbibliothek 718
• Die Allgemeine Versorgungsbibliothek
  
  • Exit () und atexit () 721
  • Die qsort()-Funktion 723
  • Verwenden der qsort()-Funktion 725
  • Vergleiche () Funktionsdefinition 726
• Die assert.h-Bibliothek 728
  
  • Die Funktionen memcpy () und memmove () aus der string.h-Bibliothek 729
• Variable Anzahl von Argumenten: stdarg.h 731
  
  • Die Schlüsselausgabe 734
• Kapitelzusammenfassung 734
• Wiederholungsfragen 735
• Übungen

Kapitel 17. Fortgeschrittene Datendarstellung 739

• Kennenlernen der Datenrepräsentation 740
  
  • Verbundene Listen (743)
  • Abstrakte Datentypen (ATD) 751
• Warteschlangen (767)
  
  • Definieren einer Warteschlange als abstrakten Datentyp
  • Simulation mit einer Warteschlange 778
  • Verkettete Liste oder Array? (784)
  • Binäre Bäume 788
  • Was kommt als nächstes? (812)
  • Kernthemen (813)
• Kapitelzusammenfassung (813)
• Wiederholungsfragen 814
  
  • Übungen (815)

Anhang A Beantwortete Überprüfungsfragen 817

Anhang B Zusammenfassung 855

• I. Weiterführende Literatur (855)
• II. Die C-Operatoren 859
• III. Grundtypen und Klassen von Variablen
• IV. Ausdrücke, Anweisungen und Ablaufsteuerung in einem Programm 870
• V. ANSI C-Standardbibliothek und Erweiterungen des C99-Standards (876)
• VI. Erweiterte Integer-Typen 922
• VII. Unterstützung für erweiterte Zeichensätze (926)
• VIII. Effizientere numerische Berechnungen im C99-Standard (932)
• IX. Unterschiede zwischen C und C ++ 936