C als erste Programmiersprache: Vom Einsteiger zum Profi

587 Pages·2008·9.379 MB·German

by  Manfred Dausmann, Ulrich Bröckl, Joachim Goll

Manfred Dausmann, Ulrich Bröckl,
Joachim Goll
C als erste
Programmiersprache
Manfred Dausmann,
Ulrich Bröckl,
Joachim Goll
C als erste
Programmiersprache
Vom Einsteiger zum Profi
6., überarbeitete Auflage
Bibliografische Information der Deutschen Nationalbibliothek
Die Deutsche Nationalbibliothek verzeichnet diese Publikation in der
Deutschen Nationalbibliografie; detaillierte bibliografische Daten sind im Internet über
<http://dnb.d-nb.de> abrufbar.
Prof. Dr. Manfred Dausmann, Jahrgang 1951, ist seit 1996 Professor an der Hoch-
schule Esslingen. Er lehrt in der Fakultät Informationstechnik die Fächer Program-
miersprachen, Compilerbau, Software Engineering und Betriebssysteme. In seiner
Industrielaufbahn befasste er sich vor allem mit dem Bau von Ada-Compilern und der
Basis-Software für SAP R/3. Beim Steinbeis-Transferzentrum Softwaretechnik Esslingen
ist er zuständig für Programmiersprachen und die Standard-Software SAP R/3.
Prof. Dr. Ulrich Bröckl, Jahrgang 1961, ist seit 1999 Professor. Er lehrt die Fächer
Mensch-Maschine-Interaktion und Datenbanken an der Hochschule Karlsruhe –
Technik und Wirtschaft. Der Schwerpunkt seiner Tätigkeit in der Industrie war die
Konzeption und Realisierung von verteilten objektorientierten Systemen. Beim Stein-
beis-Transferzentrum Softwaretechnik ist er zuständig für Grafische Oberflächen und
Mustererkennung.
Prof. Dr. Joachim Goll, Jahrgang 1947, unterrichtet seit 1991 in der Fakultät Infor-
mationstechnik der Hochschule Esslingen die Fächer Programmiersprachen, Betriebs-
systeme, Software Engineering, Objektorientierte Modellierung und Sichere Systeme.
Während seiner beruflichen Tätigkeit in der Industrie befasste er sich vor allem mit dem
Entwurf von verteilten Informationssystemen. Prof. Goll ist Leiter des Steinbeis-Trans-
ferzentrums Softwaretechnik Esslingen und Technischer Leiter der Firma IT-Designers
GmbH in Esslingen.
1. Auflage 1998
6., überarbeitete Auflage 2008
Alle Rechte vorbehalten
© B.G.Teubner Verlag / GWV Fachverlage GmbH, Wiesbaden 2008
Lektorat: Ulrich Sandten / Kerstin Hoffmann
Der B. G. Teubner Verlag ist ein Unternehmen von Springer Science+Business Media.
www.teubner.de
Das Werk einschließlich aller seiner Teile ist urheberrechtlich ge schützt. Jede Verwertung
außerhalb der engen Grenzen des Ur heber rechts gesetzes ist ohne Zustimmung des Ver-
lags unzuläs sig und strafb ar. Das gilt insbesondere für Vervielfältigungen, Übersetzun gen,
Mikro ver filmungen und die Ein speiche rung und Verarbeitung in elek tron ischen Syst emen.
Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk be-
rechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der
Waren- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von jedermann benutzt
werden dürften.
Umschlaggestaltung: Ulrike Weigel, www.CorporateDesignGroup.de
Druck und buchbinderische Verarbeitung: Strauss Offsetdruck, Mörlenbach
Gedruckt auf säurefreiem und chlorfrei gebleichtem Papier.
Printed in Germany
ISBN 978-3-8351-0222-4
Vorwort
Zum Inhalt
Die Programmiersprache C wurde im Jahre 1989 durch das American National
Standards Institute1 und im Jahre 1990 durch die International Organization for
Standardization2 standardisiert. Seit dieser Zeit hat sie einen rasanten Aufschwung
erlebt. Sie steht heute als ANSI- und als ISO-Standard in einheitlicher Form auf
praktisch allen Computern und Betriebssystemen zur Verfügung.
Grundlage für dieses Buch ist der bereits erwähnte ANSI/ISO C-Standard aus dem
Jahre 1990 – kurz C90 genannt. Er wird von den allermeisten Compilern unterstützt
und ist auch in der industriellen Praxis am weitesten verbreitet.
Das vorliegende Buch wendet sich an Studierende der Informatik und der
ingenieurswissenschaftlichen Disziplinen, berufliche Umsteiger und Schüler, welche
das Interesse haben, die Grundlagen der Programmiersprache C fundiert zu
erlernen. Das Buch hat den Titel „C als erste Programmiersprache“, weil es dem
engagierten Neuling erlaubt, C ohne Vorkenntnisse anderer Programmiersprachen
zu erlernen. Dabei hat dieses Buch das ehrgeizige Ziel, dem Leser die
Sprachkonzepte von C so präzise wie möglich und dennoch in leicht verständlicher
Weise vorzustellen. Es wird von den Autoren seit einigen Jahren erfolgreich im
Unterricht im ersten Semester an der Fachhochschule und an Gymnasien eingesetzt.
Wegweiser durch das Buch
„Lernkästchen“, auf die grafisch durch eine kleine Glühlampe ( ) aufmerksam
gemacht wird, stellen eine Zusammenfassung eines Kapitels dar. Sie erlauben eine
rasche Wiederholung des Stoffes. Ein fortgeschrittener Leser kann mit ihrer Hilfe
gezielt bis zu der Stelle vorstoßen, an der für ihn ein detaillierter Einstieg erforderlich
wird.
„Warnkästchen“, die durch ein Vorsicht-Symbol ( Vorsicht! ) gekennzeichnet sind, zeigen
Fallen und typische, gern begangene Fehler an, die in der Praxis oft zu langwierigem
Fehlersuchen führen oder noch schlimmer, erst im Endprodukt beim Kunden erkannt
werden.
Gerade als Anfänger in einer Programmiersprache macht man gerne den Fehler,
sich beim Lesen an nicht ganz so wesentlichen Einzelheiten fest zu beißen. Um zu
erkennen, welche Information grundlegend für das weitere Vorankommen ist und
welche Information nur ein Detailwissen darstellt – und deshalb auch noch zu einem
späteren Zeitpunkt vertieft werden kann – weist dieses Buch Kapitel oder Kapitelteile,
die beim ersten Lesen übersprungen werden können, mit dem Symbol aus.

