482.txt ************************************************************************ * Edit v1.001 from 2022-03-01 to 2022-10-04 by HSc * ************************************************************************ C als erste Programmiersprache Vorm Einsteiger zum Profi Joachim Goll, Ulrich Broeckl, Manfred Dausmann Teubner, 4. Auflage 2003 3-519-32999-9 Seite Auszug ======================================================================== 002 GRUNDBEGRIFFE DER PROGRAMMIERUNG ------------------------------------------------------------------------ 002 1.1 Vom Problem zum Programm ------------------------------------------------------------------------ 008 1.2 Nassi-Shneiderman-Diagramme ------------------------------------------------------------------------ 016 1.3 Werkzeuge fuef die Programmierung ------------------------------------------------------------------------ 023 1.4 Zeichen ------------------------------------------------------------------------ 026 1.5 Variablen und Datentypen ------------------------------------------------------------------------ 030 1.6 Entwicklung der hoeheren Programmiersprachen ------------------------------------------------------------------------ 035 1.7 UEbungsaufgaben ------------------------------------------------------------------------ 038 2 EINFUEHRUNG IN DIE PROGRAMMIERSPRACHE C ------------------------------------------------------------------------ 038 2.1 Ursprung von C ------------------------------------------------------------------------ 038 2.2 Standardisierung von C ------------------------------------------------------------------------ 039 2.3 Eigenschaften von C ------------------------------------------------------------------------ 040 2.4 Einordnung der Programmiersprache C ------------------------------------------------------------------------ 041 2.5 C und C++ ------------------------------------------------------------------------ 044 3 LEXIKALISCHE KONVENTIONEN ------------------------------------------------------------------------ 044 3.1 Zeichenvorrat von C ------------------------------------------------------------------------ 045 3.2 Lexikalische Einheiten ------------------------------------------------------------------------ 062 4 ERSTE BEISPIELPROGRAMME ------------------------------------------------------------------------ 062 4.1 Aufbau eines C-Proegramms ------------------------------------------------------------------------ 064 4.2 Das beruehmte Programm "hello, world" ------------------------------------------------------------------------ 066 4.3 Programm zur Zinsberechnung ------------------------------------------------------------------------ 070 4.4 Euklid'scher Algorithmus als Programm ------------------------------------------------------------------------ 072 4.5 UEbungsaufgaben ------------------------------------------------------------------------ 078 5 DATENTYPEN UND VARIABLEN ------------------------------------------------------------------------ 078 5.1 Typkonzept ------------------------------------------------------------------------ 078 5.2 Einfache Datentypen ------------------------------------------------------------------------ 088 5.3 Variablen ------------------------------------------------------------------------ 092 5.4 Typ-Attribute ------------------------------------------------------------------------ 093 5.5 Typen in C ------------------------------------------------------------------------ 094 5.6 Klassifikation von Datentypen ------------------------------------------------------------------------ 095 5.7 UEbungsaufgaben ------------------------------------------------------------------------ 098 6 EINFUEHRUNG IN POINTER UND ARRAYS ------------------------------------------------------------------------ 098 6.1 Pointertypen und Pointervariablen ------------------------------------------------------------------------ 105 6.2 Pointer auf void ------------------------------------------------------------------------ 106 6.3 Eindimensionale Arrays ------------------------------------------------------------------------ 112 6.4 UEbungsaufgaben ------------------------------------------------------------------------ 116 7 ANWEISUNGEN, AUSDRUECKE UND OPERATOREN ------------------------------------------------------------------------ 116 7.1 Operatoren und Operanden ------------------------------------------------------------------------ 118 7.2 Ausdruecke und Anweisungen ------------------------------------------------------------------------ 119 7.3 Nebeneffekte ------------------------------------------------------------------------ 120 7.4 Auswertungsreihenfolge ------------------------------------------------------------------------ 123 7.5 L-Werte und R-Werte ------------------------------------------------------------------------ 125 7.6 Zusammenstellung der Operatoren ------------------------------------------------------------------------ 134 7.6.5 Logische Operatoren ------------------------------------------------------------------------ 134 - Operatoren fuer das logisch UND: && - Operatoren fuer das logisch ODER: || - Logisch Negationsoperator: ! 137 7.6.6 Bit-Operatoren ------------------------------------------------------------------------ 137 - UND-Operator fuer Bits: & - ODER-Operator fuer Bits: | - Exklusiv-ODER-Operator fuer Bits: ^ - Negatsionsoperator fuer Bits: ~ - Rechtsshift-Operator: >> - Linksshift-Operator: << 148 7.7 Impzite Tyumwandlung ------------------------------------------------------------------------ 155 7.8 Sequenzpunkte bei Nebeneffekten ------------------------------------------------------------------------ 157 7.9 UEbungsaufgaben ------------------------------------------------------------------------ 162 8 KONTROLLSTRUKTUREN ------------------------------------------------------------------------ 162 8.1 Bloecke - Kontrollstrukturen fuer die Sequenz ------------------------------------------------------------------------ 162 8.2 Selektion ------------------------------------------------------------------------ 169 8.3 Iteration ------------------------------------------------------------------------ 180 8.4 Sprunganweisungen ------------------------------------------------------------------------ 184 8.5 UEbungsaufgaben ------------------------------------------------------------------------ 188 9 BLOECKE UND FUNKTIONEN ------------------------------------------------------------------------ 188 9.1 Struktur eines Blockes ------------------------------------------------------------------------ 189 9.2 Sichtbarkeit und Lebensdauer ------------------------------------------------------------------------ 193 9.3 Definition und Aufruf von Funktionen ------------------------------------------------------------------------ 202 9.4 Deklaration von Funktionen ------------------------------------------------------------------------ 206 9.5 Gueltigkeitsbereiche von Namen ------------------------------------------------------------------------ 206 9.6 Alte Funktionsdefinition und -deklaration nach Kernighan und Ritchie ------------------------------------------------------------------------ 207 9.7 Die Ellipse - ein Mittel fuer variable Parameteranzahlen ------------------------------------------------------------------------ 210 9.8 Rekursive Funktionen ------------------------------------------------------------------------ 220 9.9 UEbungsaufgaben ------------------------------------------------------------------------ 228 10 FORTGESCHRITTENE PROGRAMMIERUNG MIT POINTERN. ------------------------------------------------------------------------ 228 10.1 Arrays ------------------------------------------------------------------------ 242 10.2 UEbergabe von Arrays und Zeichenketten ------------------------------------------------------------------------ 244 10.3 Vergleich von char-Arrays und Pointern auf Zeichenketten ------------------------------------------------------------------------ 245 10.4 Das Schluesselwort const bei Pointern und Arrays ------------------------------------------------------------------------ 247 10.5 Kopieren von Zeichenketten ------------------------------------------------------------------------ 249 10.6 Standardfunktionen zur Stringverarbeitung und Speicherbearbeitung ------------------------------------------------------------------------ 260 10.7 Vektoren von Pointern und Pointer auf Pointer ------------------------------------------------------------------------ 264 10.8 Pointer auf Funktionen ------------------------------------------------------------------------ 270 10.9 UEbungsaufgaben ------------------------------------------------------------------------ 278 11 STRUKTUREN, UNIONEN UND BITFELDER ------------------------------------------------------------------------ 278 11.1 Strukturen ------------------------------------------------------------------------ 278 11.1.7 Anwendungsmoeglichkeiten von Strukturen ------------------------------------------------------------------------ 286 struct tm ... localtime() ... time() 288 Beispiel Dateiinfo struct stat ... DateiInfo mit Laufwerk, ..., Datum des letzten Zugriffs/Aenderung/Erstellung 290 11.2 Unionen ------------------------------------------------------------------------ 294 11.3 Bitfelder - Komponenten von Strukturen und Unionen ------------------------------------------------------------------------ 294 11.3 Bitfelder - Komponenten von Strukturen und Unionen ------------------------------------------------------------------------ 294 ..., Bits zu gruppieren. 296 Ein Bitfeld ... mit einem Punkt-Operator . angesprochen. 301 11.4 UEbungsaufgaben ------------------------------------------------------------------------ 308 12 KOMPLEXERE DATENTYPEN, EIGENE TYPNAMEN UND NAMENSRAEUME ------------------------------------------------------------------------ 308 12.1 Komplexere Vereinbarungen ------------------------------------------------------------------------ 310 12.2 Komplexere Typen ------------------------------------------------------------------------ 310 12.3 typedef zur Vereinbarung eigener Typnamen ------------------------------------------------------------------------ 313 12.4 Namensraeume ------------------------------------------------------------------------ 316 13 SPEICHERKLASSEN ------------------------------------------------------------------------ 316 13.1 Adressraum eines Programms ------------------------------------------------------------------------ 318 13.2 Programme aus mehreren Dateien - Adressen ------------------------------------------------------------------------ 319 13.3 Programme aus mehrerep Dateien - die Speicherklasse extern ------------------------------------------------------------------------ 324 13.4 Programme aus mehreren Dateien - die Speicherklasse static ------------------------------------------------------------------------ 325 13.5 Speicherklassen bei lokalen Variablen ------------------------------------------------------------------------ 330 13.6 Initialisierung ------------------------------------------------------------------------ 330 13.7 Interne und externe Bindung von Nmep ------------------------------------------------------------------------ 331 13.8 Tabellarischer UEberblick ueber die Speicherklassen ------------------------------------------------------------------------ 332 13.9 UEbungsaufgaben ------------------------------------------------------------------------ 336 14 EIN- UND AUSGABE ------------------------------------------------------------------------ 336 14.1 Speicherung von Daten in Dateisystemen ------------------------------------------------------------------------ 338 14.2 Dateien unter UNIX - das Streamkonzept ------------------------------------------------------------------------ 338 14.3 Schichtenmodell fuer die Ein- und Ausgabe ------------------------------------------------------------------------ 340 14.4 Das Ein-/Ausgabe-Konzept von C ------------------------------------------------------------------------ 341 14.5 Standardeingabe und -ausgabe ------------------------------------------------------------------------ 344 14.6 C-Bibliotheksfunktionen zur Ein- und Ausgabe ------------------------------------------------------------------------ 345 14.7 High-Level-Funktioneh fuer die Standardeingabe und -ausgabe ------------------------------------------------------------------------ 356 14.7.3 Stringweise Ausgabe mit der Funktion puts() ------------------------------------------------------------------------ 356 int puts(const char * s); ... ... EOF 370 14.8 High-Level-Dateizugritfsfunktionen ------------------------------------------------------------------------ 371 14.8.1.1 Die Funktion fopen() ------------------------------------------------------------------------ 371 Tabelle 14-3 Der Parameter mode der Funktion fopen() 374 14.8.1.2 Die Funktion fclose() ------------------------------------------------------------------------ 376 14.8.1.3 Die Funktion remove() ------------------------------------------------------------------------ 377 14.8.1.4 Die Funktion fflush() ------------------------------------------------------------------------ 379 14.8.2 Formatiere Ein-/Ausgabe von Daten ------------------------------------------------------------------------ 379 14.8.2.1 Die Funktion fprintf() ------------------------------------------------------------------------ 380 14.8.2.2 Die Funktion fscanf() ------------------------------------------------------------------------ 381 14.8.3 Ein-/Ausgabe von Zeichen ------------------------------------------------------------------------ 381 14.8.3.1 Die Funktion fputc() ------------------------------------------------------------------------ 382 14.8.3.2 Die Funktion fgetc() ------------------------------------------------------------------------ 383 14.8.3.3 Die Funktion ungetc() ------------------------------------------------------------------------ 396 14.9 UEbungsaufgaben ------------------------------------------------------------------------ 404 UEBERGABEPARAMETER UND RUECKGABEWERT EINES PROGRAMMS ------------------------------------------------------------------------ 404 15.1 UEbergabe von Parametern beim Programmufruf ------------------------------------------------------------------------ 406 15.2 Beendigung von Programmen ------------------------------------------------------------------------ 412 16 DYNAMISCHE SPEICHERZUWEISUNG, LISTEN UND BAEUME ------------------------------------------------------------------------ 414 16.1 Reservierung von Speicher ------------------------------------------------------------------------ 418 16.2 Rueckgabe von Speicher ------------------------------------------------------------------------ 419 16.3 Verkettete Listen ------------------------------------------------------------------------ 427 16.4 Baumstrukturen ------------------------------------------------------------------------ 444 16.5 UEbungsaufgaben ------------------------------------------------------------------------ 450 17 INTERNE SUCH- UND SORTIERVERFAHREN ------------------------------------------------------------------------ 450 17.1 Interne Sortierverfahren ------------------------------------------------------------------------ 460 17.2 Interne Suchverfahren ------------------------------------------------------------------------ 488 18 PRAEPROZESSOR ------------------------------------------------------------------------ 488 18.1 Aufgaben des Praeprozessors ------------------------------------------------------------------------ 489 18.2 Einfuegen von Dateien in den Source-Code ------------------------------------------------------------------------ 490 18.3 Symbolische Konstanten und Makros mit Parametern ------------------------------------------------------------------------ 494 18.4 Bedingte Kompilierung ------------------------------------------------------------------------ 497 18.5 Informationen ueber den UEbersetzungskontext ------------------------------------------------------------------------ 498 18.6 Weitere Praeprozessor-Direktiven ------------------------------------------------------------------------ 500 19 SOFTWARE ENGINEERING INC ------------------------------------------------------------------------ 500 19.1 Structured Design ------------------------------------------------------------------------ 500 19.2 Moduelar Design ------------------------------------------------------------------------ 503 19.3 Umsetzung des Modular Designs in C ------------------------------------------------------------------------ 504 19.4 Trennung von Schnittstelle und Implementierung in C ------------------------------------------------------------------------ 506 19.5 Realisierung eines Stacks mit Modular Design in C ------------------------------------------------------------------------ 514 19.6 UEbungsaufgaben ------------------------------------------------------------------------ 515 ANHANG A STANDARDBIBLIOTHEKSFUNKTIONEN ------------------------------------------------------------------------ 515 A.1 Fehlersuche (assert.h) ------------------------------------------------------------------------ 515 A.2 Klassifizierung und Konvertierung von Zeichen (ctype.h) ------------------------------------------------------------------------ 516 A.3 Laenderspezifische Darstellungen und Zeichen (locale.h) ------------------------------------------------------------------------ 516 A.4 Mathematische Funktionen (math.h) ------------------------------------------------------------------------ 517 A.5 Globale Spruenge (setjmp.h) ------------------------------------------------------------------------ 517 A.6 Signalbehandlungen (signal.h) ------------------------------------------------------------------------ 517 A.7 Behandlung einer variablen Parameterliste (stdarg.h) ------------------------------------------------------------------------ 517 A.8 Ein- und Ausgabe (stdio.h) ------------------------------------------------------------------------ 519 A.9 Zahlenkonvertierung, Speicherverwaltung, Zufallszahlengenerierung und Beenden von Programmen (stdlib.h) ------------------------------------------------------------------------ 520 A.10 String- und Speicherbearbeitung (string.h) ------------------------------------------------------------------------ 521 All Datum und Uhrzeit (time.h) ------------------------------------------------------------------------ 523 ANHANG B LOW-LEVEL-DATEIZUGRIFFSFUNKTIONEN ------------------------------------------------------------------------ 524 B.1 Dateioperationen ------------------------------------------------------------------------ 528 B.2 Ein-/Ausgabe ------------------------------------------------------------------------ 529 B.3 Positionieren in Dateien ------------------------------------------------------------------------ 530 B.4 Beispiel zur Dateibearbeitung mit Low-Level-Funktionen ------------------------------------------------------------------------ 532 ANHANG C WANDLUNGEN ZWISCHEN ZAHLENSYSTEMEN ------------------------------------------------------------------------ 532 C.1 Vorstellung der Zahlensysteme ------------------------------------------------------------------------ 533 C.2 Umwandlung von Dual/Hexadezimal in Dezimal ------------------------------------------------------------------------ 533 C.3 Umwandlung von Dezimal in Dual/Hexadezimal ------------------------------------------------------------------------ 536 C.4 Umwandlung von Dual in Hexadezimal und von Hexadezimal in Dual ------------------------------------------------------------------------ 538 LITERATURVERZEICHNIS ------------------------------------------------------------------------ 539 INDEX ------------------------------------------------------------------------ 548 TABELLEN FUER DEN SCHNELLEN ZUGRIFF ------------------------------------------------------------------------ 550 Umwandlungszeichen fuer printf() und scanf(): ... 551 Siehe auch printf() Kapitel 14.7.1 bzw. scanf() Kapitel 14.7.4 ******* EOF ************************************************************