1 Abgekürzt als ANSI.
2 Abgekürzt als ISO.
Generell ist es empfehlenswert, ein oder mehrere Kapitel zu überfliegen, um sich
einen Überblick zu verschaffen, und dann erst mit der Feinarbeit zu beginnen und
gründlicher zu lesen. Dennoch gilt: Eine Vorgehensweise, die sich für den einen
Leser als optimal erweist, muss noch lange nicht für alle Leser das Allheilmittel
darstellen. Wenn Sie zu den Lesern gehören, die es gewohnt sind, von Anfang an
möglichst detailliert zu lesen, um möglichst viel sofort zu verstehen, so sollten Sie
zumindest darauf achten, dass Sie in den Kapiteln mit dem „Überspringe und komm
zurück“-Zeichen beim ersten Durchgang nicht zu lange verweilen.
Bei all den guten Ratschlägen gilt: Programmieren hat man zu allen Zeiten durch
Programmierversuche erlernt. „Do it yourself“ heißt der rote Faden zum Erfolg. So
wie ein Kleinkind beim Erlernen der Muttersprache einfach zu sprechen versucht, so
sollten auch Sie möglichst früh versuchen, in der Programmiersprache zu sprechen –
das heißt, eigene Programme zu schreiben. Gestalten Sie den Lernvorgang ab-
wechslungsreich – lesen Sie einen Teil und versuchen Sie, das Erlernte gleich in
Programme umzusetzen. Um die mühsame Tipparbeit am Anfang minimal zu halten,
sind alle Beispielprogramme des Buches auf der CD zu finden.
Praktisch jedes Kapitel enthält Übungsaufgaben, die zum selbstständigen
Programmieren auffordern. Lösungen wurden jedoch absichtlich nicht in das Buch
aufgenommen, um nicht zum vorschnellen Nachschlagen zu verleiten. Sie finden die
Lösungen auf der beigelegten CD. Auch die Übungsaufgaben sind mit auf der CD
enthalten. Daher können Sie dort, wo Programme zu ergänzen bzw. zu erweitern
sind, Aufgaben-Dateien der CD als Ausgangspunkt nehmen, um unnötige Tipparbeit
zu sparen.
Schreibweisen
In diesem Buch sind der Quellcode und die Ein-/Ausgabe von ganzen Beispiel–
programmen sowie einzelne Anweisungen in der Schriftart Courier New
geschrieben. Dasselbe gilt für Programmteile wie Variablennamen, Funktionsnamen
etc., die im normalen Text erwähnt werden. Einige Programmbeispiele enthalten
Platzhalter wie Anweisung oder Bedingung für konkrete Anweisungen oder
Ausdrücke in der Programmiersprache. Ihre Rolle als Platzhalter ist jedoch so
offensichtlich, dass für sie keine eigene Schriftart verwendet wurde. Sie sind wie die
Wörter der Sprache in Courier New geschrieben. Wichtige Begriffe im normalen
Text sind fett gedruckt, um sie hervorzuheben.
Wichtige Hinweise zur CD
Die beigelegte CD enthält im Ordner C_Buch die Übungsaufgaben, die zugehörigen
Lösungen sowie die Beispiele des Buches. Ebenfalls in diesem Ordner finden Sie die
Bilder der einzelnen Kapitel als Unterstützung für Lehrende, die selber einen C-Kurs
auf der Basis dieses Buches gestalten wollen.
Auf dieser CD wird ferner das Microsoft Visual Studio in der Express Edition mit dem
Visual C++ Compiler kostenlos mitgeliefert, damit sofort mit dem Programmieren
begonnen werden kann. Der Visual C++ Compiler kann neben der Sprache C++
auch die im Buch behandelte Sprache C verarbeiten. Wir danken der Microsoft
GmbH für diese Unterstützung.
Hinweise zum Gebrauch der CD befinden sich im Hauptverzeichnis der CD in der
DateiLiesmich.txt
Ihre Verbesserungsvorschläge
Ihre Verbesserungsvorschläge und kritischen Hinweise, die wir weiter gerne an-
nehmen, erreichen uns unter der Adresse:
Prof. Dr. Manfred Dausmann
Hochschule Esslingen
Fakultät Informationstechnik
Flandernstraße 101
73732 Esslingen
oder via E-Mail:
[email protected]
Danksagung
Unser Dank bei der 6. Auflage gilt Herrn Volker Kugler, der in bewährter Weise das
Configuration Management für alle Einzeldokumente des Buches ausgeübt hat. Nur
so konnten wir unsere Änderungen so schnell und problemlos durchführen. Herr
Kugler hat außerdem alle Übungsbeispiele mit dem neuen Compiler überprüft,
sodass wir die neue CD unbesorgt aus den Händen geben können.
Zu den letzten Auflagen haben wir von Ihnen, liebe Leser, viele wertvolle Korrekturen
und Anregungen erhalten, die wesentlich zur Qualitätssteigerung beigetragen haben.
Dafür herzlichen Dank!
Esslingen, im Dezember 2007 M. Dausmann / U. Bröckl / J. Goll
Inhaltsverzeichnis
1 Grundbegriffe der Programmierung ................................................ 2
1.1 Das erste Programm .................................................................................... 2
1.2 Vom Problem zum Programm ...................................................................... 3
1.3 Nassi-Shneiderman-Diagramme ................................................................ 12
1.4 Vom Algorithmus zum Programm ............................................................... 18
1.5 Zeichen ...................................................................................................... 20
1.6 Variablen .................................................................................................... 21
1.7 Datentypen ................................................................................................. 23
1.8 Unterprogramme ........................................................................................ 27
1.9 Programmerzeugung und -ausführung ....................................................... 32
1.10 Übungsaufgaben ........................................................................................ 40
2 Einführung in die Programmiersprache C .................................... 42
2.1 Ursprung von C .......................................................................................... 42
2.2 Standardisierungvon C .............................................................................. 42
2.3 Eigenschaften von C .................................................................................. 43
2.4 C und C++ .................................................................................................. 44
2.5 Einordnung der Programmiersprache C ..................................................... 44
2.6 Abstraktionsgrad in Programmiersprachen ................................................ 46
3 Einfache Beispielprogramme ......................................................... 52
3.1 Programm zur Ausgabe von Quadratzahlen .............................................. 52
3.2 Programm zur Zinsberechnung .................................................................. 56
3.3 Euklid’scher Algorithmus als Programm ..................................................... 59
3.4 Definition eigener Funktionen ..................................................................... 60
3.5 Struktur einer Quelldatei ............................................................................. 64
3.6 Übungsaufgaben ........................................................................................ 70
4 Lexikalische Konventionen ............................................................ 76
4.1 Zeichenvorratvon C ................................................................................... 76
4.2 Lexikalische Einheiten ................................................................................ 77
4.3 Übungsaufgaben ........................................................................................ 93
5 Datentypen und Variablen .............................................................. 96
5.1 Typkonzept ................................................................................................. 96
5.2 Einfache Datentypen.................................................................................. 96
5.3 Variablen .................................................................................................. 106
5.4 Typ-Attribute const und volatile ................................................................ 111
X Inhaltsverzeichnis
5.5 Typen in C ................................................................................................ 111
5.6 Klassifikation von Datentypen .................................................................. 112
5.7 Übungsaufgaben ...................................................................................... 113
6 Einführung in Pointer und Arrays ................................................ 116
6.1 Pointertypen und Pointervariablen ........................................................... 116
6.2 Pointer auf void ........................................................................................ 123
6.3 EindimensionaleArrays ............................................................................ 124
6.4 Übungsaufgaben ...................................................................................... 130
7 Anweisungen, Ausdrücke und Operatoren ................................ 134
7.1 Operatoren und Operanden ..................................................................... 134
7.2 Ausdrücke und Anweisungen ................................................................... 136
7.3 Nebeneffekte ............................................................................................ 137
7.4 Auswertungsreihenfolge ........................................................................... 138
7.5 L-Werte und R-Werte ............................................................................... 141
7.6 Zusammenstellung der Operatoren .......................................................... 143
7.7 Implizite Typumwandlung ......................................................................... 167
7.8 Sequenzpunkte bei Nebeneffekten .......................................................... 174
7.9 Übungsaufgaben ...................................................................................... 176
8 Kontrollstrukturen ......................................................................... 182
8.1 Blöcke – Kontrollstrukturen für die Sequenz............................................ 182
8.2 Selektion .................................................................................................. 183
8.3 Iteration .................................................................................................... 189
8.4 Sprunganweisungen................................................................................. 200
8.5 Übungsaufgaben ...................................................................................... 204
9 Blöcke und Funktionen ................................................................ 208
9.1 Struktur eines Blockes .............................................................................. 208
9.2 Gültigkeit, Sichtbarkeit und Lebensdauer ................................................. 210
9.3 Definition und Aufruf von Funktionen ....................................................... 214
9.4 Deklaration von Funktionen ...................................................................... 222
9.5 Gültigkeitsbereiche von Namen ................................................................ 226
9.6 Alte Funktionsdefinition und -deklaration nach Kernighan und Ritchie ..... 227
9.7 Die Ellipse ... – ein Mittel für variable Parameteranzahlen ....................... 228
9.8 Rekursive Funktionen ............................................................................... 230
9.9 Übungsaufgaben ...................................................................................... 241
Inhaltsverzeichnis XI
10 Fortgeschrittene Programmierung mit Pointern ........................ 250
10.1 Arrays....................................................................................................... 250
10.2 Übergabe von Arrays und Zeichenketten ................................................. 264
10.3 Vergleich von char-Arrays und Pointern auf Zeichenketten ..................... 266
10.4 Das Schlüsselwort const bei Pointern und Arrays .................................... 267
10.5 Kopieren von Zeichenketten ..................................................................... 269
10.6 Standardfunktionen zur Stringverarbeitung und Speicherbearbeitung ..... 271
10.7 Vektoren von Pointern und Pointer auf Pointer ........................................ 282
10.8 Pointer auf Funktionen ............................................................................. 287
10.9 Übungsaufgaben ...................................................................................... 292
11 Strukturen, Unionen und Bitfelder ............................................... 300
11.1 Strukturen ................................................................................................. 300
11.2 Unionen .................................................................................................... 312
11.3 Bitfelder – Komponenten von Strukturen und Unionen ............................ 317
11.4 Übungsaufgaben ...................................................................................... 324
12 Komplexere Datentypen, eigene Typnamen und
Namensräume ............................................................................... 332
12.1 Komplexere Vereinbarungen .................................................................... 332
12.2 Komplexere Typen ................................................................................... 334
12.3 typedef zur Vereinbarung eigener Typnamen.......................................... 334
12.4 Namensräume .......................................................................................... 336
13 Speicherklassen ............................................................................ 340
13.1 Adressraum eines Programms ................................................................. 340
13.2 Programme aus mehreren Dateien – Adressen....................................... 342
13.3 Programme aus mehreren Dateien – die Speicherklasse extern ............. 343
13.4 Programme aus mehreren Dateien – die Speicherklasse static ............... 348
13.5 Speicherklassen bei lokalen Variablen ..................................................... 350
13.6 Initialisierung ............................................................................................ 354
13.7 Interne und externe Bindung von Namen ................................................. 355
13.8 Tabellarischer Überblick über die Speicherklassen .................................. 356
13.9 Übungsaufgaben ...................................................................................... 357
14 Ein- und Ausgabe .......................................................................... 360
14.1 Speicherung von Daten in Dateisystemen............................................... 360
14.2 Dateien unter UNIX – das Streamkonzept ............................................... 361
14.3 Schichtenmodell für die Ein- und Ausgabe ............................................... 362
14.4 Das Ein-/Ausgabe-Konzept von C ............................................................ 363
XII Inhaltsverzeichnis
14.5 Standardeingabe und -ausgabe ............................................................... 365
14.6 C-Bibliotheksfunktionen zur Ein- und Ausgabe........................................ 368
14.7 High-Level-Funktionen für die Standardeingabe und -ausgabe ............... 369
14.8 High-Level-Dateizugriffsfunktionen ........................................................... 394
14.9 Übungsaufgaben ...................................................................................... 420
15 Übergabeparameter und Rückgabewert eines Programms ...... 428
15.1 Übergabe von Parametern beim Programmaufruf .................................... 428
15.2 Beendigung von Programmen ................................................................ 430
16 Dynamische Speicherzuweisung, Listen und Bäume ............... 436
16.1 Reservierung von Speicher ...................................................................... 438
16.2 Freigabe von Speicher ............................................................................. 442
16.3 Dynamisch erzeugte Arrays ..................................................................... 444
16.4 VerketteteListen ...................................................................................... 445
16.5 Baumstrukturen ........................................................................................ 453
16.6 Übungsaufgaben ...................................................................................... 470
17 Sortieren und Suchen ................................................................... 476
17.1 Interne Sortierverfahren ........................................................................... 477
17.2 Einfache Suchverfahren ........................................................................... 487
17.3 Suchen nach dem Hashverfahren............................................................ 490
17.4 Rekursives Suchen mit Backtracking ....................................................... 508
17.5 Übungsaufgaben ...................................................................................... 513
18 Präprozessor ................................................................................. 516
18.1 Aufgaben des Präprozessors ................................................................... 516
18.2 Einfügen von Dateien in den Source-Code .............................................. 517
18.3 Symbolische Konstanten und Makros mit Parametern ............................. 518
18.4 Bedingte Kompilierung ............................................................................. 522
18.5 Informationen über den Übersetzungskontext .......................................... 525
18.6 Weitere Präprozessor-Direktiven .............................................................. 526
19 Software Engineering in C ........................................................... 528
19.1 Structured Design ..................................................................................... 528
19.2 Modular Design ........................................................................................ 528
19.3 Umsetzung des Modular Designs in C ..................................................... 532
19.4 Realisierung eines Stacks mit Modular Design in C ................................. 536
19.5 Übungsaufgaben ...................................................................................... 544