Einf ¨uhrung in C/C++ - Digital

Einf ¨uhrung in C/C++ - Digital
@
@
@
@
@
@
@
@
@
@
@
¨
Einfuhrung
in C/C++
W. Alex
2004
¨ Karlsruhe
Universitat
Copyright 2000, 2002, 2003, 2004 by Wulf Alex, Karlsruhe
Permission is granted to copy, distribute and/or modify this document under
the terms of the GNU Free Documentation License, Version 1.2 or any later
version published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the license
is included in the section entitled GNU Free Documentation License on page
305.
Ausgabedatum: 24. November 2004.
Email:
[email protected]
¨
¨ Fehler.
Dies ist ein Skriptum. Es ist unvollstandig
und enthalt
¨
Geschutzte
Namen wie UNIX oder Postscript sind nicht gekennzeichnet.
Geschrieben mit dem Editor vi(1), formatiert mit LaTeX unter Debian
GNU/Linux.
¨
Hinweise auf erganzendes
Material finden sich auf:
http://www.mvm.uni-karlsruhe.de/skriptum/
http://www.mvm.uni-karlsruhe.de/technik.html
Von den Skripten gibt es neben der Normalausgabe eine Ausgabe in kleinerer
¨
Schrift (9 Punkte), in großer Schrift (14 Punkte) sowie eine Textausgabe fur
Leseprogramme (Screenreader). Bei Springer, Heidelberg ist 1999 ein Buch
erschienen, das auf den Skripten und weiteren Texten aufbaut: W. Alex u. a.:
UNIX, C und Internet, ISBN 3-540-65429-1.
There is an old system called UNIX,
suspected by many to do nix,
but in fact it does more
than all systems before,
and comprises astonishing uniques.
Vorwort
Die Skripten richten sich an Leser mit wenigen Vorkenntnissen in der
Elektronischen Datenverarbeitung; sie sollen – wie F RITZ R EUTERS Urge¨ die wisschicht von Meckelnborg – ok f¨or Schaulkinner tau bruken sin. Fur
senschaftliche Welt zitiere ich aus dem Vorwort zu einem Buch des Mathematikers R ICHARD C OURANT: Das Buch wendet sich an einen weiten Kreis:
an Schuler
¨
und Lehrer, an Anfanger
¨
und Gelehrte, an Philosophen und Ingenieure. Das Lernziel ist eine Vertrautheit mit Betriebssystemen der Gattung
UNIX einschließlich Linux, der Programmiersprache C/C++ und dem weltumspannenden Computernetz Internet, die so weit reicht, dass der Leser mit
¨
der Praxis beginnen und sich selbstandig
weiterbilden kann. Ausgelernt hat
man nie.
Warum ein Linux/UNIX? Die Betriebssysteme der Gattung UNIX sind die
ersten und bisher einzigen, die auf einer Vielzahl von Computertypen laufen.
¨
Unter den verbreiteten Betriebssystemen sind sie die altesten
und daher aus¨
gereift. Die UNIXe haben sich lange ohne kommerzielle Einflusse
entwickelt
und tun das teilweise heute noch, siehe Linux, FreeBSD, NetBSD, OpenBSD
und andere. Programmierer, nicht das Marketing, haben die Ziele gesetzt. Die
UNIXe haben von Anfang an gemischte Hardware und die Zusammenarbeit
¨
mehrerer Benutzer unterstutzt.
In Verbindung mit dem X Window System
¨
(X11), einem netzfahigen
Fenstersystem, sind die UNIXe unter den Betriebs¨
systemen mittlerer Gr¨oße die leistungsfahigsten.
Linux/UNIX-Rechner waren von Anbeginn im Internet dabei und haben seine Entwicklung bestimmt.
¨
Warum C/C++? Die universelle Programmiersprache C mit ihrer machtigen Erweiterung C++ ist – im Vergleich zu BASIC etwa – ziemlich einheitlich. Der Anfang ist leicht, an die Grenzen stoßen wenige Benutzer. Das
Zusammenspiel zwischen C/C++-Programmen und Linux/UNIX funktioniert
reibungslos.
Warum das Internet? Das Internet ist das gr¨oßte Computernetz dieser
¨
Erde, ein Zusammenschluss vieler regionaler Netze. Ursprunglich
auf Hoch¨
schulen und Beh¨orden beschrankt,
sind mittlerweile auch Industrie und Handel beteiligt. Unser berufliches Leben und zunehmend unser privates Dasein
¨
werden vom Internet beruhrt.
Eine Email-Anschrift ist so wichtig wie ein Telefonanschluss. Als Informationsquelle ist das Netz unentbehrlich.
Wenn Ihnen diese drei Themen – Linux/UNIX, C/C++ und Internet – ver¨
¨
¨ den Umtraut geworden sind, verfugen
Sie uber
eine solide Grundlage fur
gang mit Computern.
Der Text besteht insgesamt aus sechs Teilen. Nach ersten Schritten zur
Eingew¨ohnung in den Umgang mit dem Computer beschreibt der zweite Teil
v
vi
kurz die Hardware, der dritte Betriebssysteme der Gattung UNIX, der vier¨
te die Programmiersprache C/C++ und der funfte
das Internet samt seinen
¨ Fakten, die man immer wieder braucht. Bei
Diensten. Ein Anhang enthalt
der Stoffauswahl habe ich mich von meiner Arbeit als Benutzer und Verwalter vernetzter Systeme sowie als Programmierer leiten lassen.
¨
Besonderer Wert wird auf die Erlauterung
der zahlreichen Fachbegriffe
¨
gelegt, die dem Anfanger
das Leben erschweren. Die typische Frage, vor der
auch ich immer wieder stehe, lautet: Was ist XYZ und wozu kann man es
gebrauchen? Hinsichtlich vieler Einzelheiten verweise ich auf die Referenz¨
Handbucher
zu den Rechenanlagen und Programmiersprachen oder auf Mo¨
¨
nografien, um den Text nicht uber
die Maßen aufzublahen;
er ist ein Kompromiss aus Breite und Tiefe. Alles uber
¨
UNIX, C und das Internet ist kein Buch,
¨
sondern ein Bucherschrank.
An einigen Stellen gehe ich außer auf das Wie auch auf das Warum ein.
Von Zeit zu Zeit sollte man den Blick weg von den Wellen auf das Meer rich¨
ten, sonst hauft
man nur kurzlebiges Wissen an.
Man kann den Gebrauch eines Betriebssystems, einer Programmierspra¨
che oder der Netzdienste nicht allein aus Buchern
erlernen – das ist wie beim
¨
Klavierspielen oder Kuchenbacken. Die Beispiele und Ubungen
wurden auf
einer Hewlett-Packard 9000/712 unter HP-UX 10.20 und einem PC der Marke Weingartener Katzenberg Auslese unter Debian GNU/Linux entwickelt.
Als Shell wurden Bourne-Abk¨ommlinge bevorzugt, als Compiler wurde neben
¨
dem von Hewlett-Packard der GNU gcc verwendet. Die vollstandigen
Quellen
der Beispiele stehen im Netz.
¨
Dem Text liegen eigene Erfahrungen aus funf
Jahrzehnten zugrunde.
¨
Seine Wurzeln gehen zuruck
auf eine Erste Hilfe fur
¨ Benutzer der HewlettPackard 9000 Modell 550 unter HP-UX, im Jahr 1986 aus zwanzig Aktenord¨
nern destilliert, die die Maschine begleiteten. Gegenwartig
verschiebt sich
der Schwerpunkt in Richtung Debian GNU/Linux. Ich habe auch fremde Hil¨
fe beansprucht und danke Kollegen in den Universitaten
Karlsruhe und Lyon
¨ schriftliche Unsowie Mitarbeitern der Firmen IBM und Hewlett-Packard fur
¨
¨ Anregungen
terlagen und mundlichen
Rat sowie zahlreichen Studenten fur
¨
und Diskussionen. Daruber
hinaus habe ich fleißig das Internet angezapft
und viele dort umlaufende Guides, Primers, HowTos, Tutorials und Sammlungen von Frequently Asked Questions (FAQs) verwendet.
¨ fertig erklaren,
¨
So eine Arbeit wird eigentlich nie fertig, man muss sie fur
¨
wenn man nach Zeit und Umstanden
das M¨oglichste getan hat, um es mit
J OHANN W OLFGANG VON G OETHE zu sagen (Italienische Reise; Caserta,
¨
¨
¨ unfertig und bitte, mir
den 16. Marz
1787). Ich erklare
die Skripten fur
¨
Mangel
mitzuteilen.
Weingarten (Baden), 01. November 2004
Wulf Alex
Inhalt auf einen Blick
¨
1 Uber
den Umgang mit Computern
2 Programmieren in C/C++
1
19
A Zahlensysteme
259
¨
B Zeichensatze
265
C UNIX-Systemaufrufe
278
D C-Lexikon
280
E Karlsruher Test
290
F GNU Lizenzen
298
G Zeittafel
313
H Zum Weiterlesen
323
Sach- und Namensverzeichnis
341
vii
Zum Gebrauch
• Hervorhebungen im Text werden kursiv dargestellt.
• Titel von Ver¨offentlichungen oder Abschnitten, kurze Zitate oder w¨ortliche Rede werden im Text kursiv markiert.
¨
• In Aussagen uber
W¨orter werden diese kursiv abgesetzt.
¨ einen Vortrag oder eine Vorlesung erscheinen fett.
• Stichw¨orter fur
¨
• Namen von Personen stehen in K APIT ALCHEN
.
• Eingaben von der Tastatur und Ausgaben auf den Bildschirm werden in
Schreibmaschinenschrift wiedergegeben.
• Hinsichtlich der deutschen Rechtschreibung befindet sich das Manu¨
skript in einem Ubergangsstadium.
• Hinter Linux/UNIX-Kommandos folgt oft in Klammern die Nummer der
betroffenen Sektion des Referenz-Handbuchs, z. B. vi(1). Diese Nummer samt Klammern ist beim Aufruf des Kommandos nicht einzugeben.
¨
• Suchen Sie die englische oder franz¨osische Ubersetzung
eines deutschen
¨
Fachwortes, so finden Sie diese bei der erstmaligen Erlauterung
des
deutschen Wortes.
¨
• Suchen Sie die deutsche Ubersetzung
eines englischen oder franz¨osischen Fachwortes, so finden Sie einen Verweis im Sach- und Namensverzeichnis.
• UNIX wird hier immer als die Gattung der aus dem bei AT&T um
¨
1970 entwickelten Unix ahnlichen
Betriebssysteme verstanden, nicht
¨
als geschutzter
Name eines bestimmten Produktes.
¨
• Ich gebe m¨oglichst genaue Hinweise auf weiterfuhrende
Dokumente im
Netz. Der Leser sei sich aber bewußt, dass sich sowohl Inhalte wie
¨
Adressen (URLs) andern.
Bei Verweisen auf Webseiten (URLs) ist die
Angabe des Protokolls http:// weggelassen.
¨
• Unter Benutzer, Programmierer, Verwalter usw. werden sowohl mannliche wie weibliche Erscheinungsformen verstanden.
¨
• An einigen Stellen wird auf andere Skripten verwiesen. Dies ruhrt
¨ ein Buch im
daher, dass die Skripten gemeinsam die Grundlage fur
Springer-Verlag (ISBN 3-540-65429-1) bilden.
• Ich rede den Leser mit Sie an, obwohl unter Studenten und im Netz das
¨
¨
Du ublich
ist. Gegenwartig
erscheint mir diese Wahl passender.
viii
Inhaltsverzeichnis
¨
1 Uber
den Umgang mit Computern
1.1 Was macht ein Computer? . . . . . . . . . .
1.2 Woraus besteht ein Rechner? . . . . . . . .
1.3 Was muss man wissen? . . . . . . . . . . . .
¨
1.4 Wie lauft
eine Sitzung ab? . . . . . . . . . .
¨ man nach? . . . . . . . . . . . .
1.5 Wo schlagt
1.6 Warum verwendet man Computer (nicht)? .
1.7 Begriffe . . . . . . . . . . . . . . . . . . . . .
1.8 Memo . . . . . . . . . . . . . . . . . . . . . .
1.9 Fragen . . . . . . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
2 Programmieren in C/C++
2.1 Grundbegriffe . . . . . . . . . . . . . . . . . . . . . . .
2.1.1 Wozu Programmierkenntnisse? . . . . . . . . .
2.1.2 Warum braucht man Programmiersprachen? .
2.1.3 Sprachenfamilien . . . . . . . . . . . . . . . . .
2.1.4 Imperative Programmiersprachen . . . . . . .
2.1.5 Objektorientierte Programmiersprachen . . .
2.1.6 Interpreter – Compiler – Linker . . . . . . . .
¨ und Stil . . . . . . . . . . . . . . . . .
2.1.7 Qualitat
2.1.8 Programmiertechnik . . . . . . . . . . . . . . .
2.1.9 Aufgabenanalyse und Entwurf . . . . . . . . .
2.1.9.1 Aufgabenstellung . . . . . . . . . . . .
2.1.9.2 Zerlegen in Teilaufgaben . . . . . . .
2.1.9.3 Zusammensetzen aus Teilaufgaben .
2.1.10 Prototyping . . . . . . . . . . . . . . . . . . . .
2.1.11 Flussdiagramme . . . . . . . . . . . . . . . . . .
2.1.12 Memo Grundbegriffe . . . . . . . . . . . . . . .
¨
2.1.13 Ubung
Grundbegriffe . . . . . . . . . . . . . . .
2.2 Programmer’s Workbench . . . . . . . . . . . . . . . .
2.2.1 Nochmals die Editoren . . . . . . . . . . . . . .
2.2.2 Compiler und Linker (cc, ccom, ld) . . . . . . .
2.2.3 Unentbehrlich (make) . . . . . . . . . . . . . .
2.2.4 Debugger (xdb, gdb) . . . . . . . . . . . . . . . .
2.2.5 Profiler (time, gprof) . . . . . . . . . . . . . . .
2.2.6 Archive, Bibliotheken (ar) . . . . . . . . . . . .
2.2.7 Weitere Werkzeuge . . . . . . . . . . . . . . . .
2.2.8 Versionsverwaltung mit RCS, SCCS und CVS
2.2.9 Systemaufrufe . . . . . . . . . . . . . . . . . . .
ix
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
1
1
5
6
11
13
15
17
18
18
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
19
19
19
20
23
26
29
31
33
35
36
36
37
38
38
39
40
41
41
42
42
44
47
49
51
53
54
61
x
Inhaltsverzeichnis
2.2.9.1
2.2.9.2
2.2.9.3
Was sind Systemaufrufe? . . . . . . . . . . . . .
Beispiel Systemzeit (time) . . . . . . . . . . . . .
Beispiel Datei-Informationen (access, stat,
open, close) . . . . . . . . . . . . . . . . . . . . .
2.2.9.4 Beispiel Prozesserzeugung (exec, fork) . . . . . .
2.2.10 Begriffe Programmer’s Workbench . . . . . . . . . . . . .
2.2.11 Memo Programmer’s Workbench . . . . . . . . . . . . . .
¨
2.2.12 Ubung
Programmer’s Workbench . . . . . . . . . . . . . .
2.2.13 Fragen Programmer’s Workbench . . . . . . . . . . . . . .
2.3 Bausteine eines Quelltextes . . . . . . . . . . . . . . . . . . . . .
¨
2.3.1 Ubersicht
. . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.2 Syntax-Diagramme . . . . . . . . . . . . . . . . . . . . . .
2.3.3 Kommentar . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.4 Namen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
¨
2.3.5 Schlusselw¨
orter . . . . . . . . . . . . . . . . . . . . . . . .
2.3.6 Operanden . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.6.1 Konstanten und Variable . . . . . . . . . . . . .
2.3.6.2 Typen – Grundbegriffe . . . . . . . . . . . . . . .
2.3.6.3 Einfache Typen . . . . . . . . . . . . . . . . . . .
2.3.6.4 Zusammengesetzte Typen (Arrays, Strukturen)
2.3.6.5 Union . . . . . . . . . . . . . . . . . . . . . . . . .
¨
2.3.6.6 Aufzahlungstypen
. . . . . . . . . . . . . . . . .
2.3.6.7 Pointer (Zeiger) . . . . . . . . . . . . . . . . . . .
¨ Typen (typedef) . . . . . . .
2.3.6.8 Weitere Namen fur
2.3.6.9 Speicherklassen . . . . . . . . . . . . . . . . . . .
2.3.6.10 Geltungsbereich . . . . . . . . . . . . . . . . . . .
2.3.6.11 Lebensdauer . . . . . . . . . . . . . . . . . . . . .
2.3.7 Operationen . . . . . . . . . . . . . . . . . . . . . . . . . .
¨
2.3.7.1 Ausdrucke
. . . . . . . . . . . . . . . . . . . . . .
2.3.7.2 Zuweisung . . . . . . . . . . . . . . . . . . . . . .
2.3.7.3 Arithmetische Operationen . . . . . . . . . . . .
2.3.7.4 Logische Operationen . . . . . . . . . . . . . . .
2.3.7.5 Vergleiche . . . . . . . . . . . . . . . . . . . . . .
2.3.7.6 Bitoperationen . . . . . . . . . . . . . . . . . . .
2.3.7.7 st ointeroperationen . . . . . . . . . . . . . . . .
2.3.7.8 Ein- und Ausgabe-Operationen . . . . . . . . . .
2.3.7.9 Sonstige Operationen . . . . . . . . . . . . . . .
2.3.7.10 Vorrang und Reihenfolge . . . . . . . . . . . . .
2.3.8 Anweisungen . . . . . . . . . . . . . . . . . . . . . . . . .
2.3.8.1 Leere Anweisung . . . . . . . . . . . . . . . . . .
2.3.8.2 Zuweisung als Anweisung . . . . . . . . . . . . .
2.3.8.3 Kontrollanweisungen . . . . . . . . . . . . . . .
¨
2.3.8.4 Ruckgabewert
. . . . . . . . . . . . . . . . . . . .
2.3.9 Memo Bausteine . . . . . . . . . . . . . . . . . . . . . . . .
¨
2.3.10 Ubung
Bausteine . . . . . . . . . . . . . . . . . . . . . . .
2.4 Funktionen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
61
63
66
71
71
72
73
76
77
77
78
79
80
81
81
82
82
83
87
90
91
91
97
99
100
101
101
101
101
102
103
105
106
107
108
110
111
113
113
113
113
120
122
123
123
Inhaltsverzeichnis
2.4.1 Aufbau und Deklaration . . . . . . . . . . . . . . .
2.4.2 Pointer auf Funktionen . . . . . . . . . . . . . . . .
¨
2.4.3 Parameterubergabe
. . . . . . . . . . . . . . . . . .
2.4.4 Kommandozeilenargumente, main() . . . . . . . .
2.4.5 Funktionen mit wechselnder Argumentanzahl . .
2.4.6 Iterativer Aufruf einer Funktion . . . . . . . . . .
2.4.7 Rekursiver Aufruf einer Funktion . . . . . . . . .
2.4.8 Assemblerroutinen . . . . . . . . . . . . . . . . . .
2.4.9 Memo Funktionen . . . . . . . . . . . . . . . . . . .
¨
2.4.10 Ubung
Funktionen . . . . . . . . . . . . . . . . . .
2.5 Funktions-Bibliotheken . . . . . . . . . . . . . . . . . . .
2.5.1 Zweck und Aufbau . . . . . . . . . . . . . . . . . .
2.5.2 Standardbibliothek . . . . . . . . . . . . . . . . . .
¨
2.5.2.1 Ubersicht
. . . . . . . . . . . . . . . . . .
2.5.2.2 Standard-C-Bibliothek . . . . . . . . . . .
2.5.2.3 Standard-Mathematik-Bibliothek . . . .
2.5.2.4 Standard-Grafik-Bibliothek . . . . . . . .
2.5.2.5 Weitere Teile der Standardbibliothek . .
2.5.3 Xlib, Xt und Xm (X Window System) . . . . . . . .
2.5.4 NAG-Bibliothek . . . . . . . . . . . . . . . . . . . .
2.5.5 Eigene Bibliotheken . . . . . . . . . . . . . . . . .
2.5.6 Speichermodelle (PC-DOS) . . . . . . . . . . . . .
2.5.7 Memo Bibliotheken . . . . . . . . . . . . . . . . . .
¨
2.5.8 Ubung
Bibliotheken . . . . . . . . . . . . . . . . . .
2.5.9 Systemaufrufe . . . . . . . . . . . . . . . . . . . . .
2.5.9.1 Was sind Systemaufrufe? . . . . . . . . .
2.5.9.2 Beispiel Systemzeit (time) . . . . . . . . .
2.5.9.3 Beispiel Datei-Informationen (access,
open, close) . . . . . . . . . . . . . . . . .
2.5.9.4 Beispiel Prozesserzeugung (exec, fork) . .
2.6 Klassen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.6.1 Warum C mit Klassen? . . . . . . . . . . . . . . . .
2.6.2 Datenabstraktion, Klassenbegriff . . . . . . . . . .
2.6.3 Klassenhierarchie, abstrakte Klassen, Vererbung
2.6.4 Memo Klassen . . . . . . . . . . . . . . . . . . . . .
¨
2.6.5 Ubung
Klassen . . . . . . . . . . . . . . . . . . . .
2.7 Klassen-Bibliotheken . . . . . . . . . . . . . . . . . . . . .
2.7.1 C++-Standardbibliothek . . . . . . . . . . . . . . .
2.7.2 Standard Template Library (STL) . . . . . . . . .
2.7.3 C-XSC . . . . . . . . . . . . . . . . . . . . . . . . . .
2.7.3.1 Was ist C-XSC? . . . . . . . . . . . . . . .
2.7.3.2 Datentypen, Operatoren und Funktionen
2.7.3.3 Teilfelder von Vektoren und Matrizen . .
¨
2.7.3.4 Genaue Auswertung von Ausdrucken
. .
2.7.3.5 Dynamische Langzahl-Arithmetik . . . .
2.7.3.6 Ein- und Ausgabe in C-XSC . . . . . . . .
xi
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
. . .
stat,
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
. . . .
123
124
124
135
137
140
142
144
149
150
150
150
151
151
152
154
155
155
156
156
157
157
158
158
159
159
160
163
168
169
169
170
172
178
178
179
179
179
181
181
181
183
183
185
186
xii
Inhaltsverzeichnis
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.7.3.7 C-XSC-Numerikbibliothek . . . . . .
2.7.3.8 Beispiel Intervall-Newton-Verfahren
2.7.4 X11-Programmierung mit dem Qt-Toolkit . . .
¨
Uberladen
von Operatoren . . . . . . . . . . . . . . . .
¨
Praprozessor
. . . . . . . . . . . . . . . . . . . . . . . .
2.9.1 define-Anweisungen . . . . . . . . . . . . . . .
2.9.2 include-Anweisungen . . . . . . . . . . . . . . .
2.9.3 Bedingte Kompilation (#ifdef) . . . . . . . . . .
¨
2.9.4 Memo Praprozessor
. . . . . . . . . . . . . . . .
¨
¨
2.9.5 Ubung Praprozessor
. . . . . . . . . . . . . . .
Dokumentation . . . . . . . . . . . . . . . . . . . . . .
2.10.1 Zweck . . . . . . . . . . . . . . . . . . . . . . . .
2.10.2 Anforderungen (DIN 66 230) . . . . . . . . . .
2.10.3 Erstellen einer man-Seite . . . . . . . . . . . .
Weitere C-Programme . . . . . . . . . . . . . . . . . .
2.11.1 Name . . . . . . . . . . . . . . . . . . . . . . . .
2.11.2 Aufbau . . . . . . . . . . . . . . . . . . . . . . .
2.11.3 Fehlersuche . . . . . . . . . . . . . . . . . . . .
2.11.4 Optimierung . . . . . . . . . . . . . . . . . . . .
2.11.5 curses – Fluch oder Segen? . . . . . . . . . . .
¨
2.11.6 Mehr oder weniger zufallig
. . . . . . . . . . .
¨ Pointer . . . . . . . . . . . . . . .
2.11.7 Ein Herz fur
2.11.7.1 Nullpointer . . . . . . . . . . . . . . .
2.11.7.2 Pointer auf Typ void . . . . . . . . . .
2.11.7.3 Arrays und Pointer . . . . . . . . . . .
2.11.7.4 Arrays von Funktionspointern . . . .
2.11.8 Verarbeitung von Strings . . . . . . . . . . . .
2.11.9 Dynamische Speicherverwaltung (malloc) . . .
2.11.10X Window System . . . . . . . . . . . . . . . . .
2.11.11cgi-Programme . . . . . . . . . . . . . . . . . .
Obfuscated C . . . . . . . . . . . . . . . . . . . . . . . .
Portieren von Programmen . . . . . . . . . . . . . . .
2.13.1 Regeln . . . . . . . . . . . . . . . . . . . . . . .
¨
2.13.2 Ubertragen
von ALGOL nach C . . . . . . . . .
¨
2.13.3 Ubertragen
von FORTRAN nach C . . . . . . .
¨
Exkurs uber
Algorithmen . . . . . . . . . . . . . . . .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
187
187
189
193
195
196
197
199
202
202
202
202
203
204
205
205
206
209
209
211
215
219
219
220
222
226
231
232
237
243
249
250
250
252
254
258
A Zahlensysteme
259
¨
B Zeichensatze
B.1 EBCDIC, ASCII, Roman8, IBM-PC
B.2 German-ASCII . . . . . . . . . . . .
B.3 ASCII-Steuerzeichen . . . . . . . .
B.4 Latin-1 (ISO 8859-1) . . . . . . . .
265
265
270
271
272
C UNIX-Systemaufrufe
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
278
Inhaltsverzeichnis
D C-Lexikon
¨
D.1 Schlusselw¨
orter . . . . . . .
D.2 Operatoren . . . . . . . . . .
D.3 Standardfunktionen . . . . .
D.4 printf(3), scanf(3) . . . . . .
D.5 Include-Dateien . . . . . . .
¨
D.6 Praprozessor-Anweisungen
E Karlsruher Test
xiii
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
280
280
282
283
287
288
289
290
F GNU Lizenzen
298
F.1 GNU General Public License . . . . . . . . . . . . . . . . . . . . 298
F.2 GNU Free Documentation License . . . . . . . . . . . . . . . . . 305
G Zeittafel
313
H Zum Weiterlesen
323
Sach- und Namensverzeichnis
341
Abbildungen
1.1 Aufbau eines Rechners . . . . . . . . . . . . . . . . . . . . . . . .
5
2.1 Flussdiagramm . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.2 Nassi-Shneiderman-Diagramm . . . . . . . . . . . . . . . . . . .
2.3 Syntax-Diagramm . . . . . . . . . . . . . . . . . . . . . . . . . . .
39
40
79
xiv
Tabellen
¨
2.1 Lange
von Datentypen . . . . . . . . . . . . . . . . . . . . . . . .
xv
84
Quelldateien
2.1
2.2
2.3
2.4
2.5
2.6
2.7
2.8
2.9
2.10
2.11
2.12
2.13
2.14
2.15
2.16
2.17
2.18
2.19
2.20
2.21
2.22
2.23
2.24
2.25
2.26
2.27
2.28
2.29
2.30
2.31
2.32
2.33
2.34
2.35
2.36
2.37
2.38
2.39
2.40
LISP-Programm . . . . . . . . . . . . . . . . . . . . . . . . .
SCHEME-Programm . . . . . . . . . . . . . . . . . . . . . .
PROLOG-Programm . . . . . . . . . . . . . . . . . . . . . .
Programm Z 22 . . . . . . . . . . . . . . . . . . . . . . . . .
COBOL-Programm . . . . . . . . . . . . . . . . . . . . . . .
JAVA-Programm . . . . . . . . . . . . . . . . . . . . . . . . .
Makefile . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Erweitertes Makefile . . . . . . . . . . . . . . . . . . . . . .
C-Programm mit Funktionsbibliothek . . . . . . . . . . . .
C-Funktion Mittelwert . . . . . . . . . . . . . . . . . . . . .
C-Funktion Varianz . . . . . . . . . . . . . . . . . . . . . . .
Makefile zum Sortierprogramm . . . . . . . . . . . . . . . .
Include-Datei zum Sortierprogramm . . . . . . . . . . . . .
C-Programm Sortieren . . . . . . . . . . . . . . . . . . . . .
C-Funktion Bubblesort . . . . . . . . . . . . . . . . . . . . .
C-Programm Systemzeit . . . . . . . . . . . . . . . . . . . .
FORTRAN-Programm Systemzeit . . . . . . . . . . . . . .
C-Programm File-Informationen . . . . . . . . . . . . . . .
C-Programm Fork-Bombe . . . . . . . . . . . . . . . . . . .
C-Programm mit Fehlern . . . . . . . . . . . . . . . . . . . .
C-Programm Kommentar . . . . . . . . . . . . . . . . . . .
C-Programm character und integer . . . . . . . . . . . . . .
C-Programm Pointerarithmetik . . . . . . . . . . . . . . . .
C-Programm Bitweise Negation . . . . . . . . . . . . . . . .
C-Programm Bitoperationen . . . . . . . . . . . . . . . . . .
C-Programm Ausgabe per Systemaufruf . . . . . . . . . . .
C-Programm Ausgabe per Standardfunktion . . . . . . . .
C-Programm einfache for-Schleife . . . . . . . . . . . . . . .
C-Programm zusammengesetzte for-Schleife . . . . . . . .
C-Programm mit goto, grauenvoll . . . . . . . . . . . . . . .
C-Programm, verbessert . . . . . . . . . . . . . . . . . . . .
C-Programm return-Anweisungen . . . . . . . . . . . . . .
C-Programm Funktionsprototyp . . . . . . . . . . . . . . .
¨
C-Funktion Parameterubergabe
by value . . . . . . . . . .
¨
C-Funktion Parameterubergabe
by reference . . . . . . . .
¨
FORTRAN-Funktion Parameterubergabe
by reference . .
¨
PASCAL-Funktion Parameterubergabe
by value . . . . . .
¨
PASCAL-Funktion Parameterubergabe
by reference . . . .
¨
C-Programm Parameterubergabe
an C-Funktionen . . . .
¨
C-Programm Parameterubergabe
an FORTRAN-Funktion
xvi
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
24
25
25
26
27
31
45
46
52
52
53
57
57
58
60
64
65
70
71
74
80
86
97
104
107
109
110
117
117
119
119
121
124
126
126
127
127
127
128
128
Quelldateien
2.41
2.42
2.43
2.44
2.45
2.46
2.47
2.48
2.49
2.50
2.51
2.52
2.53
2.54
2.55
2.56
2.57
2.58
2.59
2.60
2.61
2.62
2.63
2.64
2.65
2.66
2.67
2.68
2.69
2.70
2.71
2.72
2.73
2.74
2.75
2.76
2.77
2.78
2.79
2.80
2.81
2.82
2.83
2.84
2.85
2.86
xvii
¨
C-Programm Parameterubergabe
an PASCAL-Funktionen . . . 129
¨
FORTRAN-Programm Parameterubergabe
an C-Funktionen . . 130
¨
FORTRAN-Programm Parameterubergabe
an FORTRAN-Fkt. . 131
¨
FORTRAN-Programm Parameterubergabe
an PASCAL-Fkt. . . 131
¨
PASCAL-Programm Parameterubergabe
an C-Funktionen . . . 132
¨
PASCAL-Programm Parameterubergabe
an FORTRAN-Funktion132
¨
PASCAL-Programm Parameterubergabe an PASCAL-Funktionen133
¨
PASCAL-Funktion Parameterubergabe
by value . . . . . . . . . 134
¨
PASCAL-Funktion Parameterubergabe
by reference . . . . . . . 134
¨
Shellscript Parameterubergabe
. . . . . . . . . . . . . . . . . . . 135
¨
C-Programm Parameterubernahme
von Shellscript . . . . . . . 135
C-Programm Kommandozeilenargumente . . . . . . . . . . . . . 136
C-Funktion Wechselnde Anzahl von Argumenten . . . . . . . . 139
C-Programm Quadratwurzel . . . . . . . . . . . . . . . . . . . . . 142
C-Programm ggT . . . . . . . . . . . . . . . . . . . . . . . . . . . 143
¨ . . . . . . . . . . . . . . . . . . . . . . . . 143
C-Programm Fakultat
C-Programm Selbstaufruf main() . . . . . . . . . . . . . . . . . . 143
¨
C-Programm, Fakultaten
. . . . . . . . . . . . . . . . . . . . . . . 147
Assemblerfunktion Addition 1 . . . . . . . . . . . . . . . . . . . . 149
C-Programm Stringverarbeitung . . . . . . . . . . . . . . . . . . 154
C-Programm Mathematische Funktionen . . . . . . . . . . . . . 155
C-Programm Systemzeit . . . . . . . . . . . . . . . . . . . . . . . 162
FORTRAN-Programm Systemzeit . . . . . . . . . . . . . . . . . 162
C-Programm File-Informationen . . . . . . . . . . . . . . . . . . 168
C-Programm Fork-Bombe . . . . . . . . . . . . . . . . . . . . . . 169
C++-Programm Hallo, Welt . . . . . . . . . . . . . . . . . . . . . 169
C++-Programm Umrechnung UTC-MEZ . . . . . . . . . . . . . . 172
C++-Programm Geometrische Formen . . . . . . . . . . . . . . . 177
C-XSC-Funktion defect() . . . . . . . . . . . . . . . . . . . . . . . 184
C-XSC-Programm einfacher Genauigkeit . . . . . . . . . . . . . 185
C-XSC-Programm mehrfacher Genauigkeit . . . . . . . . . . . . 186
C-XSC-Programm mit Ein- und Ausgabe . . . . . . . . . . . . . 187
C-XSC-Programm Intervall-Newton-Verfahren . . . . . . . . . . 188
Makefile zu qhello.cpp . . . . . . . . . . . . . . . . . . . . . . . . 190
Include-File zu qhello.cpp . . . . . . . . . . . . . . . . . . . . . . 191
C++-Programm qhello.cpp . . . . . . . . . . . . . . . . . . . . . . 192
C++-Programm Primzahlen . . . . . . . . . . . . . . . . . . . . . 195
Include-File /usr/include/stdio.h . . . . . . . . . . . . . . . . . . . 199
C-Programm Umrechnung Zahlenbasis . . . . . . . . . . . . . . 202
C-Programm, minimal . . . . . . . . . . . . . . . . . . . . . . . . 206
C-Programm, einfachst . . . . . . . . . . . . . . . . . . . . . . . . 207
C-Programm, einfach . . . . . . . . . . . . . . . . . . . . . . . . . 207
C-Programm, fortgeschritten . . . . . . . . . . . . . . . . . . . . 207
C-Programm, Variante . . . . . . . . . . . . . . . . . . . . . . . . 208
C-Programm, Eingabe . . . . . . . . . . . . . . . . . . . . . . . . 208
C-Programm Fileputzete . . . . . . . . . . . . . . . . . . . . . . . 213
xviii
2.87 C-Programm, curses . . . . . . . . . . . . . . . .
2.88 C-Programm Zufallszahlen . . . . . . . . . . . . .
2.89 C-Programm Zufallszahlen, mit Funktion . . . .
2.90 C-Funktion Zufallszahlen . . . . . . . . . . . . .
2.91 PASCAL-Programm Zufallszahlen, mit Funktion
2.92 C-Programm, void-Pointer . . . . . . . . . . . . .
2.93 C-Programm Primzahlen . . . . . . . . . . . . . .
2.94 C-Programm Array von Funktionspointern . . .
2.95 C-Funktion bilder.c . . . . . . . . . . . . . . . . .
2.96 Makefile zu schiff.c . . . . . . . . . . . . . . . . .
2.97 C-Programm Dynamische Speicherverwaltung .
2.98 C-Programm Sortieren nach Duden . . . . . . .
2.99 C-Programm X Window System/Xlib . . . . . . .
2.100Webseite cgi test . . . . . . . . . . . . . . . . . . .
2.101Include-File cgi.h . . . . . . . . . . . . . . . . . .
2.102C-Programm cgi test.c . . . . . . . . . . . . . . .
2.103C-Funktionen cgi.c . . . . . . . . . . . . . . . . .
2.104ALGOL-Programm . . . . . . . . . . . . . . . . .
2.105C-Programm ggT nach Euklid . . . . . . . . . . .
2.106FORTRAN-Programm Quadratische Gleichung .
2.107C-Programm Quadratische Gleichung . . . . . .
Quelldateien
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
214
216
217
218
218
222
226
229
229
231
233
237
242
243
244
245
248
253
254
255
257
Rien n’est simple.
Semp´e
¨
Uber
den Umgang mit Computern
1
1.1
Was macht ein Computer?
Eine elektronische Datenverarbeitungsanlage, ein Computer oder Rechner, ist ein Werkzeug, mit dessen Hilfe man Informationen
¨
¨
• speichert (Anderung
der zeitlichen Verfugbarkeit),
¨
¨
¨
• ubermittelt
(Anderung
der o¨ rtlichen Verfugbarkeit),
¨
¨
• erzeugt oder verandert
(Anderung
des Inhalts).
¨ Informationen sagt man auch Nachrichten oder Daten1 . Sie lassen sich
Fur
durch gesprochene oder geschriebene W¨orter, Zahlen, Bilder oder im Com¨
puter durch elektrische oder magnetische Zustande
darstellen. Speichern
heißt, die Information so zu erfassen und aufzubewahren, dass sie am selben
¨
¨
¨
¨
Ort zu einem spateren
Zeitpunkt unverandert
zur Verfugung
steht. Uber¨
mitteln heißt, eine Information unverandert
einem anderen – in der Regel,
¨
aber nicht notwendigerweise an einem anderen Ort – verfugbar
zu machen,
¨
was wegen der endlichen Geschwindigkeit aller irdischen Vorgange
Zeit kostet. Da sich elektrische Transporte jedoch mit Lichtgeschwindigkeit (nahezu
¨
300 000 km/s) fortbewegen, spielt der Zeitbedarf nur in seltenen Fallen
ei¨
¨
ne Rolle. Juristen denken beim Ubermitteln weniger an die Ortsanderung
¨
¨
¨
als an die Anderung
der Verfugungsgewalt.
Zum Speichern oder Ubermitteln
¨
muss die physikalische Form der Information meist mehrmals verandert
wer¨
den, was sich auf den Inhalt auswirken kann, aber nicht soll. Verandern
¨
¨
¨
heißt inhaltlich verandern:
eingeben, suchen, auswahlen,
verknupfen,
sor¨
¨
tieren, prufen,
sperren oder l¨oschen. Tatigkeiten,
die mit Listen, Karteien,
¨
Rechenschemata zu tun haben oder die mit geringen Abweichungen haufig
¨
wiederholt werden, sind mit Rechnerhilfe schneller und sicherer zu bewalti¨
gen. Rechner finden sich nicht nur in Form grauer Kasten
auf oder neben
Schreibtischen, sondern auch versteckt in Fotoapparaten, Waschmaschinen,
¨
Heizungsregelungen, Autos, Motorradern
und Telefonen. Diese versteckten
Rechner werden Embedded Systems (Eingebettete Systeme) genannt.
Das Wort Computer stammt aus dem Englischen, wo es vor hundert Jah¨
ren eine Person bezeichnete, die berufsmaßig
rechnete, einen Rechenknecht
1 Schon
geht es los mit den Fußnoten: Bei genauem Hinsehen gibt es Unterschiede
zwischen Information, Nachricht und Daten, siehe Abschnitt ?? Exkurs uber
¨
Informationen auf Seite ??.
1
2
¨
1 Uber
den Umgang mit Computern
oder eine Rechenmagd. Heute versteht man nur noch die Maschinen dar¨
unter. Das englische Wort wiederum geht auf lateinisch computare zuruck,
¨
¨
was berechnen, veranschlagen, erwagen,
uberlegen
bedeutet. Die Franzosen
sprechen vom ordinateur, die Spanier vom ordenador, dessen lateinischer Ursprung ordo Reihe, Ordnung bedeutet. Die Portugiesen – um sich von den
Spaniern abzuheben – gebrauchen das Wort computador. Die Schweden nennen die Maschine dator, analog zu Motor, die Finnen tietokone, was Wissensmaschine heißt. Hierzulande sprach man eine Zeit lang von Elektronengehirnen, weniger respektvoll von Blechbregen. Im Deutschen verbreitet ist das Wort
Rechner, wobei heute niemand mehr an eine Person denkt. Rechnen bedeutete
¨
¨
urpsunglich
ordnen, richten, geh¨ort in eine vielk¨opfige indoeuropaische
Wort¨
familie und war nicht auf Zahlen beschrankt.
Die Wissenschaft von der Informationsverarbeitung ist die Informatik,
englisch Computer Science, franz¨osisch Informatique. Ihre Wurzeln sind die
¨
Mathematik und die Elektrotechnik; kleinere Wurzelauslaufer
reichen
¨
auch in Wissenschaften wie Physiologie und Linguistik. Sie zahlt
zu den In¨
¨
genieurwissenschaften. Die fruheste
mir bekannte Erwahnung
des Wortes
Informatik findet sich in der Firmenzeitschrift SEG-Nachrichten (Technische
Mitteilungen der Standard Elektrik Gruppe) 1957 Nr. 4, S. 171: K ARL S TEIN BUCH , Informatik: Automatische Informationsverarbeitung. S TEINBUCH berichtet in einem Referat von 1970, dass das Wort Informatik etwa im Jah¨
re 1955 der Firma Standard Elektrik Lorenz AG geschutzt
und mit dem
¨
Informatik-System Quelle (Versandhaus Quelle) der Offentlichkeit vorgestellt
worden sei. Damit war das Wort geboren; die Wissenschaft von der Computerey wußte aber noch nicht, wie sie sich im deutschsprachigen Raum nennen
soll. Es wurde sogar bezweifelt, dass sie eine eigene Wissenschaft sei.
Am Morgen des 26. Februar 1968 – nach dem 3. Internationalen Kollo¨
quium uber
aktuelle Probleme der Rechentechnik an der TU Dresden unter der Verantwortung von N IKOLAUS J OACHIM L EHMANN – einigten sich
die dort anwesenden Gr¨oßen der deutschen Computerwissenschaft unter der
¨
Fuhrung
von F RIEDRICH L. B AUER nach franz¨osischem Beispiel auf die Be¨
zeichnung Informatik. Diese Entscheidung war ebenso glucklich
wie wichtig
¨ die weitere Entwicklung dieser Wissenschaft im deutschen Sprachbereich:
fur
¨
¨
gegenuber
Politik, Forschungstragern,
anderen Wissenschaften und in der
¨
Offentlichkeit konnten nun ihre Vertreter unter einer einheitlichen und ein¨
¨
pragsamen
Bezeichnung auftreten. Kurze Zeit spater
wurden die Gesellschaft
fur
¨ Informatik und in Karlsruhe das Institut fur
¨ Informatik, Direktor K ARL
¨
N ICKEL, gegrundet.
Mit dem Wintersemester 1969/70 beginnt in Karlsruhe
die Informatik als eigener, voller Studiengang. Kurz darauf wird die Karls¨ fur
¨ Informatik aus der Taufe gehoben.
ruher Fakultat
¨
Der Begriff Informatik ist somit rund funfzig
Jahre alt, Computer gibt es
¨
seit siebzig Jahren, Uberlegungen
dazu stellten C HARLES B ABBAGE vor rund
zweihundert und G OTTFRIED W ILHELM L EIBNIZ vor vierhundert Jahren an.
Die Bedeutung der Information war dagegen schon im Altertum bekannt. Der
¨
Laufer
von Marathon setzte 490 vor Christus sein Leben daran, eine Informa¨
tion so schnell wie m¨oglich in die Heimat zu ubermitteln.
Neu in unserer Zeit
1.1 Was macht ein Computer?
3
ist die M¨oglichkeit, Informationen maschinell zu verarbeiten.
Informationsverarbeitung ist nicht an Computer gebunden. Die Informa¨
tik beschrankt
sich insbesondere nicht auf das Herstellen von Computerprogrammen. Der Computer hat jedoch die Aufgaben und die M¨oglichkeiten
der Informatik ausgeweitet. Unter Technischer Informatik – im Scherz
L¨otkolben-Informatik genannt – versteht man den elektrotechnischen Teil.
Den Gegenpol bildet die Theoretische Informatik – nicht zu verwechseln
mit der Informationstheorie – die sich mit formalen Sprachen, Grammati¨
ken, Semantik, Automaten, Entscheidbarkeit, Vollstandigkeit
und Komple¨ von Problemen beschaftigt.
¨
xitat
Computer und Programme sind in der Angewandten Informatik zu Hause. Die Grenzen innerhalb der Informatik
¨
sowie zu den Nachbarwissenschaften sind jedoch unscharf und durchlassig.
Auch die heute in Hochschulen und gr¨oßeren Unternehmen selbst¨
verstandlichen
Rechenzentren waren anfangs umstritten. Abgesehen von den
¨
Fachleuten, die deren Daseinsberechtigung grundsatzlich
bezweifelten (es
ging ja auch um viel Geld), hatten manche Außenstehende die falsche Vorstellung, ein Rechenzentrum sei eine Einrichtung, bei der man abends sein
¨
Problem abliefere und am nachsten
Morgen die L¨osung abhole, ohne sich mit
¨
niedrigen Kunsten
wie numerischer Mathematik oder Programmiertechnik
Finger und Hirn zu beschmutzen. Die Entwicklung – vor allem das Netz –
hat die Aufgaben der Rechenzentren deutlicher hervortreten lassen.
Computer sind Automaten, Maschinen, die auf bestimmte Eingaben
¨
mit bestimmten Tatigkeiten
und Ausgaben antworten. Dieselbe Eingabe
¨
fuhrt
immer zu derselben Ausgabe; darauf verlassen wir uns. Deshalb ist
es im Grundsatz unm¨oglich, mit Computern Zufallszahlen zu erzeugen
¨
(zu wurfeln).
Zwischen einem Briefmarkenautomaten (Postwertzeichengeber)
und einem Computer besteht jedoch ein wesentlicher Unterschied. Ein Brief¨
markenautomat nimmt nur Munzen
entgegen und gibt nur Briefmarken aus,
¨ spemehr nicht. Es hat auch mechanische Rechenautomaten gegeben, die fur
zielle Aufgaben wie die Berechnung von Geschossbahnen oder Gezeiten oder
¨ die harmonische Analyse eingerichtet waren. Das Verhalten von mechafur
¨
nischen Automaten ist durch ihre Mechanik unveranderlich
vorgegeben.
Bei einem Computer hingegen wird das Verhalten durch ein Programm
¨ gespeichert ist und leicht ausgewechselt werbestimmt, das im Gerat
den kann. Derselbe Computer kann sich wie eine Schreibmaschine, eine
Rechenmaschine, eine Zeichenmaschine, ein Telefon-Anrufbeantworter, ein
Schachspieler oder wie ein Lexikon verhalten, je nach Programm. Er ist
ein Universal-Automat. Das Wort Programm ist lateinisch-griechischen Ur¨
sprungs und bezeichnet ein o¨ ffentliches Schriftstuck
wie ein Theater- oder
Parteiprogramm. Im Zusammenhang mit Computern ist an ein Arbeitsprogramm zu denken. Die englische Schreibweise ist programme, Computer zie¨
hen jedoch das amerikanische program vor. Die Gallier reden haufiger
von
einem logiciel als von einem programme, wobei logiciel das gesamte zu einer Anwendung geh¨orende Programmpaket meint – bestehend aus mehreren
Programmen samt Dokumentation.
4
¨
1 Uber
den Umgang mit Computern
¨
Mit dem Charakter der Computer als Automaten hangt
zusammen, dass
sie entsetzlich dumm sind und des gesunden Menschenverstandes v¨ollig er¨
mangeln. Daruber
hinaus sind sie kleinlich bis zum geht nicht mehr. Ein feh¨
lendes Komma kann sie zum Stillstand bringen. Man muss ihnen ausfuhrlich
¨
und in exakter Sprache sagen, was sie tun sollen. Ein haufiges
Problem im
Umgang mit Computern ist, dass sie genau das tun, was ihnen aufgetragen
¨
wird, nicht das, was sich der Benutzer denkt oder wunscht.
Andererseits zeigen sie eine Eselsgeduld. Es macht ihnen gar nichts aus, denselben Fehler
¨
millionenmal zu wiederholen. Insofern erganzen
sich Mensch und Computer
hervorragend.
¨
¨
Ebenso wie man die Gr¨oße von Massen, Kraften
oder Langen
misst, werden auch Informationsmengen gemessen. Nun liegen Informationen in
unterschiedlichen Formen vor. Sie lassen sich jedoch alle auf Folgen von zwei
¨
¨
Zeichen zuruckf
uhren,
die mit 0 und 1 oder H (high) und L (low) bezeich¨
¨
net werden. Sie durfen
auch Anna und Otto dazu sagen, es mussen
nur zwei
¨ genannt,
verschiedene Zeichen sein. Diese einfache Darstellung wird binar
¨
zu lateinisch bini = je zwei. Die Binardarstellung
beliebiger Informationen
durch zwei Zeichen darf nicht verwechselt werden mit dem Dualsystem von
¨
Zahlen, bei der die Zahlen auf Summen von Potenzen zur Basis 2 zuruck¨
gefuhrt
werden. Das eine ist eine Darstellung oder Codierung und geh¨ort in
die Informatik, das andere ist ein Zahlensystem und geh¨ort in die Mathematik.
¨ Darstellungen von Informationen?
Warum bevorzugen Computer binare
Als die Rechenmaschinen noch mechanisch arbeiteten, verwendeten sie das
¨
¨
Dezimalsystem, denn es ist einfach, Zahnrader
mit 20 oder 100 Zahnen
herzustellen. Viele elektronische Bauelemente hingegen kennen – von Wackel¨
kontakten abgesehen – nur zwei Zustande
wie ein Schalter, der entweder
¨
offen oder geschlossen ist. Mit binaren
Informationen hat es die Elektronik
leichter. In der Anfangszeit hat man aber auch dezimal arbeitende elektro¨
nische Rechner gebaut. Hatten
wir brauchbare Schaltelemente mit drei oder
¨
¨
¨ oder quaternare
¨ Darstellungen vervier Zustanden,
wurden
wir auch ternare
wenden.
¨
¨
Eine 0 oder 1 stellt eine Binarziffer
dar, englisch binary digit, abgekurzt
Bit. Ein Bit ist das Datenatom. Hingegen ist 1 bit (kleingeschrieben) die Maߨ die Entscheidung zwischen 0 und 1 im Sinne der Informationseinheit fur
theorie von C LAUDE E LWOOD S HANNON. Kombinationen von acht Bits spielen eine große Rolle, sie werden daher zu einem Byte oder Oktett zusammengefasst. Die Festlegung des Bytes zu acht Bit stammt von der Firma IBM aus
dem Jahr 1964; davor waren auch andere Werte in Gebrauch. Auf dem Papier
¨
wird ein Byte oft durch ein Paar hexadezimaler Ziffern – ein Hexparchen
– wiedergegeben. Das Hexadezimalsystem – das Zahlensystem zur Basis
¨
16 – wird uns haufig
begegnen, in Linux/UNIX auch das Oktalsystem zur
Basis 8. Durch ein Byte lassen sich 28 = 256 unterschiedliche Zeichen darstel¨ unsere europaischen
¨
len. Das reicht fur
Buchstaben, Ziffern und Satzzeichen.
Ebenso wird mit einem Byte eine Farbe aus 256 unterschiedlichen Farben
¨
ausgewahlt.
1024 Byte ergeben 1 Kilobyte, 1024 Kilobyte sind 1 Megabyte,
1.2 Woraus besteht ein Rechner?
5
1024 Megabyte sind 1 Gigabyte, 1024 Gigabyte machen 1 Terabyte (mit ei¨
nem r, aus dem Griechischen). Die nachste
Stufen heißen Petabyte, Exabyte
und Zettabyte.
Der Computer verarbeitet Informationen in Einheiten eines Maschinenwortes, das je nach der Breite der Datenregister des Prozessors 1 bis 16 Bytes
(128 Bits) umfasst. Der durchschnittliche Benutzer kommt mit dieser Einheit
¨
selten in Beruhrung.
1.2
Woraus besteht ein Rechner?
Der Benutzer sieht von einem Rechner vor allem den Bildschirm2 (E: screen,
F: e´ cran) und die Tastatur (E: keyboard, F: clavier), auch Hackbrett genannt.
¨ werden zusammen als Terminal (E: terminal, F: terminal)
Die beiden Gerate
bezeichnet und stellen die Verbindung zwischen Benutzer und Rechner dar.
Mittels der Tastatur spricht der Benutzer zum Rechner, auf dem Bildschirm
erscheint die Antwort.
Tastatur
Bildschirm
KAA Terminal A
A
A
A
Arbeitsspeicher
-
CPU
Prozessor
?
-
Massenspeicher
@
I
@
@
@
@
R
@
Drucker
Netze
Abb. 1.1: Aufbau eines Rechners
Der eigentliche Rechner, die Prozessoreinheit (Zentraleinheit, E: central unit, F: unit´e centrale) ist in die Tastatur eingebaut wie beim Schneider
2 Aus
der Fernsehtechnik kommend wird der Bildschirm oft Monitor genannt. Da
das Wort hier nicht ganz trifft und auch ein Programm bezeichnet, vermeide ich es.
¨
1 Uber
den Umgang mit Computern
6
¨
CPC 464 oder Commodore C64, in das Bildschirmgehause
wie beim ersten
¨
Apple Macintosh oder in ein eigenes Gehause.
Seine wichtigsten Teile sind
der Zentralprozessor (CPU, E: central processing unit, F: processeur central) und der Arbeitsspeicher (E: memory, F: m´emoire centrale, m´emoire
vive, m´emoire secondaire).
Um recht in Freuden arbeiten zu k¨onnen, braucht man noch einen Massenspeicher (E: mass storage, F: m´emoire de masse), der seinen Inhalt
nicht vergisst, wenn der Rechner ausgeschaltet wird. Nach dem heutigen
Stand der Technik arbeiten die meisten Massenspeicher mit magnetischen
¨
¨
¨
¨
Datentragern
ahnlich
wie Ton- oder Videobandgerate.
Tatsachlich
verwendeten die ersten Personal Computer Tonbandkassetten. Weit verbreitet sind
¨
scheibenf¨ormige magnetische Datentrager
in Form von Disketten (E: floppy
disk, F: disquette) und Festplatten (E: hard disk, F: disque dur).
Disketten, auch Schlappscheiben genannt, werden nach Gebrauch aus
dem Laufwerk (E: drive, F: d´erouleur) des Rechners herausgenommen und
im Schreibtisch vergraben oder mit der Post verschickt. Festplatten verbleiben in ihrem Laufwerk. CDs und DVDs sind ebenfalls entfernbare, transpor¨
table Datentrager.
Da man gelegentlich etwas schwarz auf weiß besitzen m¨ochte, geh¨ort zu
den meisten Rechnern ein Drucker (E: printer, F: imprimante). Ferner ist
¨ heutzutage durch ein Netz (E: network,
ein Rechner, der etwas auf sich halt,
F: r´eseau) mit anderen Rechnern rund um die Welt verbunden. Damit ist die
¨
Anlage vollstandig.
Was um den eigentlichen Rechner (Prozessoreinheit) herumsteht, wird als
¨
Peripherie (E: periphery, F: p´eriph´erique) bezeichnet. Die peripheren Gerate
¨
sind uber
Schnittstellen (Datensteckdosen, E: interface, F: interface) angeschlossen.
In Abb. 1.1 auf Seite 5 sehen wir das Ganze schematisch dargestellt. In
der Mitte die CPU, untrennbar damit verbunden der Arbeitsspeicher. Um
dieses Paar herum die Peripherie, bestehend aus Terminal, Massenspeicher,
Drucker und Netzanschluss. Sie k¨onnen aber immer noch nichts damit anfangen, allenfalls heizen. Es fehlt noch die Intelligenz in Form eines Betriebssystems (E: operating system, F: syst`eme d’exploitation) wie Linux oder UNIX.
1.3
Was muss man wissen?
¨
Die ersten Gedanken des Anfangers
werden darum kreisen, wie man dem
¨
Rechner vernunftige
Reaktionen entlockt. Keine Angst: durch Tastatureinga¨
ben (außer Kaffee und ahnlichen
Programming Fluids) ist ein Rechner nicht
zu zerst¨oren. Die in ihm gespeicherten Daten sind allerdings empfindlich.
Zum Arbeiten mit einem Rechner muss man drei Dinge lernen:
• den Umgang mit der Hardware3
3 Ich
weiß, dass ich ein deutsch-englisches Kauderwelsch gebrauche, aber ich habe
1.3 Was muss man wissen?
7
• den Umgang mit dem Betriebssystem,
• den Umgang mit einem Anwendungsprogramm, zum Beispiel einer
Textverarbeitung oder Datenbank.
¨
¨
Daruber
hinaus sind Englischkenntnisse und Ubung
im Maschinen¨
¨
schreiben nutzlich.
Das Lernen besteht zunachst
darin, sich einige hundert
¨
Begriffe anzueignen. Das ist in jedem Wissensgebiet so. Man kann nicht uber
Primzahlen, Wahrscheinlichkeitsamplituden, Sonette oder Sonaten nachden¨
ken oder reden, ohne sich vorher uber
die Begriffe klar geworden zu sein.
Die Hardware (E: hardware, F: mat´eriel) umschließt alles, was aus Kupfer, Eisen, Kunststoffen, Glas und dergleichen besteht, was man anfassen
¨
kann. Dichterfurst
F RIEDRICH VON S CHILLER hat den Begriff Hardware
trefflich gekennzeichnet:
Leicht beieinander wohnen die Gedanken,
doch hart im Raume stoßen sich die Sachen.
Die Verse stehen in Wallensteins Tod im 2. Aufzug, 2. Auftritt. WALLENSTEIN
spricht sie zu M AX P ICCOLOMINI. Was sich hart im Raume st¨oßt, geh¨ort
zur Hardware, was leicht beieinander wohnt, die Gedanken, ist Software
(E: software, F: logiciel). Die Gedanken stecken in den Programmen und den
Daten.
Die reine Hardware – ohne Betriebssystem – tut nichts anderes als elek¨
trische Energie in Warme
zu verwandeln. Sie ist ein Ofen, mehr nicht. Das
¨
Betriebssystem ist ein Programm, das diesen Ofen befahigt,
Daten einzulesen und in bestimmter Weise zu antworten. Hardware plus Betriebssystem
machen den Rechner aus. Diese Kombination wird von vielen als System
bezeichnet. Manche sagen auch Plattform dazu. Eine bestimmte Hardware
kann mit verschiedenen Betriebssystemen laufen, umgekehrt kann dasselbe
Betriebssystem auch auf unterschiedlicher Hardware laufen (gerade das ist
¨
eine Starke
von Linux/UNIX).
Bekannte Betriebssysteme sind DOS von IBM, Microsoft oder Novell, Win¨ IBM-PCs und ihre Verwandtschaft,
dows von Microsoft sowie IBM OS/2 fur
¨ die Macintoshs, VMS fur
¨ die VAXen der Digital Equipment CorpoMacOS fur
¨
ration (DEC) sowie die UNIX-Familie einschließlich Linux und FreeBSD fur
eine ganze Reihe von mittleren Rechnern verschiedener Hersteller.
Um eine bestimmte Aufgabe zu erledigen – um einen Text zu schreiben,
ein Gleichungssystem zu l¨osen oder ein Getriebe zu konstruieren – braucht
man noch ein Anwendungsprogramm (E: application program, F: logiciel
d’application). Dieses erwirbt man fertig, zum Beispiel ein Programm zur
Textverarbeitung oder zur Tabellenkalkulation, oder schreibt es selbst. In diesem Fall muss man eine Programmiersprache (E: programming language,
¨
schon so viele schlechte Ubersetzungen
der amerikanischen Fachw¨orter gelesen, dass
ich der Deutlichkeit halber teilweise die amerikanischen W¨orter vorziehe. Oft sind
¨
auch die deutschen W¨orter mit unerwunschten
Assoziationen befrachtet. Wenn die
¨
Mediziner lateinische Fachausdrucke
verwenden, die Musiker italienische und die
Gastronomen franz¨osische, warum sollten die Informatiker nicht auch ihre termini
¨
¨
technici aus einer anderen Sprache ubernehmen
durfen?
¨
1 Uber
den Umgang mit Computern
8
F: langage de programmation) beherrschen. Die bekanntesten Sprachen sind
BASIC, COBOL, FORTRAN, JAVA, PASCAL und C/C++. Es gibt mehr als
¨ Genf wird eine Liste der Programmiersprachen
tausend4 . Bei der Universitat
¨
gefuhrt:
http://cui.unige.ch/langlist
Das n¨otige Wissen kann man auf mehreren Wegen erwerben und auf dem
laufenden halten:
• Kurse, Vorlesungen
¨
• Lehrbucher,
Skripten
• Zeitschriften
• Electronic Information
• Lernprogramme
Gute Kurse oder Vorlesungen verbinden Theorie und Praxis, das heißt Un¨
terricht und Ubungen
am Rechner. Zudem kann man Fragen stellen und bekommt Antworten. Nachteilig ist der feste Zeitplan. Die schwierigen Fragen
tauchen immer erst nach Kursende auf. Viele Kurse sind auch teuer.
¨
¨
Seit 1974 gibt es einen Europaischen
Computer-Fuhrerschein
(European Computer Driving Licence, ECDL) samt zugeh¨origem Ausbildungs¨
¨
und Prufungswesen
sowie Webseiten. Der Prufungsplan
(Syllabus) sieht
¨
Microsoft-lastig aus und wendet sich eher an Buroberufe
als an technische
¨ diesen Kreis sind vor allem die
oder naturwissenschaftliche Benutzer. Fur
¨
Themen Computer-Grafik und -Algebra sowie Programmieren zu erganzen.
Aber der im Netz zu findende Syllabus ist eine Hilfe beim Abchecken der ei¨
genen Fahigkeiten.
¨
Bei Buchern
und verwandten Werken sind zu unterscheiden:
¨
• Lehrbucher
¨
– Einfuhrungen,
Primer
– Einzelwerke, Monografien
• Nachschlagewerke
– Glossare, Lexika
¨
– Referenz-Handbucher,
Standards, Normen
¨
¨
Breit angelegte Lehrbucher
wie das vorliegende fuhren
durch ein Wissensgebiet, treffen eine Auswahl, werten oder diskutieren und verzichten zu Gun¨
sten der Verstandlichkeit
auf viele Einzelheiten. Einzelwerke behandeln ein
¨
¨
enges Thema ausfuhrlich.
Sie gehen in eine Tiefe, die den Anfanger
verwir¨
ren wurde.
Zu einer Reihe von Linux/UNIX-Kommandos, Programmierfragen
4 Zum
¨
Vergleich: es gibt etwa 6000 lebende naturliche
Sprachen. Die Bibel – oder
¨
Teile von ihr – ist in rund 2000 Sprachen ubersetzt.
1.3 Was muss man wissen?
9
und Netzdiensten gibt es solche vertiefenden Werke, siehe Anhang H Zum
Weiterlesen ab Seite 323.
Glossare und Lexika sind nach Stichw¨ortern alphabetisch geordnet und
dienen der schnellen Information, dem Einordnen eines Begriffes in einen
gr¨oßeren Zusammenhang und dem Erschließen verwandter Stichw¨orter, gegebenenfalls in weiteren Sprachen. Außer in Buchform erscheinen viele Glossare im Netz.
¨
¨
Referenzen mussen
vollstandig
und eindeutig sein. Sie beschreiben alle
Einzelheiten und helfen bei allgemeinen Schwierigkeiten gar nicht. Will man
¨
wissen, welche Werkzeuge Linux/UNIX zur Textverarbeitung bereit halt,
braucht man ein Lehrbuch. Will man hingegen wissen, wie man den Edi¨
tor vi(1) veranlasst, nach einer Zeichenfolge zu suchen, so schlagt
man
im Referenz-Handbuch nach. Auf Linux/UNIX-Systemen ist das Referenz¨
Handbuch online (auf dem Bildschirm) verfugbar,
siehe man(1), kommt
¨
gleich ausfuhrlicher.
¨
Die Eintrage
im Linux/UNIX-Referenz-Handbuch sind knapp gehalten.
Bei einfachen Kommandos wie pwd(1) oder who(1) sind sie dennoch auf den
¨
ersten Blick verstandlich.
Zu Kommandos wie vi(1), sh(1) oder xdb(1),
¨
die umfangreiche Aufgaben erledigen, geh¨oren schwer verstandliche
Ein¨
¨ des Kommandos bereits
trage,
die voraussetzen, dass man wesentliche Zuge
kennt.
¨
Ohne Rechner bleibt das Bucherwissen
trocken und abstrakt. Man sollte
¨
¨
daher die Bucher
in der Nahe
eines Terminals lesen, so dass man sein Wis¨
sen sofort ausprobieren kann5 . Das Durcharbeiten der Ubungen
geh¨ort dazu,
auch wegen der Erfolgserlebnisse.
¨
Zeitschriften berichten uber
Neuigkeiten. Manchmal bringen sie auch
Kurse in Fortsetzungsform. Ein Lehrbuch oder ein Referenz-Handbuch er¨
setzen sie nicht. Sie eignen sich zur Erganzung
und Weiterbildung, sobald
¨
¨
man uber
ein Grundwissen verfugt.
Von einer guten Computerzeitschrift darf
¨
man verlangen, dass sie uber
Email erreichbar ist und ihre Informationen
¨
¨
im Netz verfugbar
macht. Falls sie sehr gut ist, berucksichtigt
sie dabei auch
¨
sehgeschadigte
Leser.
Electronic Information besteht aus Mitteilungen in den Rechnernetzen.
Das sind Bulletin Boards (Schwarze Bretter), Computerkonferenzen, Electronic Mail, Netnews, Ver¨offentlichungen per Anonymous FTP, Webseiten und
¨
ahnliche
Dinge. Sie sind aktueller als Zeitschriften, die Diskussionsm¨oglich¨
keiten gehen weiter. Neben viel nutzlosem Zeug stehen hochwertige Beitrage
¨
von Fachleuten aus Universitaten
und Computerfirmen. Ein guter Tipp sind
die FAQ-Sammlungen (Frequently Asked Questions; Foire Aux Questions;
Fragen, Antworten, Quellen der Erleuchtung) in den Netnews. Hauptproblem
5 Es
heißt, dass von der Information, die man durch H¨oren aufnimmt, nur 30 %
¨
im Gedachtnis
haften bleiben. Beim Sehen sollen es 50 % sein, bei Sehen und H¨oren
¨
zusammen 70 %. Vollzieht man etwas eigenhandig
nach – begreift man es im w¨ortlichen Sinne – ist der Anteil noch h¨oher. Hingegen hat das maschinelle Kopieren von
¨
¨
Informationen keine Wirkungen auf das Gedachtnis
und kann nicht als Ersatz fur
die klassischen Wege des Lernens gelten.
¨
1 Uber
den Umgang mit Computern
10
¨
ist das Filtern der Informationsflut. Im Internet erscheinen taglich
(!) mehre¨
¨
re 10.000 Beitrage,
die Anzahl der Webseiten durfte
die Millionengrenze weit
¨
uberschritten
haben.
¨
Das Zusammenwirken von Buchern
oder Zeitschriften mit Electronic In¨
formation schaut vielversprechend aus. Manchen Buchern
liegt eine Diskette
oder eine CD-ROM bei. Das sind statische Informationen. Auf der WWW-Seite
http://www.ciw.uni-karlsruhe.de/technik.html haben wir – vor al¨ den eigenen Gebrauch – Verweise (Hyperlinks, URLs) zu den Themen
lem fur
dieses Buchs gesammelt, die zur weitergehenden Information verwendet werden k¨onnen. Das vorliegende Buch ist recht betrachtet Teil eines Systems aus
Papier und Elektronik.
Es gibt Lernprogramme zu Hardware, Betriebssystemen und Anwendungsprogrammen. Man k¨onnte meinen, dass sich gerade der Umgang mit
¨
dem Rechner mit Hilfe des Rechners lernen lasst.
Moderne Rechner mit Hy¨
pertext6 , bewegter farbiger Grafik, Dialogfahigkeit
und Tonausgabe bieten
¨
¨
tatsachlich
M¨oglichkeiten, die dem Buch verwehrt sind. Der Aufwand fur
¨
ein Lernprogramm, das diese M¨oglichkeiten ausnutzt, ist allerdings betrachtlich, und deshalb sind manche Lernprogramme nicht gerade ermunternd. Es
gibt zwar Programme – sogenannte Autorensysteme (E: authoring system,
F: ) – die das Schreiben von Lernsoftware erleichtern, aber Arbeit bleibt es
¨
¨ Unterstreitrotzdem. Auch gibt es vorlaufig
keinen befriedigenden Ersatz fur
¨
chungen und Randbemerkungen, mit denen eifrige Leser ihren Buchern
eine
pers¨onliche Note geben. Erst recht ersetzt ein Programm nicht die Ausstrah¨
lung eines guten Padagogen.
¨
¨
Uber den modernen Wegen der Wissensvermittlung hatte
ich beinahe
einen jahrzehntausendealten, aber immer noch aktuellen Weg vergessen:
Fragen. Wenn Sie etwas wissen wollen oder nicht verstanden haben, fragen
Sie, notfalls per Email. Die meisten Linux/UNIX-Wizards (wizard: person
who effects seeming impossibilities; man skilled in occult arts; person who
is permitted to do things forbidden to ordinary people) sind nette Menschen
¨
und freuen sich uber
Ihren Wissensdurst. M¨oglicherweise bekommen Sie verschiedene Antworten – es gibt in der Informatik auch Glaubensfragen – doch
nur so kommen Sie voran.
¨
Weiß auch Ihr Wizard nicht weiter, k¨onnen Sie sich an die Offentlichkeit
¨
wenden, das heißt an die schatzungsweise
zehn Millionen Usenet-Teilnehmer.
Den Weg dazu finden Sie unter dem Stichwort Netnews. Sie sollten allerdings
¨
vorher Ihre Handbucher
gelesen haben und diesen Weg nicht bloß aus Be¨
quemlichkeit wahlen.
Sonst erhalten Sie RTFM 7 als Antwort.
6 Hypertext
¨
¨
ist ein Text, bei dem Sie erklarungsbed
urftige
W¨orter anklicken und
¨
¨ diese Fußnote
dann die Erklarung
auf den Bildschirm bekommen. In Hypertext ware
¨
eine solche Erklarung.
Der Begriff wurde Anfang der 60er Jahre von T HEODOR H OL ¨
ME (T ED ) N ELSON in den USA gepragt.
Siehe Abschnitt ?? Hypertext auf Seite ??.
Mit dem Xanadu-Projekt hat er auch so etwas wie das World Wide Web vorweggenommen.
7 Anhang ?? Slang im Netz, Seite ??: Read The Fantastic Manual
¨
1.4 Wie lauft
eine Sitzung ab?
1.4
11
¨
Wie lauft
eine Sitzung ab?
Die Arbeit mit dem Rechner vollzieht sich meist im Sitzen vor einem Terminal und wird daher Sitzung (E: session, F: session) genannt. Mittels der
¨
Tastatur teilt der Benutzer dem Rechner seine Wunsche
mit, auf dem Bildschirm antwortet die Maschine. Diese Arbeitsweise wird interaktiv genannt
¨
und als Terminal-Dialog bezeichnet. Die Tastatur sieht ahnlich
aus wie ei¨
ne Schreibmaschinentastatur (weshalb Fahigkeiten
im Maschinenschreiben
¨
nutzlich
sind), hat aber ein paar Tasten mehr. Oft geh¨ort auch eine Maus (E:
mouse, F: souris) oder eine Rollkugel (E: trackball, F: boule de commande)
dazu. Der Bildschirm ist ein naher Verwandter des Fernsehers.
¨
Falls Sie mit einem Personal Computer arbeiten, mussen
Sie ihn als erstes
einschalten. Bei gr¨oßeren Anlagen, an denen mehrere Leute gleichzeitig ar¨ Sie erledigt, der
beiten, hat dies ein wichtiger und vielgeplagter Mensch fur
System-Verwalter, Administrator oder System-Manager. Sie sollten seine
Freundschaft suchen8 .
¨ der Rechner sein Betriebssystem, er bootet,
Nach dem Einschalten ladt
wie man so sagt. Booten (E: to boot, F: lancer le syst`eme) heißt eigent¨
lich Bootstrappen und das hinwiederum, sich an den eigenen Stiefelbandern
¨
oder Schnursenkeln
(bootstraps) aus dem Sumpf der Unwissenheit herauszie¨
hen wie weiland der Lugenbaron
K ARL F RIEDRICH H IERONYMUS F REIHERR
¨
¨
VON M UNCHHAUSEN an seinem Zopf9 . Zu Beginn kann der Rechner namlich
noch nicht lesen, muss aber sein Betriebssystem vom Massenspeicher lesen,
um lesen zu k¨onnen.
Ist dieser heikle Vorgang erfolgreich abgeschlossen, gibt der Rechner einen
Prompt (E: prompt, F: invite) auf dem Bildschirm aus. Der Prompt ist ein
Zeichen oder eine kurze Zeichengruppe – beispielsweise ein Pfeil, ein Dollarzeichen oder C geteilt durch gr¨oßer als – die besagt, dass der Rechner auf
Eingaben wartet. Der Prompt wird auch Systemanfrage, Bereitzeichen oder
Eingabeaufforderung genannt.
¨
Nun durfen
Sie in die Tasten greifen. Bei einem Mehrbenutzersystem erwartet der Rechner als erstes Ihre Anmeldung, das heißt die Eingabe des
Benutzer-Namens (E: user name, F: nom d’utilisateur), unter dem Sie der
Verwalter eingetragen hat. Man sagt auch, er habe Ihnen ein Konto (E:
¨
user account, F: compte d’acc`es) auf der Maschine eingerichtet. Als nachstes
wird die Eingabe eines Passwortes verlangt. Das Passwort (auch Passphra¨
se genannt, E: password, F: mot de passe) ist der Schlussel
zum Rechner. Es
wird auf dem Bildschirm nicht angezeigt. Bei der Eingabe von Namen und
Passwort sind meist keine Korrekturen zugelassen, Groß- und Kleinschreibung wird unterschieden. War Ihre Anmeldung in Ordnung, heißt der Rechner Sie herzlich willkommen und promptet wieder. Die Arbeit beginnt. Auf ei8 Laden
Sie ihn gelegentlich zu Kaffee und Kuchen oder einem Viertele Wein ein.
¨
G OTTFRIED AUGUST B URGER
, Wunderbare Reisen zu Wasser und zu Lan¨
¨
de, Feldzuge
und lustige Abenteuer des Freiherrn von Munchhausen,
wie er diesel¨
ben bei der Flasche im Zirkel seiner Freunde selbst zu erzahlen
pflegt. Insel Taschenbuch 207, Insel Verlag Frankfurt (Main) (1976), im 4. Kapitel
9 Siehe
12
¨
1 Uber
den Umgang mit Computern
nem DOS-PC geben Sie beispielsweise dir ein, auf einer Linux/UNIX-Anlage
ls. Jede Eingabe wird mit der Eingabe-Taste (auch mit Return, Enter, CR
oder einem geknickten Pfeil nach links bezeichnet; E: return key, F: touche de
retour) abgeschlossen10 .
¨
Zum Eingew¨ohnen fuhren
wir eine kleine Sitzung durch, m¨oglichst im Beisein eines Systemkundigen. Suchen Sie sich ein freies Linux/UNIX-Terminal.
Auf die Aufforderung zur Anmeldung (login) tippen Sie Ihren Benutzernamen ein, Eingabe-Taste nicht vergessen, dann Ihr Passwort. Nach dem Willkommensgruß des Systems geben wir folgende Linux/UNIX-Kommandos ein
(Eingabe-Taste!) und versuchen, ihre Bedeutung mithilfe der Online-Referenz
¨
(man-Kommandos) naherungsweise
zu verstehen:
who
man who
date
man date
pwd
man pwd
ls
ls -l /bin
man ls
exit
¨
Falls auf dem Bildschirm links unten das Wort more erscheint, betatigen
Sie
die Zwischenraum-Taste (E: space bar, F: ). more(1) ist ein Pager, ein Programm, das einen Text seiten- oder bildschirmweise ausgibt.
Die Grundform eines Linux/UNIX-Kommandos ist:
Kommando -Optionen Argumente
Statt Option findet man auch die Bezeichnung Parameter, Flag oder Schalter. Eine Option modifiziert die Wirkungsweise des Kommandos, beispiels¨
weise wird die Ausgabe des Kommandos ls ausfuhrlicher,
wenn wir die Option -l (long) dazuschreiben. Argumente sind Datei-Namen oder andere Informationen, die das Kommando ben¨otigt, oben der Verzeichnisname /bin.
Bei den Namen der Linux/UNIX-Kommandos haben sich ihre Sch¨opfer etwas gedacht, nur was, bleibt hin und wieder im Dunkeln. Hinter manchen
Namen steckt auch eine ganze Geschichte, wie man sie in der Newsgruppe
¨
comp.society.folklore im Netz erfahrt.
Das Kommando exit beendet
die Sitzung. Es ist ein internes Shell-Kommando und im Handbuch unter der
Beschreibung der Shell sh(1) zu finden.
¨ beendet werden. Es reicht nicht, sich
Jede Sitzung muss ordnungsgemaß
einfach vom Stuhl zu erheben. Laufende Programme – zum Beispiel ein Edi¨
tor – mussen
zu Ende gebracht werden, auf einer Mehrbenutzeranlage meldet
10 Manche
Systeme unterscheiden zwischen Return- und Enter-Taste, rien n’est
¨ den kirchlichen Gebrauch tragt
¨ die Taste die Bezeichnung
simple. Auf Tastaturen fur
Amen.
¨ man nach?
1.5 Wo schlagt
13
man sich mit einem Kommando ab, das exit, quit, logoff, logout, stop,
bye oder end lautet. Arbeiten Sie mit Fenstern, so findet sich irgendwo am
Rand das Bild eines Knopfes (E: button, F: bouton) namens exit. Ihren eige¨
nen PC durfen
Sie selbst herunterfahren und ausschalten, ansonsten erledigt
das wieder der Verwalter. Das Ausschalten des Terminals einer Mehrbenut¨ den Rechner keine Bedeutung, die Sitzung lauft
¨
zeranlage hat fur
weiter!
Stundenlanges Arbeiten am Bildschirm belastet die Augen, stundenlan¨
ges Bucherlesen
oder Autofahren genauso. Eine gute Information zu diesem
¨ Gießen unter dem URL:
Thema findet sich in der Universitat
http://www.uni-giessen.de/˜gkw1/patient/
arbeitsplatz.html
¨ Linux/UNIX und C/C++ sind große und kleine Buchstaben verMerke: Fur
schiedene Zeichen. Ferner sind die Ziffer 0 und der Buchstabe O auseinanderzuhalten.
1.5
¨ man nach?
Wo schlagt
Wenn es um Einzelheiten geht, ist das zu jedem Linux/UNIX-System geh¨orende und einheitlich aufgebaute Referenz-Handbuch – auf Papier, CD oder
Bildschirm – die wichtigste Hilfe11 . Es gliedert sich in folgende Sektionen:
• 1
Kommandos und Anwendungsprogramme
• 1M
Kommandos zur Systemverwaltung (maintenance)
• 2
Systemaufrufe
• 3C
Subroutinen der Standard-C-Bibliothek
• 3M
Mathematische Bibliothek
• 3S
Subroutinen der Standard-I/O-Bibliothek
• 3X
Besondere Bibliotheken
• 4
¨
Datei-Formate oder Gerate-Dateien
¨
• 5
Vermischtes (z. B. Datei-Hierarchie, Zeichensatze)
oder DateiFormate
• 6
Spiele
• 7
¨
Geratefiles
oder Makros
• 8
Systemverwaltung
• 9
Glossar oder Kernroutinen
11 Real
programmers don’t read manuals, sagt das Netz.
¨
1 Uber
den Umgang mit Computern
14
¨ eiSubroutinen sind in diesem Zusammenhang vorgefertigte Funktionen fur
gene Programme, Standardfunktionen oder Unterprogramme mit anderen
¨
Worten. Die erste Seite jeder Sektion ist mit intro betitelt und fuhrt
in
¨
den Inhalt der Sektion ein. Beim Erwahnen
eines Kommandos wird die Sektion des Handbuchs in Klammern angegeben, da das gleiche Stichwort in
mehreren Sektionen mit unterschiedlicher Bedeutung vorkommen kann, beispielsweise cpio(1) und cpio(4). Die Einordnung eines Stichwortes in eine
¨
Sektion variiert etwas zwischen verschiedenen Linux/UNIX-Abfullungen.
Die
Eintragungen zu den Kommandos oder Stichw¨ortern sind wieder gleich aufgebaut:
• Name (Name des Kommandos)
• Synopsis, Syntax (Gebrauch des Kommandos)
• Remarks (Anmerkungen)
• Description (Beschreibung des Kommandos)
¨
• Return Value (Ruckgabewert
des Programms)
• Examples (Beispiele)
¨
• Hardware Dependencies (hardwareabhangige
Eigenheiten)
• Author (Urheber des Kommandos)
• Files (vom Kommando betroffene Dateien)
¨
• See Also (ahnliche
oder verwandte Kommandos)
• Diagnostics (Fehlermeldungen)
¨
• Bugs (Mangel,
soweit bekannt)
• Caveats, Warnings (Warnungen)
¨
• International Support (europaische
Absonderlichkeiten)
Bei vielen Kommandos finden sich nur Name, Synopsis und Description. Zu
einigen kommt eine Beschreibung mit, die ausgedruckt mehr als hundert Seiten A4 umfasst. Der Zweck des Kommandos wird meist verheimlicht; deshalb versuche ich, diesen Punkt zu erhellen. Was hilft die Beschreibung eines
Schweißbrenners, wenn Sie nicht wissen, was und warum man schweißt? Am
Fuß jeder Handbuch-Seite steht das Datum der Ver¨offentlichung.
Einige Kommandos oder Standardfunktionen haben keinen eigenen Eintrag, sondern sind mit anderen zusammengefasst. So findet man das Kom¨ das Kommando cp(1) oder die Stanmando mv(1) unter der Eintragung fur
dardfunktion gmtime(3) bei der Standardfunktion ctime(3). In solchen
¨
Fallen
muss man das Sachregister, den Index des Handbuchs befragen. Auf
manchen Systemen findet sich auch ein Kommando apropos(1), das in den
¨
man-Seiten nach Schlusselw¨
ortern sucht.
¨
Mittels des Kommandos man(1) holt man die Eintrage
aus dem gespeicherten Referenz-Handbuch (On-line-Manual, man-Seiten, man-pages) auf
den Bildschirm oder Drucker. Das On-line-Manual sollte zu den auf dem Sys¨
tem vorhandenen Kommandos passen, wahrend
das papierne Handbuch veraltet oder verschwunden sein kann. Versuchen Sie folgende Eingaben:
1.6 Warum verwendet man Computer (nicht)?
man
man
man
man
man
man
man
15
pwd
time
2 time
-k time
man
man | col -b > manual.txt
man | col -b | lp
Die Zahlenangabe bei der dritten Eingabe bezieht sich auf die Sektion. Mit
¨
¨
der vierten Zeile erfahrt
man m¨oglicherweise etwas zum Schlusselwort
time.
Falls nicht, weisen Sie Ihren Verwalter auf das Kommando catman(1M) hin.
Die letzten beiden Eingabezeilen geben die Handbuchseiten zum Kommando
man(1) in eine Datei oder auf den Default-Drucker aus (fragen Sie Ihren Arzt
¨ das Drucken gibt es viele
oder Apotheker oder besser Ihren Verwalter, fur
Wege). Drucken Sie aber nicht das ganze Handbuch aus, die meisten Seiten
braucht man nie.
Die Struktur des Hilfesystems wird in Abschnitt 2.10.3 Erstellen eigener
man-Seiten auf Seite 204 im Zusammenhang mit der Dokumentation von Pro¨
grammen erlautert.
1.6
Warum verwendet man Computer (nicht)?
¨
Philosophische Interessen sind bei Ingenieuren haufig
eine Alterserscheinung, meint der Wiener Computerpionier H EINZ Z EMANEK. Ich glaube, das
n¨otige Alter zu haben, um dann und wann das Wort warum in den Mund
¨
¨
nehmen oder in die Tastatur hacken zu durfen.
Junge Informatiker außern
¨
diese Frage auch gern. Bei der Umstellung einer hergebrachten Tatigkeit
auf
Computer steht oft die Zeitersparnis (= Kostenersparnis) im Vordergrund.
¨
¨ die Umstellung herangezogen. Das
Zumindest wird sie als Begrundung
fur
¨
ist weitgehend falsch. Wahrend
der Umstellung muss doppelgleisig gearbei¨
tet werden, und hernach erfordert das Rechnersystem eine standige
Pflege.
¨ verurEinige Arbeiten gehen mit Rechnerhilfe schneller von der Hand, dafur
sacht der Rechner selbst Arbeit. Auf Dauer sollte ein Gewinn herauskommen,
¨
aber die Erwartungen sind oft uberzogen.
Nach drei bis zehn Jahren Betrieb ist ein Rechner veraltet. Die weitere
Benutzung ist unwirtschaftlich, das heißt man k¨onnte mit dem bisherigen
¨
Aufwand an Zeit und Geld eine leistungsfahigere
Anlage betreiben oder mit
einer neuen Anlage den Aufwand verringern. Dann stellt sich die Frage, wie
¨
die alten Daten weiterhin verfugbar
gehalten werden k¨onnen. Denken Sie
an die Lochkartenstapel oder Disketten verflossener Jahrzehnte, die heute
¨
nicht mehr lesbar sind, weil es die Maschinen nicht langer
gibt. Oft muss man
¨
auch mit der Anlage die Programme wechseln. Der Ubergang
zu einem neuen System ist von Zeit zu Zeit unausweichlich, wird aber von Technikern und
¨
¨
Kaufleuten gleichermaßen gefurchtet.
Auch dieser Aufwand ist zu berucksichtigen. Mit Papier und Tinte war das einfacher; einen Brief unserer Urgroßeltern k¨onnen wir heute noch lesen.
16
¨
1 Uber
den Umgang mit Computern
¨
Deutlicher als der Zeitgewinn ist der Qualitatsgewinn
der Arbeitsergeb¨
nisse. In einer Buchhaltung sind dank der Unterstutzung
durch Rechner die
¨
Auswertungen aktueller und differenzierter als fruher.
Informationen – zum
Beispiel aus Einkauf und Verkauf – lassen sich schneller, sicherer und ein¨
facher miteinander verknupfen
als auf dem Papierweg. Manuskripte lassen
¨
sich bequemer andern
und besser formatieren als zu Zeiten der mechanischen Schreibmaschine. Von technischen Zeichnungen lassen sich mit minimalem Aufwand Varianten herstellen. Mit Simulationsprogrammen k¨onnen
¨
Entwurfe
getestet werden, ehe man an echte und kostspielige Versuche geht.
Literaturrecherchen decken heute eine weit gr¨oßere Menge von Ver¨offentli¨
chungen ab als vor vierzig Jahren. Große Datenmengen waren fruher
gar
¨
¨
nicht oder nur mit Einschrankungen
zu bewaltigen.
Solche Aufgaben kommen beim Suchen oder Sortieren sowie bei der numerischen Behandlung von
Problemen aus der Wettervorhersage, der Str¨omungslehre, der Berechnung
¨
von Flugbahnen oder Verbrennungsvorgangen
vor. Das Durchsuchen umfang¨
reicher Datensammlungen ist eine Lieblingsbeschaftigung
der Rechner.
Noch eine Warnung. Die Arbeit wird durch Rechner nur selten einfacher.
Mit einem Bleistift k¨onnen die meisten umgehen. Die Benutzung eines Texteditors erfordert eine Einarbeitung, die Ausnutzung aller M¨oglichkeiten ei¨
¨
nes leistungsfahigen
Textsystems eine lange Vorbereitung und standige
Wei¨
¨ vor funfzig
¨
terbildung. Ein Schriftstuck
wie das vorliegende ware
Jahren
nicht am Schreibtisch herzustellen gewesen; heute ist das mit Rechnerhil¨
fe kein Hexenwerk, setzt aber eine eingehende Beschaftigung
mit mehreren
Programmen (Editor, LaTeX, RCS, make(1), dvips(1), xdvi(1), xfig(1)
und eine Handvoll kleinerer Linux/UNIX-Werkzeuge) und Fragen zur Gestaltung von Schriftwerken voraus.
Man darf nicht vergessen, dass der Rechner ein Werkzeug ist. Er bereitet
¨
Daten auf, interpretiert sie aber nicht. Er ubernimmt
keine Verantwortung
¨
und handelt nicht nach ethischen Grundsatzen.
Er rechnet, aber wertet nicht.
¨
Das ist keine technische Unvollkommenheit, sondern eine grundsatzliche
Ei¨
genschaft. Die Fahigkeit
zur Verantwortung setzt die Willensfreiheit voraus
¨
und diese beinhaltet den eigenen Willen. Ein Rechner, der anfangt,
einen ei¨ die Werkstatt.
genen Willen zu entwickeln, ist ein Fall fur
Der Rechner soll den Menschen ebensowenig ersetzen wie ein Hammer die
¨
Hand ersetzt, sondern ihn erganzen.
Das h¨ort sich banal an, aber manchmal
ist die Aufgabenverteilung zwischen Mensch und Rechner schwierig zu erkennen. Es ist bequem, die Entscheidung samt der Verantwortung der Maschine
zuzuschieben. Es gibt auch Aufgaben, bei denen der Rechner einen Menschen
¨
ersetzen kann – wenn nicht heute, dann kunftig
– aber dennoch nicht soll.
¨
Nehmen wir zwei Extremfalle.
Rufe ich die Telefonnummer 0721/19429 an,
so antwortet ein Automat und teilt mir den Pegelstand des Rheins bei Karlsruhe mit. Das ist ok, denn ich will nur die Information bekommen. Ruft man
dagegen die Telefonseelsorge an, erwartet man, dass ein Mensch zuh¨ort, wo¨
bei das Zuh¨oren wichtiger ist als das Ubermitteln
einer Information. So klar
¨
liegen die Verhaltnisse
nicht immer. Wie sieht es mit dem Rechner als Leh¨
rer aus? Darf ein Rechner Studenten prufen?
Soll ein Arzt eine Diagnose vom
1.7 Begriffe
17
¨
Rechner stellen lassen? Ist ein Rechner zuverlassiger
als ein Mensch? Ist die
¨
¨
¨
¨
Kunstliche
Intelligenz in allen Fallen
der Naturlichen
Dummheit uberlegen?
¨
¨
Soll man die Entscheidung uber
Krieg und Frieden dem Prasidenten
der USA
¨
¨
uberlassen
oder besser seinem Rechner? Und wenn der Prasident
zwar ent¨
¨
scheidet, sich aber auf die Auskunfte
seines Rechners verlasst?
Wer ist dann
¨
wichtiger, der Prasident
oder sein Rechner?
Je besser die Rechner funktionieren, desto mehr neigen wir dazu, die Da¨ maßgebend zu halten und Abweichungen der realen Welt von der
tenwelt fur
¨ St¨orungen. H¨ort sich ubertrieben
¨
Datenwelt fur
an, ist es auch, aber wie lange
¨
noch? Fachliteratur, die nicht in einer Datenbank gespeichert ist, zahlt
prak¨
tisch nicht mehr. Texte, die sich nicht per Rechner in andere Sprachen uber¨
setzen lassen, gelten als mangelhaft. Bei Meinungsverschiedenheiten uber
¨
personenbezogene Daten hat zunachst
einmal der Rechner recht, und wenn
¨
¨
er Briefe an Herrn Marianne Meier schreibt. Das lasst
sich klaren,
aber wie
sieht es mit dem Weltbild aus, das die Computerspiele unseren Kindern vermitteln? Welche Welt ist wirklich? Kann man von Spielgeld leben? Haben
¨ wie die virtuellen Helden? War Der
die Mitmenschen ein so einfaches Gemut
langste
¨
Tag nur ein Bildschirmspektakel? Brauchten wir 1945 nur neu zu
booten?
¨
Unbehagen bereitet auch manchmal die zunehmende Abhangigkeit
vom
¨
¨
Rechner, die bei St¨orfallen
unmittelbar zu spuren
ist – sei es, dass der Rech¨
ner streikt oder dass der Strom ausfallt.
Da gibt es Augenblicke, in denen sich
¨
¨
die Verwalter fragen, warum sie nicht Minnesanger
oder Leuchtturmwarter
¨
geworden sind. Nun, der Mensch war immer abhangig.
In der Steinzeit da¨
¨
¨
von, dass es genugend
viele nicht zu starke Baren
gab, spater
davon, dass
¨
das Wetter die Ernte begunstigte,
und heute sind wir auf die Rechner ange¨
¨
¨
¨
wiesen. Im Unterschied zu fruher
– als der erfahrene Barenj
ager
die Baren¨
¨ der
lage uberblickte
– hat heute der Einzelne nur ein unbestimmtes Gefuhl
¨
Abhangigkeit
von Dingen, die er nicht kennt und nicht beeinflussen kann.
¨
Mit den Rechnern wird es uns vermutlich ahnlich
ergehen wie mit der
¨ wir werden uns daran gew¨ohnen. Wie man fur
¨ Stromausfalle
¨
Elektrizitat:
¨
¨
eine Petroleumlampe und einen Campingkocher bereithalt,
sollte man fur
¨
¨
Rechnerausfalle
etwas Papier, einen Bleistift und ein gutes, zum Umblattern
¨
geeignetes Buch zurucklegen.
1.7
Begriffe
Folgende Begriffe sollten klarer geworden sein:
• Anwendungsprogramm
• Benutzer, System-Verwalter
• Betriebssystem
¨ Darstellung
• binare
• Bit, Byte, Oktett
¨
1 Uber
den Umgang mit Computern
18
• booten
• Dualsystem, Oktalsystem, Hexadezimalsystem
• Hardware, Software
• Informatik
• Kommando, Eingabe-Taste
• Konto, Benutzername, Passwort
• Prompt
• Prozessor, CPU, Arbeitsspeicher, Massenspeicher
• Programmiersprache
• Rechner (Computer)
• Referenz-Handbuch, man-Seiten, man(1)
• Sitzung, anmelden, abmelden
¨
¨
• Speichern, Ubermitteln
und Verandern
von Daten
• Terminal, Bildschirm, Tastatur
• Linux/UNIX-Kommando, Option, Argument
Folgende Linux/UNIX-Kommandos sollten bekannt sein:
• exit
• man
• who
• date
• pwd
• ls
1.8
Memo
1.9
Fragen
Brevity is the soul of wit.
Shakespeare, Hamlet
2
Programmieren in C/C++
¨ die Kunst des Programmierens anhand der SpraDieses Kapitel erklart
che C/C++. Anfangskenntnisse im Programmieren in einer anderen Sprache
(BASIC, FORTRAN, PASCAL, COBOL) sind hilfreich.
2.1
2.1.1
Grundbegriffe
Wozu Programmierkenntnisse?
Auch wer seine Br¨otchen nicht mit Programmieren verdient, sondern nur mit
Computern arbeitet, braucht Grundkenntnisse im Programmieren, um die
richtigen Vorstellungen von dem Geschehen hinter dem Bildschirm zu haben.
Nicht jeder Maschinenbauer muss einen Kolbenmotor konstruieren k¨onnen,
aber er muss wissen, wie eine Kolbenmaschine aufgebaut ist und funktio¨
niert, und er sollte mit einem Schraubenschlussel
umgehen k¨onnen. Hinzu
¨
¨
kommt, dass haufig
kleinere Anpassungen oder Erganzungen
der Software
¨ die man nicht immer einen Spezialisten hat.
erforderlich sind, fur
Wenn es ernst wird, bezieht man seine Kenntnisse aus drei Quellen, nmlich aus:
• einem Lehrbuch wie diesem,
• einer Referenz zum Nachschlagen, siehe das Verzeichnis am Ende des
Buches,
• einer Sammlung von Frequently Asked Questions aus dem Internet, hier
zu den Themen C und C++.
Das Lehrbuch sorgt fr den berblick, die Referenz vermittelt Einzelheiten, die
FAQ beantwortet die offen gebliebenen Fragen. FAQs zu C und C++ finden
sich unter:
• www.eskimo.com/ scs/c-faq/top.html, die FAQ der Newsgruppe
comp.lang.c,
• www-info2.informatik.uni-wuerzburg.de/dclc-faq/, die FAQ
der Newsgruppe de.comp.lang.c,
• www.faqs.org/faqs/C-faq/learn/,
• www.cerfnet.com/˜mpcline/c++-faq-lite/,
• rtfm.mit.edu/pub/usenet-by-hierarchy/news/answers/
C++-faq/ bzw. C-faq/.
19
20
2 Programmieren in C/C++
Langfristig sind auch die genannen Newsgruppen eine Quelle der Erleuchtung, aber man sollte Grundkenntnisse erworben haben, ehe man dort mitmischt.
2.1.2
Warum braucht man Programmiersprachen?
Von einer Anweisung in einer h¨oheren Programmiersprache bis zu den Nullen und Einsen im Befehlsregister des Prozessors ist ein weiter Weg. Wir wollen diesen Weg schrittweise an Hand eines kleinen, aber weltweit bekannten
Programmes verfolgen. Das Programm schreibt den Gruß Hallo, Welt! auf den
¨
Bildschirm. Weitere Exemplare dieses Programmes in uber
200 Programmier1
sprachen finden sich bei der Louisiana Tech University unter:
http://www.latech.edu/˜acm/HelloWorld.shtml
Als erstes das Programm, so wie es ein C-Programmierer schreibt:
/* hallo.c, C-Programm */
#include <stdio.h>
int main()
{
printf("Hallo, Welt!\n");
return 0;
}
Das Aussehen des Textes wird durch den ANSI-C-Standard bestimmt, letzten
Endes durch die Leute, die die Sprache C entwickelt haben. Diese Form des
¨
Programmes wird von geubten
Programmierern verstanden und Programmquelle (source) genannt. Die Maschine kann nichts damit anfangen.
¨
Damit das Programm von einer Maschine ausgefuhrt
werden kann, muss
¨
es ubersetzt
werden. Hierzu wird ein weiteres Programm, ein Compiler, her¨
¨
angezogen. Im Fall von C lauft
der Ubersetzungsvorgang
in mehreren Schritten ab, ohne dass der Benutzer etwas davon merkt. Wir verwenden hier den
¨
GNU-C-Compiler unter MS-DOS auf einem PC. Im ersten Schritt (Praprozes¨ die Maschine unbedeutende Kommentar entfernt und die
sor) werden der fur
¨
¨
mit einem Doppelkreuz beginnenden Praprozessor-Anweisungen
ausgefuhrt.
¨
Das Ergebnis sieht leicht gekurzt
so aus:
# 1 "hallo.c"
# 1 "c:/djgpp/include/stdio.h" 1 3
# 1 "c:/djgpp/include/sys/djtypes.h" 1 3
# 12 "c:/djgpp/include/stdio.h" 2 3
typedef void *va list;
typedef long unsigned int size t;
1 Unter
¨
www.ionet.net/˜timtroyr/funhouse/beer.html liegt eine ahnliche
Sammlung.
2.1 Grundbegriffe
21
typedef struct {
cnt;
int
char * ptr;
char * base;
int
bufsiz;
int
flag;
int
file;
char * name to remove;
} FILE;
extern FILE
void
int
int
.
.
int
.
.
int
dj stdin,
dj stdout,
dj stderr;
clearerr(FILE * stream);
fclose(FILE * stream);
feof(FILE * stream);
printf(const char * format, ...);
vsprintf(char * s, const char * format, va list
extern FILE
dj stdprn,
ap);
dj stdaux;
# 3 "hallo.c" 2
int main()
{
printf("Hallo, Welt!\n");
return 0;
}
¨
¨ hat.
Wir erkennen, dass der Praprozessor
eine Reihe von Zeilen hinzugefugt
Im Prinzip k¨onnte das auch der Programmierer machen, doch so erspart man
¨
sich viel routinemaßige
Arbeit.
Im zweiten Schritt wird das C-Programm in ein Assembler-Programm
¨
ubersetzt:
.file
"hallo.c"
gcc2 compiled.:
gnu compiled c:
.text
LC0:
.ascii "Hallo, Welt!\12\0"
.align 2
.globl main
main:
pushl %ebp
movl %esp,%ebp
main
call
pushl $LC0
call printf
addl $4,%esp
xorl %eax,%eax
jmp L1
22
2 Programmieren in C/C++
.align 2,0x90
L1:
leave
ret
¨
Selbst diese, bereits schwerer verstandliche
Form k¨onnte ein erfahrener Pro¨
grammierer noch von Hand schreiben. Fruher
gab es nichts anderes. Im
Großen und Ganzen entspricht eine Anweisung in C oder FORTRAN vier
Assembler-Anweisungen. Die Assembler-Befehle werden zu einem wesentlichen Teil durch den Hersteller der CPU bestimmt, hier also durch Intel. Das
Assembler-Programm ist an die Hardware und das Betriebssystem gebunden.
¨
Nun folgt als dritter Schritt die Ubersetzung
des Assemblerprogramms in
¨
ein Maschinenprogramm, hier gekurzt
und mit Hexadezimalzahlen anstelle
der Nullen und Einsen wiedergegeben:
4c01
0000
0000
0000
6100
0000
4000
0300
0401
0000
0000
0000
0000
0000
66da
2e74
3000
0300
3000
0000
2e62
7d31
6578
0000
0000
0000
0000
7373
da00
7400
8c00
2000
3000
0000
0000
0000
0000
0000
0000
0000
0000
0000
0d00
0000
bc00
2e64
0000
0000
3000
0000
0000
0000
6174
0000
0000
0000
¨ einen Menschen nicht mehr verstandlich,
¨
¨
Diese Form ist fur
stattdessen fur
die Maschine, weshalb sie als Maschinencode bezeichnet wird, gelegentlich
¨
¨
auch als Objektcode. Ein ZuruckUbersetzen
in Assemblercode ist nur einge2
¨
schrankt
m¨oglich .
¨
Obige Form ist jedoch immer noch nicht ausfuhrbar.
Wir verwenden eine
Standard-Funktion printf() zur Ausgabe auf den Bildschirm. Auch hinter
¨
dem W¨ortchen main verbirgt sich einiges. Deren Code muß noch hinzugefugt
¨
werden, dann kann die Maschine loslegen mit der Begrußung.
Diesen letz¨
ten Schritt vollzieht der Linker. Der Anfang des ausfuhrbaren
Programmes
hallo.exe sieht nicht besser aus als vorher, der Umfang des Programmfiles
ist gr¨oßer geworden:
4d5a
6007
2067
7374
6d2c
2032
5468
0000
0000
656e
7562
206f
333a
6520
0400
5400
6572
2e61
6e20
3433
5354
0000
0000
6174
736d
5475
3a35
5542
2000
0d0a
6564
2062
6520
3820
2e45
2700
7374
2066
7920
4a61
3139
5845
ffff
7562
726f
646a
6e20
3936
2073
0000
2e68
6d20
6173
3330
0d0a
7475
¨
¨
Das musste
ein Programmierer schreiben, gabe
es keine h¨oheren Programmiersprachen. Als Kontrast dazu ein kurzes Beispiel einer problemangepassten, maschinenfernen Sprache (SQL). Die Aufgabe sei die Abfrage einer Da¨
tenbank, die ihre Daten in Form von Tabellen mit Spalten und Zeilen halt:
¨
¨
Das RuckUbersetzen
ist m¨oglich, das Ergebnis jedoch praktisch unbrauchbar, wenn es um mehr als triviale Programme geht.
2 Genauer:
2.1 Grundbegriffe
23
select nachname, vorname, telefon from mitarbeiter
where wohnort=’Karlsruhe’
order by nachname, vorname;
Die Datenbank soll bittesch¨on ein Liste mit Nachnamen, Vornamen und Telefonnummer aus der Tabelle mitarbeiter herausziehen und dabei nur die
¨
Mitarbeiter berucksichtigen,
deren Wohnort Karlsruhe ist. Die Liste soll an
erster Stelle nach dem Nachnamen alphabetisch sortiert sein, bei gleichem
¨
Nachnamen nach dem Vornamen. Einfacher lasst
sich eine Aufgabe kaum
formulieren.
Eine Programmiersprache wird von zwei Seiten her entwickelt. Von oben,
den zu programmierenden Aufgaben aus der realen Welt her, kommen die
Anforderungen an die Sprache. Von unten, der Hardware (CPU) und dem
Betriebssystem her kommen die M¨oglichkeiten zur L¨osung der Aufgaben. Wir
haben folgende Schichten:
• Aufgabe, Problem
• L¨osungsweg, Algorithmus
• Programm in einer h¨oheren (problemorientierten) Sprache
• Assemblerprogramm
• Maschinenprogramm
• Mikroprogramme (Firmware) im Computer
• Elektronik
¨
Jede Schicht stellt ein Modell der nachsth¨
oheren Schicht dar, wobei das, was
¨
sich in der Elektronik abspielt, hoffentlich noch etwas mit der ursprunglichen Aufgabe zu tun hat. Der Compilerbauer muss sowohl das Problem wie
die Hardware samt Betriebssystem im Auge haben, wenn er beispielsweise
¨ das Betriebssystem PC-DOS auf einem Intel-Prozessor
einen C-Compiler fur
¨
¨ Compiler interessiert, kann mit dem Buch von
schreibt. Wer sich naher
fur
A LFRED V. A HO – genannt das Dragon-Book – beginnen. Die Thematik geht
¨
uber
den Bau von Compilern hinaus und erstreckt sich ganz allgemein auf
die Analyse und Verarbeitung von Zeichenfolgen.
2.1.3
Sprachenfamilien
Hat man eine Aufgabe, ein Problem zu l¨osen, so kann man drei Abschnitte
auf dem Weg unterscheiden:
• Aufgabenstellung,
• L¨osungsweg,
• Ergebnis.
¨ die Aufgabe bereits gel¨ost. Die
Das Ergebnis ist nicht bekannt, sonst ware
Aufgabenstellung und erforderlichenfalls einen L¨osungsweg sollten wir kennen.
24
2 Programmieren in C/C++
Mithilfe der bekannten Programmiersprachen von BASIC bis C++ be¨ den Computer geeigneten Form.
schreiben wir den L¨osungsweg in einer fur
Diese Programmiersprachen werden als algorithmische oder prozedurale Programmiersprachen im weiteren Sinn bezeichnet, weil die Programme
aus Prozeduren bestehen, die Anweisungen an den Computer enthalten (lateinisch procedere = vorangehen). Diese Familie wird unterteilt in die imperativen oder prozeduralen Sprachen im engeren Sinne einerseits und die objektorientierten Sprachen andererseits (lateinisch imperare = befehlen).
¨ es jedoch, wir k¨onnten uns mit der Beschreibung der AufBequemer ware
¨
¨
gabe begnugen
und das Finden eines L¨osungsweges dem Computer uber¨
lassen. Sein Nutzen wurde
damit bedeutend wachsen. Die noch nicht sehr
verbreiteten deklarativen Programmiersprachen gehen diesen Weg (latei¨
nisch declarare = erklaren,
beschreiben). Die Datenbank-Abfragesprache
SQL (Structured Query Language) geh¨ort hierher: in den Programmen (SQLScript) steht, was man wissen will, nicht, wie man dazu kommt. Die deklarativen Sprachen unterteilt man in die funktionalen und die logischen oder
¨
pradikativen
Sprachen.
¨
Wir haben also folgende Einteilung (wobei die tatsachlich
benutzten Spra¨
¨
chen Mischlinge sind und die Einordnung ihrem am starksten
ausgepragten
Charakterzug folgt):
• Prozedurale Sprachen im weiteren Sinn
– imperative, algorithmische, operative oder im engeren Sinn prozedurale Sprachen (BASIC, FORTRAN, COBOL, C, PASCAL)
– objektorientierte Sprachen (SMALLTALK, C++, Java)
• Deklarative Sprachen
– funktionale oder applikative Sprachen (LISP, SCHEME, HASKELL)
¨
– logische oder pradikative
Sprachen (PROLOG)
Diese Sprachentypen werden auch Paradigmen (Beispiel, Muster) genannt.
¨
Auf imperative und objektorientierte Sprachen gehen wir bald ausfuhrlich
¨
ein. Zuerst ein kurzer Blick auf funktionale und pradikative
Sprachen.
Programme in funktionalen Programmiersprachen wie LISP oder SCHE¨
¨
ME bestehen aus Definitionen von Funktionen, außerlich
ahnlich
einem Gleichungssystem, die auf Listen von Werten angewendet werden. Hier das HelloWorld-Programm in LISP:
; LISP
(DEFUN HELLO-WORLD ()
(PRINT (LIST ’HELLO ’WORLD)))
Quelle 2.1 : LISP-Programm Hello, World
und auch noch in SCHEME:
2.1 Grundbegriffe
25
(define hello-world
(lambda ()
(begin
(write ’Hello-World)
(newline)
(hello-world))))
Quelle 2.2 : SCHEME-Programm Hello, World
¨
¨ ins Auge, aber ansonDie großzugige
Verwendung runder Klammern fallt
sten sind die Programme zu einfach, um die Eigenheiten der Sprachen zu
erkennen. Die Sprache C ist trotz der Verwendung des Funktionsbegriffes
keine funktionale Programmiersprache, da ihr Konzept nicht anders als in
¨
FORTRAN oder PASCAL auf der sequentiellen Ausfuhrung
von Anweisungen beruht.
¨
Programmen in logischen oder pradikativen
Sprachen wie PROLOG werden Fakten und Regeln zum Folgern mitgegeben, sie beantworten dann die
¨
Anfrage, ob eine Behauptung mit den Fakten und Regeln vertraglich
(wahr)
ist oder nicht. Viele Denksportaufgaben legen eine solche Sprache nahe. Hier
das Hello-World-Programm in PROLOG:
% HELLO WORLD.
Works with Sbp (prolog)
hello :printstring("HELLO WORLD!!!!").
printstring([]).
printstring([H|T]) :- put(H), printstring(T).
Quelle 2.3 : PROLOG-Programm Hello, World
¨
Die Umgew¨ohnung von einem Paradigma auf ein anderes geht uber
das
Erlernen einer neuen Sprache hinaus und beeinflusst die Denkweise, die
Sicht auf ein Problem.
¨
Es gibt ein zweite, von der ersten unabhangige
Einteilung, die zugleich die
historische Entwicklung spiegelt:
• maschinenorientierte Sprachen (Maschinensprache, Assembler)
• problemorientierte Sprachen (h¨ohere Sprachen)
¨
In der Fruhzeit
gab es nur die v¨ollig auf die Hardware ausgerichtete und unbequeme Maschinensprache, wir haben eine Kostprobe gesehen. Assembler
sind ein erster Schritt in Richtung auf die Probleme und die Programmierer zu. H¨ohere Sprachen wie FORTRAN sind von der Hardware schon ziemlich losgel¨ost und in diesem Fall an mathematische Probleme angepasst. Es
¨ spezielle Aufgaben wie Stringverarbeitung, Datenbankabfragen,
gibt aber fur
Statistik oder Grafik Sprachen, die in ihrer Anpassung noch weiter gehen.
Auch die zur Formatierung des vorliegenden Textes benutzte Sammlung von
¨ die
LaTeX-Makros stellt eine problemangepasste Sprache dar. Der Preis fur
26
2 Programmieren in C/C++
Erleichterungen ist ein Verlust an Allgemeinheit. Denken Sie an die Noten¨ andere Gebiete
sprache der Musik: an ihre Aufgabe gut angepasst, aber fur
wie etwa die Chemie ungeeignet.
2.1.4
Imperative Programmiersprachen
¨ den MenDer Computer kennt nur Bits, das heißt Nullen und Einsen. Fur
¨ sind die Zeiten, als
schen ist diese Ausdrucksweise unangebracht. Zum Gluck
man die Bits einzeln von Hand in die Lochstreifen schlug, vorbei.
¨
Die nachste
Stufe war die Zusammenfassung mehrerer Bits zu Gruppen,
die man mit Buchstaben und Ziffern bezeichnen konnte. Ein Ausschnitt eines
¨ die ZUSE Z 22 im Freiburger Code aus den funfziger
¨
Programmes fur
Jahren:
B15
U6
B18
+
B13
X
CGKU30+1
0
Bringe den Inhalt von Register 15 in den Akku
Kopiere den Akku nach Register 6
Bringe den Inhalt von Register 18 in den Akku
Addiere Akku und Reg. 6, Summe in Akku und 6
Bringe den Inhalt von Register 13 in den Akku
Multipliziere Akku mit Register 6
Kopiere den Akku nach der Adresse, die in
Register 30 steht; inkrementiere Register 30
leere Operation
¨ die ZUSE Z 22
Quelle 2.4 : Ausschnitt aus einem Programm fur
¨
Man musste dem Computer in aller Ausfuhrlichkeit
sagen, was er zu tun
¨
hatte. Das war auch muhsam,
aber diese Art der Programmierung gibt es
heute noch unter dem Namen Assemblerprogrammierung. Man braucht
sie, wenn man die Hardware fest im Griff haben will, also an den Grenzen
¨
Software - Hardware (Treiberprogramme). Daruber
hinaus sind gute Assemblerprogramme schnell, weil sie nichts Unn¨otiges tun. Programmieren in As¨ PCs gibt es von
sembler setzt vertiefte Kenntnisse der Hardware voraus. Fur
Microsoft eine Kombination von Quick C mit Assembler, die es gestattet, das
große Programm in der h¨oheren Sprache C und einzelne kritische Teile in Assembler zu programmieren. Wer unbedingt den herben Reiz der Assemblerprogrammierung kennenlernen will, hat es mit dieser Kombination einfach.
Die meisten Programmierer wollen jedoch nicht Speicherinhalte verschie¨
ben, sondern Gleichungen l¨osen oder W¨orter suchen3 . Schon Mitte der funfziger Jahre entstand daher bei der Firma IBM die erste h¨ohere Programmiersprache, und zwar zum Bearbeiten mathematischer Aufgaben. Die Sprache war daher stark an die Ausdrucksweise der Mathematik angelehnt und
¨ die mathematisch gebildete Welt einigermaßen bequem. Sie
zumindest fur
¨
wurde als formula translator, abgekurzt
FORTRAN bezeichnet. FORTRAN
wurde im Laufe der Jahrzehnte weiter entwickelt – zur Zeit ist FORTRAN
3 Recht
betrachtet, will man auch keine Gleichungen, sondern Aufgaben wie die
Dimensionierung eines Maschinenteils oder das Zusammenstellen eines Sachregisters l¨osen.
2.1 Grundbegriffe
27
90 bzw. 95 aktuell – und ist auch heute noch die in der Technik am weitesten verbreitete Programmiersprache. Kein Ingenieur kommt an FORTRAN
vorbei. Ein Beispiel findet sich in Abschnitt 2.4.3 Parameterubergabe
¨
auf Seite 124.
¨ aber große
Die Kaufleute hatten mit Mathematik weniger am Hut, dafur
¨
Datenmengen. Sie erfanden Ende der funfziger
Jahre ihre eigene Programmiersprache COBOL, das heißt Common Business Oriented Language. Dass
Leutnant G RACE M. H OPPER (eine Frau, zuletzt im Admiralsrang) sowohl
den ersten Bug erlegt wie auch COBOL erfunden habe, ist eine Legende um
¨
ein K¨ornchen Wahrheit herum. COBOL ist ebenfalls unverwustlich
und gilt
heute noch als die am weitesten verbreitete Programmiersprache. Kein Wirtschaftswissenschaftler kommt an COBOL vorbei. Ein COBOL-Programm
liest sich wie gebrochenes Englisch:
000100 IDENTIFICATION DIVISION.
000200 PROGRAM-ID.
HELLOWORLD.
000300 DATE-WRITTEN.
02/05/96
21:04.
000400*
AUTHOR
BRIAN COLLINS
000500 ENVIRONMENT DIVISION.
000600 CONFIGURATION SECTION.
000700 SOURCE-COMPUTER. RM-COBOL.
000800 OBJECT-COMPUTER. RM-COBOL.
000900
001000 DATA DIVISION.
001100 FILE SECTION.
001200
100000 PROCEDURE DIVISION.
100100
100200 MAIN-LOGIC SECTION.
100300 BEGIN.
100400
DISPLAY " " LINE 1 POSITION 1 ERASE EOS.
100500
DISPLAY "HELLO, WORLD." LINE 15 POSITION 10.
100600
STOP RUN.
100700 MAIN-LOGIC-EXIT.
100800
EXIT.
Quelle 2.5 : COBOL-Programm Hello, World
Als die Computer in die Reichweite gew¨ohnlicher Studenten kamen,
¨
¨ das
entstand das Bedurfnis
nach einer einfachen Programmiersprache fur
Gr¨obste, kurzum nach einem Beginners’ All Purpose Symbolic Instruction
Code. J OHN K EMENY und T HOMAS K URTZ vom Dartmouth College in den
¨
USA erfullten
1964 mit BASIC diesen Bedarf. Der Gebrauch von BASIC
4
¨
gilt in ernsthaften Programmiererkreisen als anruchig
. Richtig ist, dass es
¨
¨
unzahlige,
miteinander unvertragliche
BASIC-Dialekte gibt, dass BASIC die
Unterschiede zwischen Betriebssystem und Programmiersprache verwischt
und dass die meisten BASIC-Dialekte keine ordentliche Programmstruktur
¨ kurze Programme brauchbar sind. Richtig ist
erm¨oglichen und daher nur fur
4 No
programmers write in BASIC, after the age of 12.
28
2 Programmieren in C/C++
aber auch, dass moderne BASIC-Dialekte wie HP-BASIC oder QuickBASIC
¨
¨
von Microsoft uber
alle Hilfsmittel zur Strukturierung verfugen
und dass in
¨
keiner anderen gangigen
Programmiersprache die Bearbeitung von Strings
so einfach ist wie in BASIC5 . In der Messwerterfassung ist es beliebt. Fa¨ einen Programmierer
zit: die Kenntnis von GW-BASIC auf dem PC reicht fur
¨ viele Aufgaben ist ein modernes BASIC ein brauchbares
nicht aus, aber fur
Werkzeug.
Anfang der sechziger Jahre wurde ALGOL 60 aufgrund theoretischer
¨
¨
Uberlegungen entwickelt und nach einer umfangreichen Uberarbeitung
als
ALGOL 68 ver¨offentlicht. Diese Programmiersprache ist nie in großem Umfang angewendet worden, spielte aber eine bedeutende Rolle als Wegbereiter
¨ die heutigen Programmiersprachen beziehungsweise die heutigen Fassunfur
¨
¨
gen alterer
Sprachen. Viele Konzepte gehen auf ALGOL zuruck.
Ende der sechziger Jahre hatte sich das Programmieren vom Kunsthand¨
werk zur Wissenschaft entwickelt, und N IKLAUS W IRTH von der ETH Zurich
¨
brachte PASCAL heraus, um seinen Studenten einen anstandigen
Programmierstil anzugew¨ohnen. PASCAL ist eine strenge und logisch aufgebaute
Sprache, daher gut zum Lernen geeignet. Turbo-PASCAL von Borland ist auf
PCs weit verbreitet. Ein PASCAL-Beispiel findet sich in Abschnitt 2.4.3 Parameterubergabe
¨
auf Seite 124. Eine Weiterentwicklung von PASCAL ist MODULA.
Die Sprache C wurde von B RIAN K ERNIGHAN, D ENNIS R ITCHIE und K EN
T HOMPSON in den siebziger Jahren entwickelt, um das Betriebssystem UNIX damit portabel zu gestalten. Lange Zeit hindurch gab das Buch der beiden
Erstgenannten den Standard vor6 . In den Achtzigern hat das American Na¨ C gearbeitet, dem
tional Standards Institute (ANSI) an einem Standard fur
alle neueren Compiler folgen (hinterherhinken). Das ANSI-Dokument wurde
als Internationaler Standard ANSI/ISO/IEC 9899:1990 anerkannt. Ende der
¨
neunziger Jahre wurde eine erneute Uberarbeitung
als Internationaler Stan7
dard ANSI/ISO/IEC 9899:1999 ver¨offentlicht, der auch als C9X bezeichnet
¨
wird. Den Stand der Dinge erfahrt
man bei:
http://anubis.dkuug.dk/JTC1/SC22/WG14/
¨ dauert es einige Jahre, bis die Compiler einen neuen StanErfahrungsgemaß
¨
dard voll unterstutzen.
5 1964
bot keine andere Programmiersprache nennenswerte M¨oglichkeiten zur
Verarbeitung von Strings.
6 Das vergleichsweise schlanke Buch von K&R ist die erste Lekture,
¨
sobald man
¨
einfache C-Programme schreiben kann. Uber
die Beschreibung von C hinaus birgt es
wertvolle allgemeine Hinweise zum Programmieren. Anmerkungen hat S TEVE S UM MIT unter http://www.eskimo.com/˜
scs/cclass/knotes/top.html ver¨offenlicht.
7 Den Standard kann man sich bei www.ansi.org gegen 18 US-Dollar im pdfFormat herunterladen, rund 500 Seiten. Auf der Titelseite steht Printed in the United
¨
States of America, auf dem Rucktitel
Printed in Switzerland. Die Wahrheit in meinem
Fall: Printed in Karlsruhe. Hoffentlich geht das nicht so weiter.
2.1 Grundbegriffe
29
¨
Das ANSI-C von 1990 ist im wesentlichen eine Ubermenge
von K&R-C;
¨
¨
die Nachfuhrung
der Programme – wenn uberhaupt
erforderlich – macht kei¨
ne Schwierigkeiten. ANSI-C kennt ein Schlusselwort
von K&R nicht mehr
¨ mehrere neue.
(entry) und dafur
¨
C ist allgemein verwendbar, konzentriert, lasst
dem Programmierer große
Freiheiten (having the best parts of FORTRAN and assembly language in
¨
one place) und fuhrt
in der Regel zu schnellen Programmen, da vielen
C-Anweisungen unmittelbar Assembler-Anweisungen entsprechen (Maschi¨
¨
nennahe).
Die Sprache hat einen kleinen Kern (wenige Schlusselw¨
orter), Er¨
weiterungen und Hardwareabhangigkeiten
stecken in den Bibliotheken. C¨
Programme gelten als unubersichtlich,
aber das ist eine Frage des Program8
mierstils, nicht der Sprache . Auf UNIX-Systemen hat man mit C die we¨ DOS-PCs gibt es von Microsoft das preiswerte
nigsten Schwierigkeiten. Fur
Quick-C und aus dem GNU-Projekt einen kostenlosen C-Compiler im Quellcode und betriebsklar kompiliert.
Aus C hat B JARNE S TROUSTRUP von 1979 bis 1989 eine Sprache C++
¨
entwickelt, die ebenfalls eine Ubermenge
von C bildet. Der Denkansatz (Paradigma) beim Programmieren in C++ weicht jedoch erheblich von C ab, so
¨
¨
dass man eine langere
Lernphase einplanen muss, mehr als bei einem Ubergang von PASCAL nach C. Da sich ANSI-C und C++ gleichzeitig entwickelt
haben, sind einige Neuerungen von C++ in ANSI-C eingeflossen, zum Beispiel das Prototyping. Ein ANSI-C-Programm sollte von jedem C++-Compiler
verstanden werden; das Umgekehrte gilt nicht. Aktuell ist der Standard ANSI/ISO/IEC 14882:1998.
2.1.5
Objektorientierte Programmiersprachen
¨
In dem Maß, wie die Hardware leistungsfahiger
wurde, wagten sich die Programmierer an komplexere und umfangreichere Aufgaben heran. Dass große
¨
Aufgaben in kleinere Teilaufgaben untergliedert werden mussen,
ist eine
¨
¨
alltagliche
Erfahrung und nicht auf Programme beschrankt.
Die Strukturierung einer Aufgabe samt ihrer L¨osung gewann an Bedeutung. Programmiersprachen wie C, die die Strukturierung eines Programms in Module (Funktionen, Prozeduren, Subroutinen) erleichtern, verbreiteten sich.
¨ wieder so angewachsen, dass nach
Um 1980 herum war die Komplexitat
¨
neuen Wegen zu ihrer Bewaltigung
gesucht wurde. Außerdem hatte die
¨
Software als Kostenfaktor die Hardware uberholt.
Es galt, umfangreiche
Programme schnell und preiswert herzustellen und dabei noch deren Zu¨
¨
verlassigkeit
sicherzustellen, ahnlich
wie heutzutage Autos produziert werden. Zwei Schlagw¨orter kamen auf: Objektorientierung und Software En¨
gineering. Entkleidet man sie der merkantilen Ubertreibungen,
bleibt im¨
mer noch ein brauchbarer Kern von Ideen ubrig.
8
Es gibt einen International Obfuscated C Code Contest, einen Wettbewerb um
¨
das unubersichtlichste
C-Programm, siehe Abschnitt 2.12 Obfuscated C auf Seite
249.
30
2 Programmieren in C/C++
¨ VariaDer Typbegriff wurde zur Klasse erweitert. Eine Klasse enthalt
ble und zugeh¨orige Funktionen, die nun Methoden genannt werden. Klassen
k¨onnen im Gegensatz zum Typ vom Programmierer definiert werden. Sie bilden eine Hierarchie, wobei h¨ohere Klassen Eigenschaften an niedrigere vererben. Klassen haben eine genau definierte Schnittstelle (Interface) zum Rest
des Programms, ihr Innenleben bleibt verborgen. Was sie tun, ist bekannt,
wie sie es tun, geht niemanden etwas an. Diese scharfe Trennung von Innen
¨ den Klassenbegriff. Was fur
¨ C Funktionsbibliound Außen ist wesentlich fur
¨
theken sind, das sind fur C++ Klassenbibliotheken. Die Programmierarbeit
besteht zu einem großen Teil im Schreiben von Klassen. Wie eine Variable
die Verwirklichung (Realisierung, Instantiierung) eines Typs ist, so ist ein
Objekt eine Instanz einer Klasse. Von einer Klasse k¨onnen beliebig viele Objekte abgeleitet werden. Klassen und deren Objekte sind die Bausteine eines
objektorientierten Programms. C++ hieß anfangs C mit Klassen.
Neben C++ ist eine zweite objektorientierte Erweiterung von C entstanden, die unter dem Namen Objective C in Verbindung mit dem Betriebssystem NeXT eine gewisse Verbreitung gefunden hat. Der GNU-C-Compiler
¨
unterstutzt
sowohl C++ wie Objective C, ansonsten ist es ziemlich still geworden um diese Sprache.
Es kommen noch ein paar Dinge hinzu, um das Programmieren zu erleichtern, aber das Wesentliche am objektorientierten Programmieren ist, dass die
Aufgabe nicht mehr in Module zerlegt wird, die aus Anweisungen bestehen,
¨
sondern in voneinander unabhangige
Objekte, die sich Mitteilungen oder Botschaften schicken. Die Objektorientierung setzt bei der Aufgabenanalyse ein,
nicht erst bei der Umsetzung in eine Programmiersprache (Codierung).
¨ sich C++ zu C? Manche sagen, dass C++ eine neue, von C v¨ollig
Wie verhalt
¨
unabhangige
Sprache sei. Andere wiederum betrachten C++ als eine umfangreiche Erweiterung von C. Auf jeden Fall sind die Kenntnisse, die man beim
¨
¨
Lernen von C erworben hat, auch in C++ nutzlich
und keinesfalls uberholt.
¨
C++-Compiler ubersetzen
die meisten C-Programme anstandslos. Zu feineren
¨
Unterschieden und Unvertraglichkeiten
siehe D AVID. R. T RIBBLE:
http://david.tribble.com/text/cdiffs.htm
¨ numerische Aufgaben ist C++ in der Universitat
¨ Karlsruhe um eine
Fur
Klassenbibliothek namens C-XSC (Extended Scientific Calculation) mit Datentypen wie komplexen Zahlen, Vektoren, Matrizen und Intervallen samt
¨
den zugeh¨origen Operationen erganzt
worden, siehe das Buch von R UDI
K LATTE et al.
SMALLTALK ist eine von Grund auf neu entwickelte, streng objektorientierte Sprache9 , im Gegensatz zu C++. JAVA wurde von der Firma SUN
entwickelt. Hier das Hello-World-Programm in JAVA (in C++ lernen wir es in
Abschnitt 2.66 auf Seite 169 kennen):
9 SMALLTALK
¨ LINUX verfugbar.
¨
ist ungewohnt und sehr interessant, auch fur
¨
Naheres
siehe www.software.ibm.com/ad/smalltalk/, www.exept.de/,
www.cetus-links.org/oo smalltalk.html oder www.gsug.org/.
2.1 Grundbegriffe
31
class HelloWorld {
public static void main (String args[]) {
for (;;) {
System.out.print("Hello World ");
}
}
}
Quelle 2.6 : JAVA-Programm Hello, World
¨
Ahnlichkeiten
zu C sind erkennbar, die JAVA-Entwickler waren vermutlich C-Programmierer.
¨
¨
Auf die ubrigen
989 Programmiersprachen10 soll aus Platzgrunden
nicht
¨
eingegangen werden. Braucht man uberhaupt
mehrere Sprachen? Einige
Sprachen wie FORTRAN und COBOL sind historisch bedingt und werden
wegen ihrer weiten Verbreitung noch lange leben. Andere Sprachen wie BASIC und C wenden sich an unterschiedliche Benutzerkreise. Wiederum an¨ spezielle Aufgaben besser als allgemeine Sprachen. Mit
dere eignen sich fur
einer einzigen Sprache wird man auch in der Zukunft nicht auskommen. Die
¨
Schwierigkeiten beim Programmieren liegen im ubrigen
weniger in der Umsetzung in eine Programmiersprache – der Codierung – sondern in der Formulierung und Strukturierung der Aufgabe.
¨ ein System verfugbar?
¨
Was heißt, eine Sprache sei fur
Es gibt einen In¨ diese Sprache auf diesem System (Hardware
terpreter oder Compiler fur
plus Betriebssystem). Die Bezeichnung FORTRAN-Compiler fur
¨ UNIX reicht
¨ verschiedene Hardware und zudem in verschiedenen
nicht, da es UNIX fur
¨
Versionen gibt. Drei Dinge mussen
zusammenpassen: Interpreter oder Compiler, Betriebssystem und Hardware.
2.1.6
Interpreter – Compiler – Linker
In h¨oheren Programmiersprachen wie C oder FORTRAN geschriebene Programme werden als Quellcode (source code), Quellprogramm oder Quelltext
bezeichnet. Mit diesem Quellcode kann der Computer unmittelbar nichts an¨
fangen, er ist nicht ausfuhrbar.
Der Quellcode muss mithilfe des Computers
¨
¨
und eines Ubersetzungsprogrammes
in Maschinencode ubersetzt
werden.
Mit dem Maschinencode kann dann der Programmierer nichts mehr anfangen.
¨
¨
Es gibt zwei Arten von Ubersetzern.
Interpreter ubersetzen
das Pro¨
gramm jedesmal, wenn es aufgerufen wird. Die Ubersetzung wird nicht auf
Dauer gespeichert. Da der Quellcode zeilenweise bearbeitet wird, lassen sich
¨
¨
Anderungen
schnell und einfach ausprobieren. Andererseits kostet die Uber¨
setzung Zeit. Interpreter findet man vorwiegend auf Home-Computern fur
BASIC, aber auch LISP-Programme, Shellscripts und awk-Scripts werden interpretiert.
10 Real
programmers can write FORTRAN programs in any language.
32
2 Programmieren in C/C++
¨
Compiler ubersetzen
den Quellcode eines Programms als Ganzes und
¨
¨
speichern die Ubersetzung
auf einem permanenten Medium. Zur Ausfuhrung
¨
¨
des Programms wird die Ubersetzung aufgerufen. Bei der kleinsten Ande¨ entfallt
¨
rung muss das gesamte Programm erneut kompiliert werden, dafur
¨
¨
¨
die jedesmalige Ubersetzung wahrend
der Ausfuhrung.
Compilierte Programme laufen also schneller ab als interpretierte. Es gibt auch Mischformen von
¨ JAVA. Wie wir eingangs des
Interpretern und Compilern, zum Beispiel fur
Kapitels gesehen haben, arbeiten C- und C++-Compiler wie cc(1) und CC(1)
¨
in vier Durchgangen:
¨
• Praprozessor
¨
• eigentlicher Compiler (Ubersetzung
in Assembler-Code)
¨
• Assembler (Ubersetzung
in Maschinen-Code)
• Linker
¨
¨
¨
Der Praprozessor
entfernt Kommentar und fuhrt
die PraprozessorAnweisungen (siehe Abschnitt 2.9 Praprozessor
¨
auf Seite 195) aus. Ruft man
¨ man die Ausgabe des Prapro¨
den Compiler mit der Option -P auf, so erhalt
zessors in einem lesbaren File mit der Kennung .i.
¨
Der eigentliche Compiler ccom(1) ubersetzt
den Quellcode in maschinenspezifischen, lesbaren Assemblercode. Die Compileroption -S liefert diesen
Code in einem File mit der Kennung .s. Bei einem einfachen Programm sollte
¨
man sich einmal das Vergnugen
g¨onnen und den Assemblercode anschauen.
¨
Der Assembler ist ein zweiter Ubersetzer,
der Assemblercode in Maschi¨
¨ man den Maschinensprache ubersetzt.
Mit der Compileroption -c erhalt
nencode (Objektcode, relocatable code) in einem nicht lesbaren File mit der
Kennung .o.
Große Programme werden in mehrere Files aufgeteilt, die einzeln kom¨
piliert werden, aber nicht einzeln ausfuhrbar
sind, weil erst das Programm
als Ganzes einen Sinn ergibt. Das Verbinden der einzeln kompilierten Files
¨
zu einem ausfuhrbaren
Programm besorgt der Binder oder Linker. Die Com¨
pileroption -c unterdruckt
das Linken und erzeugt ein nicht lesbares File mit
der Kennung .o.
¨
¨
Unter UNIX werden ublicherweise
Praprozessor,
Compiler, Assembler und
Linker von einem Compilertreiber aufgerufen, so dass der Benutzer nichts
von den vier Schritten bemerkt. Man arbeitet mit dem Treiber cc(1), gcc(1)
¨ ein ausfuhrbares
¨
oder CC(1) und erhalt
Programm. Im Alltag meint man den
Treiber, wenn man vom Compiler spricht.
¨
¨ die Maschine, auf
Ublicherweise
erzeugt ein Compiler Maschinencode fur
¨
¨
der er selbst lauft.
Cross-Compiler hingegen erzeugen Maschinencode fur
¨
andere Systeme. Das ist gelegentlich nutzlich.
Der Name des Programms im C-Quellcode hat die Kennung .c, in FORTRAN und PASCAL entsprechend .f und .p. Das kompilierte, aber noch nicht
gelinkte Programm wird als Objektcode oder relozierbar (relocatable) be¨
zeichnet, der Filename hat die Kennung .o oder .obj. Das lauffahige
Pro¨
gramm heißt ausfuhrbar
(executable), sein Name hat keine Kennung. Un¨
ter PC-DOS sind die Namen ausfuhrbarer
Programme durch .com oder .exe
2.1 Grundbegriffe
33
gekennzeichnet. Ein kompiliertes Programm wird auch Binary genannt, im
¨
Gegensatz zum Quelltext. Ein Programm ist binar-kompatibel
zu einem
¨
¨
anderen System, wenn es in seiner ausfuhrbaren
Form unter beiden lauft.
Hat sich ein Programm anstandslos kompilieren lassen und erzeugt beim
Aufruf die Fehlermeldung File not found, dann liegt das fast immer daran, dass das Arbeitsverzeichnis nicht im Befehlspfad enthalten ist. Man ruft
dann das neue Programm mit einem Punkt als Pfadangabe auf:
./myprogram
und veranlasst so die Shell, das Programm im Arbeitsverzeichnis zu suchen.
Alternativ k¨onnte man auch den Punkt in den Pfad aufnehmen.
¨
Bei den Operanden spielt es eine Rolle, ob ihre Eigenschaften vom Uber¨
setzer bestimmt werden oder von Programm und Ubersetzer
gemeinsam –
¨
¨
¨
zur Ubersetzungszeit – oder wahrend
der Ausfuhrung
des Programmes – zur
Laufzeit. Der zweite Weg wird als statische Bindung bezeichnet, der dritte
als dynamische Bindung. Die Gr¨oße einer Ganzzahl (2 Bytes, 4 Bytes) ist
durch den Compiler gegeben. Die Gr¨oße eines Arrays k¨onnte im Programm
¨
¨
festgelegt sein oder wahrend
der Ausfuhrung
berechnet werden. Es ist auch
denkbar, aber in C nicht zugelassen, den Typ einer Variablen erst bei der
¨
Ausfuhrung
je nach Bedarf zu bestimmen.
¨
¨
Einen Weg zuruck
vom ausfuhrbaren
Programm zum Quellcode gibt es
¨
¨
nicht. Das Außerste ist, mit einem Disassembler aus dem ausfuhrbaren
Code Assemblercode zu erzeugen, ohne Kommentar und typografische Struktur.
¨
Nur bei kurzen, einfachen Programmen ist dieser Assemblercode verstandlich.
2.1.7
¨ und Stil
Qualitat
Unser Ziel ist ein gutes Programm. Was heißt das im einzelnen? Ein Pro¨
gramm soll selbstverstandlich
fehlerfrei sein in dem Sinn, dass es aus
¨
¨
zulassigen
Eingaben richtige Ergebnisse erzeugt. Außer in seltenen Fallen
¨
lasst
sich die so definierte Fehlerfreiheit eines Programms nicht beweisen.
¨
Man kann nur – nach einer Vielzahl von Tests und langerem
Gebrauch – da¨
von reden, dass ein Programm zuverlassig
ist, ein falsches Ergebnis also nur
mit geringer Wahrscheinlichkeit auftritt.
Ein Programm soll robust sein, das heißt auf Fehler der Eingabe oder der
¨
Peripherie vernunftig
reagieren, nicht mit einem Absturz. Das Schlimmste
ist, wenn ein Programm trotz eines Fehlers ein scheinbar richtiges Ergebnis
ausgibt. Die Fehlerbehandlung macht oft den gr¨oßeren Teil eines Program¨
¨
mes aus und wird haufig
vernachlassigt.
Die Sprache C erleichtert diese Aufgabe.
¨
Ein Programm ist niemals fertig und soll daher leicht zu andern
sein.
¨
¨
Die Entdeckung von Fehlern, die Berucksichtigung
neuer Wunsche,
die
Entwicklung der Hardware, Bestrebungen zur Standardisierung und Lern¨
¨
vorgange
der Programmierer fuhren
dazu, dass Programme immer wieder
¨
uberarbeitet
werden. Kleinere Korrekturen werden durch Patches behoben,
34
2 Programmieren in C/C++
¨
w¨ortlich Flicken. Das sind Erganzungen
zum Code, die nicht gleich eine neue
¨
¨ manche Fehler lassen sich auch ohne Anderung
Version rechtfertigen. Fur
des
Codes Umgehungen finden, sogenannte Workarounds. Nach umfangreichen
¨
Anderungen
– m¨oglichst Verbesserungen – erscheint eine neue Version des
¨
¨
Programmes. Ein Programm, von dem nicht einmal jahrlich
eine Uberarbei¨
tung erscheint, ist tot. Jede Woche eine neue Version ist naturlich
auch kei¨
¨
¨
ne Empfehlung. Leichte Anderbarkeit
beruht auf Ubersichtlichkeit,
ausfuhr¨
licher Dokumentation und Vermeidung von Hardwareabhangigkeiten.
Die
¨
¨
Ubersichtlichkeit wiederum erreicht man durch eine zweckmaßige Struktu¨
rierung, verstandliche
Namenswahl und Verzicht auf besondere Tricks einer
Programmiersprache, die zwar erlaubt, aber nicht allgemein bekannt sind.
¨
¨
Gerade C erlaubt viel, was nicht zur Ubersichtlichkeit
beitragt.
¨
¨
Anderungen zu erleichtern kann auch heißen, Anderungen von vornherein zu vermeiden, indem man die Programmteile so allgemein wie mit dem
Aufwand vereinbar gestaltet.
¨
Effizienz ist immer gefragt. Fruher
bedeutete das vor allem sparsamer
Umgang mit dem Arbeitsspeicher. Das ist heute immer noch eine Tugend,
¨
tritt aber hinter den vorgenannten Kriterien zuruck.
Die moderne Software
¨
scheint zur Unterstutzung
der Chiphersteller geschrieben zu werden. An
¨
zweiter Stelle kam Ausfuhrungsgeschwindigkeit,
trotz aller Geschwindigkeitssteigerungen der Hardware ebenfalls noch eine Tugend, wenn sie mit
¨
Einfachheit und Ubersichtlichkeit
einhergeht. Mit anderen Worten: erst ein
¨
ubersichtliches
Programm schreiben und dann nachdenken, ob man Speicher
und Zeit einsparen kann.
Ein Programm soll benutzerfreundlich sein. Der Benutzer am Terminal
¨
¨
will bei alltaglichen
Aufgaben ohne das Studium pfundschwerer Handbucher
¨
auskommen und bei den haufigsten
Fehlern Hilfe vom Bildschirm erhalten.
¨
¨
Er will andererseits auch nicht mit uberfl
ussigen
Informationen und nutzlo¨
sen Spielereien belastigt
werden. Der Schwerpunkt der Programmentwicklung liegt heute weniger bei den Algorithmen, sondern bei der Interaktion
¨ einen Programmierer ist es nicht immer einfach, sich
mit dem Benutzer. Fur
in die Rolle eines EDV-Laien zu versetzen.
¨ den
Schließlich ist daran zu denken, dass man ein Programm nicht nur fur
¨ andere Programmierer. Erstens kommt
Computer schreibt, sondern auch fur
¨
es oft vor, dass ein Programm von anderen weiterentwickelt oder erganzt
wird; zweitens ist ein Programm eine von mehreren M¨oglichkeiten, einen Algorithmus oder einen komplexen Zusammenhang darzustellen. Der Quellcode sollte daher leicht zu lesen, programmiererfreundlich sein. Fordern wir
also menschenfreundliche Programme.
¨
C lasst
dem Programmierer viel Freiheit, mehr als PASCAL. Damit nun
nicht jeder schreibt, wie ihm der Schnabel gewachsen ist, hat die Program¨
mierergemeinschaft Regeln und Gebrauche
entwickelt. Ein Verstoß dagegen
¨
beeindruckt den Compiler nicht, aber das Programm ist muhsam
zu lesen.
Der Beautifier cb(1) automatisiert die Einhaltung einiger dieser Regeln,
weitergehende finden sich in:
• N ELSON F ORD, Programmer’s Guide, siehe Anhang,
2.1 Grundbegriffe
35
• B. W. K ERNIGHAN, P. J. P LAUGER, Software Tools, siehe Anhang,
• R OB P IKE, Notes on Programming in C, /pub/../pikestyle.ps auf
ftp.ciw.uni-karlsruhe.de
• Firmen-Richtlinien wie Nixdorf Computer C-Programmierrichtlinien
(Hausstandard), 1985
• K. H ENNING, Portables Programmieren in C – Programmierrichtlinien,
verfasst 1993 vom Hochschuldidaktischen Zentrum und vom Fachgebiet
Kybernetische Verfahren und Didaktik der Ingenieurwissenschaften der
RWTH Aachen im Auftrag von sechs Chemiefirmen. Der Verbreitung
dieser Richtlinien stehen leider ein Hinweis auf das Urheberrecht sowie
¨
ein ausdruckliches
Kopierverbot entgegen.
¨
Ein- und dieselbe Aufgabe kann – von einfachen Fallen
abgesehen – auf
verschiedene Weisen gel¨ost werden. Der eine bevorzugt viele kleine Pro¨ ein
grammbl¨ocke, der andere wenige große. Einer arbeitet gern mit Menus,
anderer lieber mit Kommandozeilen. Einer schreibt einen langen Kommentar
an den Programmanfang, ein anderer zieht kurze, in den Programmcode eingestreute Kommentare vor. Solange die genannten objektiven Ziele erreicht
werden, ist gegen einen pers¨onlichen Stil nichts einzuwenden. Le style c’est
l’homme.
2.1.8
Programmiertechnik
¨
Bei kurzen Programmen, wie sie in diesem Buch uberwiegen,
setzt man
sich oft gleich an das Terminal und legt los. Besonders jugendliche BASICProgrammierer neigen zu dieser Programmiertechnik. Wenn man sich das
nicht schnellstens abgew¨ohnt, kommt man nicht weit. Um wirkliche Programme zu schreiben, muss man systematisch vorgehen und viel Konzeptpapier
verbrauchen, ehe es ans Hacken geht. Es gibt mehrere Vorgehensweisen. Ei¨ Stufen vor (waterfall approach):
ne verbreitete sieht funf
• Aufgabenstellung (Vorstudien, Analyse, Formulierung),
• Entwurf (Struktur, Anpassen an Werkzeuge wie make(1), RCS, CVS),
• Umsetzung in eine Programmiersprache (Codierung, Implementation),
¨
• Test (Fehlersuche, Prufungen,
Messungen, Vergleich mit Punkt 1),
• Betrieb und Pflege (Wartung, Updating, Fehler-Management).
¨ den Anfanger
¨
Die Programmiersprache, die fur
im Vordergrund des Programmierens steht, kommt erst an dritter Stelle. Wenn die beiden vorangehenden
Punkte schlecht erledigt worden sind, kann auch ein Meister in C/C++ nichts
mehr retten.
¨
Der Zeitbedarf der einzelnen Stufen ist schwierig abzuschatzen,
da Klei¨
nigkeiten manchmal furchterlich
aufhalten. Lassen wir Betrieb und Pflege
als zeitlich unbegrenzt heraus, und nehmen wir an, dass das Schreiben der
¨ folgende Anteile als
Dokumentation parallel erfolgt, so lassen sich ungefahr
¨ eine Zeitplanung nehmen:
Ausgangswerte fur
36
2 Programmieren in C/C++
• Aufgabenanalyse 20 %,
• Entwurf 30 %,
• Codierung 20 %,
• Test 30 %.
Wer Softwareprojekte zu seinem Broterwerb macht, sollte ein Tagebuch oder
¨
Protokoll fuhren,
um Erfahrungen auf dem Papier festzuhalten und sie beim
¨
nachsten
Projekt zu verwerten.
Bei der Codierung rechnet man mit 60 Zeilen Programmcode (ohne Kommentar und Leerzeilen) pro Tag und Programmierer. Das sind zwei bis drei
Seiten DIN A4 mit Kommentar und Leerzeilen. Gleichzeitig ist das die Ober¨ ein Programmmodul (in C eine Funktion). Haben Sie fur
¨ ihr Progrenze fur
jekt 100 Arbeitstage Zeit und einen Programmierer, so ergeben sich 20 Ar¨ die Codierung gleich 20 Modulen zu je 60 Zeilen Code. Das sind
beitstage ur
¨ eine erste Abschatzung
¨
grobe Werte, aber sie reichen fur
aus.
Bei Texten kann man von einer Seite pro Tag ausgehen. Liegt das Rohmaterial samt allen Abbildungen fertig vor, kommt man auch auf zehn Seiten pro Tag. Umgekehrt k¨onnen schwierige Rechnungen oder das Beschaffen
exotischer Literatur ein Manuskript beliebig verz¨ogern. Korrekturlesen, das
¨
Zusammenstellen eines Index und ahnliche
ungeliebte Arbeiten kosten auch
¨
Zeit, unter Umstanden
Wochen.
Die Programmentwicklung vollzieht sich in der Praxis nicht so geradlinig,
¨
¨
¨
wie es der obige Plan vermuten lasst.
Aus jeder Stufe kommen Ruckspr
unge
¨
in vorangegangene Stufen vor, man k¨onnte auch von Ruckkoppelungen
sprechen. Dagegen ist nichts einzuwenden, es besteht jedoch eine Gefahr. Wenn
man nicht Zwangsmaßnahmen ergreift – Schlussstriche zieht – erreicht das
Programmierprojekt nie einen definierten Zustand. Programmierer verstehen
¨ Buchmanuskripte.
das, Kaufleute und Kunden nicht. Gilt auch fur
¨ verDer steigende Bedarf an Software und ihre wachsende Komplexitat
langen die Entwicklung von Programmierverfahren, mit denen durchschnitt¨
liche Programmierer zuverlassige
Programme entwickeln. Auf geniale Real
Programmers allein kann sich keine Firma verlassen. Die Entwicklung dieser
Programmiertechnik (Software Engineering) ist noch nicht abgeschlossen.
2.1.9
Aufgabenanalyse und Entwurf
2.1.9.1
Aufgabenstellung
Die meisten Programmieraufgaben werden verbal gestellt, nicht in Form einer mathematischen Gleichung. Zudem sind sie anfangs oft pauschal abgefasst, da dem Aufgabensteller11 Einzelheiten noch nicht klar sind.
Auf der anderen Seite ben¨otigt der Computer eine eindeutige, ins einzelne
gehende Anweisung, da er – anders als ein Mensch – fehlende Informationen nicht aufgrund seiner Erfahrung und des gesunden Menschenverstandes
¨
erganzt.
11 Real
programmers know better than the users what they need.
2.1 Grundbegriffe
37
Der erste Schritt bei der Programmentwicklung ist daher die Formulierung der Aufgabe. Zu diesem Schritt kehrt man im Verlauf des Programmie¨
¨
rens immer wieder zuruck,
um zu erganzen
oder zu berichtigen. Es ist reali¨ die Aufgabenanalyse rund ein Drittel des gesamten Zeitaufwandes
stisch, fur
anzusetzen. Die Aufgabe wird in einem Pflichtenheft schriftlich festgehal¨
ten, das zur Verstandigung
zwischen Entwickler und Anwender sowie der
Entwickler untereinander dient. Fragen in diesem Zusammenhang sind:
• Welche Ergebnisse soll das Programm liefern?
• Welche Eingaben sind erforderlich?
¨
¨
• Welche Ausnahmefalle
(Fehler) sind zu berucksichtigen?
• In welcher Form sollen die Ergebnisse ausgegeben werden?
• Wer soll mit dem Programm umgehen?
• Auf welchen Computern soll das Programm laufen?
¨
Anfanger
sehen die Schwierigkeiten des Programmierens in der Umsetzung
des L¨osungsweges in eine Programmiersprache, in der Codierung. Nach eini¨
gem Uben
stellt sich dann heraus, dass die dauerhaften Schwierigkeiten in
der Formulierung und Analyse der Aufgabe, allenfalls noch im Suchen nach
¨
L¨osungen liegen, wahrend
die Codierung gr¨oßtenteils Routine wird.
¨
Nach unserer Erfahrung sollte man eine Aufgabe zunachst
einmal so for¨
mulieren, wie sie den augenblicklichen Bedurfnissen
entspricht. Dann sollte
man sich mit viel Phantasie ausmalen, was alles noch dazu kommen k¨onn¨
te, wenn Geld, Zeit und Verstand keine Schranken setzen wurden
(I have a
dream ... ). Drittens streiche man von diesem Traum gnadenlos alles weg,
was nicht unbedingt erforderlich und absolut minimal notwendig ist – ohne
das vielleicht nur asymptotisch erreichbare Ziel aus den Augen zu verlieren.
¨
So kommt man mit beschrankten
Mitteln zu Software, die sich entwickeln
¨ reif ist. Anpassungsfahigkeit
¨
¨ Software und
kann, wenn die Zeit dafur
ist fur
Lebewesen wichtiger als H¨ochstleistungen.
2.1.9.2
Zerlegen in Teilaufgaben
Controlling complexity is the essence of computer programming (B. W. K ER NIGHAN, P. J. P LAUGER , Software Tools). Komplexe Aufgaben werden in
¨
mehreren Stufen in Teilaufgaben zerlegt, die uberschaubar
sind und sich
durch eine Funktion oder Prozedur im Programm l¨osen lassen. Insofern
¨
spiegelt die Zerlegung bereits die spatere
Programmstruktur12 wider. Das
Hauptprogramm soll m¨oglichst wenig selbst erledigen, sondern nur Aufrufe
von Unterprogrammen enthalten und somit die große Struktur widerspie¨
geln. Oft ist folgende Gliederung ein zweckmaßiger
Ausgangspunkt:
• Programmstart (Initialisierungen)
• Eingabe, Dialog
12 Real
programmers disdain structured programming.
38
2 Programmieren in C/C++
• Rechnung
• Ausgabe
• Hilfen
• Fehlerbehandlung
¨
• Programmende, Aufraumen
¨
Bei den Teilaufgaben ist zu fragen, ob sie sich – ohne die Komplexitat
¨
wesentlich zu erh¨ohen – allgemeiner formulieren lassen. Damit lasst
sich
die Verwendbarkeit von Programmteilen verbessern. Diese Strategie wird als
Top-down-Entwurf bezeichnet. Man geht vom Allgemeinen ins Einzelne.
2.1.9.3
Zusammensetzen aus Teilaufgaben
Der umgekehrte Weg – Bottom-up-Entwurf – liegt nicht so nahe. Es gibt
wiederkehrende Grund-Operationen wie Suchen, Sortieren, Fragen, Aus¨
geben, Interpolieren, Zeichnen eines Kreisbogens. Aus diesen lasst
sich eine
gegebene Aufgabe zu einem großen Teil zusammensetzen, so dass nur wenige
¨
spezielle Teilaufgaben ubrig
bleiben. Hat man die Grundoperationen einmal
programmiert, so vereinfacht sich der Rest erheblich.
¨
In praxi wendet man eine gemischte Strategie an. Man zerlegt die ubergeordnete Aufgabe in Teilaufgaben, versucht diese in Grundoperationen auszu¨
drucken
und kommt dann wieder aufsteigend zu einer genaueren und allge¨
meiner gultigen
Formulierung. Dieser Ab- und Aufstieg kann sich mehrmals
¨
wiederholen. Die Aufgabenstellung ist nicht unveranderlich.
Genau so geht
man bei der Planung von Industrieanlagen vor.
Man darf nicht den Fehler machen, die Aufgabe aus Bequemlichkeit den
Eigenheiten eines Computers oder einer Programmiersprache anzupassen.
¨
Der Benutzer hat Anspruch auf ein gut und verstandlich
funktionierendes
¨ alle m¨ogliProgramm. Die Zeiten, als der Computer als Entschuldigung fur
¨
chen Unzulanglichkeiten
herhalten musste, sind vorbei.
2.1.10
Prototyping
¨
In dem haufig
vorkommenden Fall, dass die Anforderungen an das Programm
¨
zu Beginn noch verschwommen sind, ist es zweckmaßig,
m¨oglichst rasch ein
¨
¨
lauffahiges
Grundgerust,
ein Skelett zu haben. Mit diesem kann man dann
spielen und Erfahrungen sammeln in einem Stadium, in dem der Programm¨
¨
code noch uberschaubar
und leicht zu andern
ist.
Bei einem solchen Prototyp sind nur die benutzernahen Funktionen
¨
halbwegs ausgebaut, die datennahen Funktionen schreiben vorlaufig
nur ihren Namen auf den Bildschirm. Von einem menugesteuerten Vokabeltrainer
¨
¨
beispielsweise schreibt man zunachst
das Menusystem und lasst
die Funk¨
tionen, die die eigentliche Arbeit erledigen, leer oder beschrankt
sie auf die
Ausgabe ihres Namens. Damit liegt die Programmstruktur – das Knochen¨ – fest. Gleichzeitig macht man sich Gedanken uber
¨
gerust
die Datenstruktur. Steht der Prototyp, nimmt man den Datenaustausch zwischen den
2.1 Grundbegriffe
39
¨
¨
Funktionen hinzu (Parameterubergabe
und -ruckgabe),
immer noch mit Bildschirmmeldungen anstelle der eigentlichen Arbeit. Funktioniert auch das wie
¨
¨ man eine Funktion nach der anderen mit Code.
gewunscht,
fullt
¨
Diese Vorgehensweise lenkt die Entwicklung zu einem m¨oglichst fruhen
¨
Zeitpunkt in die gewunschte
Richtung. Bei einem kommerziellen Auftrag bezieht sie den Auftraggeber in die Entwicklung ein und f¨ordert das gegensei¨
tige Verstandnis,
aber auch bei privaten Projekten verhindert sie, dass man
¨ /dev/null schreibt.
viel Code fur
¨ alle Programmieraufgaben das beste
Das Prototyping ist sicher nicht fur
¨ dialogintensive kleine
Modell – es gibt auch noch andere Modelle – aber fur
und mittlerer Anwendungen recht brauchbar und in C leicht zu verwirklichen.
2.1.11
Flussdiagramme
Q
Q
Q
true Q
Q false
Q Bedingung Q
Q
Q
Q
Anweisung 1
Anweisung 2
Anweisung 3
Anweisung 4
Abb. 2.1: Flussdiagramm einer if-else-Verzweigung
¨
¨
Programme werden schnell unubersichtlich.
Man hat daher schon fruh
13
¨
versucht, mit Hilfe grafischer Darstellungen den Uberblick zu behalten,
¨
aber auch diese neigen zum Wuchern. Ein grundsatzlicher
Mangel ist die Be¨
schrankung
eines Blattes Papier auf zwei Dimensionen. Es ist unm¨oglich, ein
¨
umfangreiches Programm durch eine einzige halbwegs uberschaubare
Grafik
zu beschreiben.
Flussdiagramme (flow chart), auch Blockdiagramme genannt, sollen die
¨
Ablaufe
innerhalb eines Programmes durch Sinnbilder nach DIN 66 001
¨
und Text darstellen, unabhangig
von einer Programmiersprache. Obwohl das
13 Real
programmers don’t draw flowcharts.
40
2 Programmieren in C/C++
Flussdiagramm vor dem Programmcode erstellt werden sollte, halten sich viele Programmierer nicht an diese Reihenfolge. Zum Teil ersetzt eine gute typo¨
grafische Gestaltung der Programmquelle auch ein Flussdiagramm, wahrend
das Umgekehrte nicht gilt. Ein Flussdiagramm ist nicht mit einem Syntaxdiagramm zu verwechseln, lesen Sie die beiden entsprechenden Abbildungen,
die die if-else-Verzweigung darstellen, einmal laut vor.
aa
aa
aa
then
!
!!
!
!
if Bedingung
aa
!!
!
aa
!
aa
!!
else
!
aa
!!
a!
Anweisung 1
Anweisung 2
Anweisung 4
Anweisung 3
Abb. 2.2: Nassi-Shneiderman-Diagramm einer if-else-Verzweigung
Nassi-Shneiderman-Diagramme oder Struktogramme nach I SAAC
N ASSI und B EN S HNEIDERMAN sind ein weiterer Versuch, den Programma¨
blauf grafisch darzustellen. Sie sind naher
an eine Programmiersprache an¨
gelehnt, so dass es leicht fallt,
nach dem Diagramm eine Quelle zu schreiben.
¨
Das lasst
sich teilweise sogar mit CASE-Werkzeugen in beide Richtungen automatisieren.
2.1.12
Memo Grundbegriffe
¨
• Maschinen verstehen nur Maschinensprache, die hardwareabhangig
¨ Menschen unverstandlich
¨
und fur
ist.
• Programmierer verwenden h¨ohere, an die Aufgaben angepasste Pro¨ Maschinen unverstandlich
¨
grammiersprachen, die fur
sind. Was sie
schreiben, wird Quelle (source) genannt.
¨
¨
• Ubersetzer
(Compiler, Interpreter) ubersetzen
Quelltexte h¨oherer Programmiersprachen in Maschinensprache. Der umgekehrte Weg ist praktisch nicht gangbar.
• Deklarative Sprachen beschreiben die Aufgabe, prozedurale den
L¨osungsweg.
• Innerhalb der prozeduralen Sprachen geh¨oren BASIC, FORTRAN, PASCAl, COBOL und C zum imperativen Zweig, JAVA, SMALLTALK und
C++ zum objektorientierten.
2.2 Programmer’s Workbench
41
• Die Objektorientierung ist ein Versuch, mit der wachsenden Komple¨ der Programme fertig zu werden.
xitat
¨
• Die Herstellung eines Programms beginnt mit einer grundlichen
Analyse der Aufgabe. Die Umsetzung in eine Programmiersprache (Codierung) ist dann vergleichsweise harmlos.
• Ein Programm soll nicht nur die zugrundeliegende Aufgabe richtig
l¨osen, sondern auch gegen Fehler und Ausnahmen unempfindlich (robust) sein. Die Fehlerbehandlung erfordert mehr Programmzeilen als
die eigentliche Aufgabe.
¨
• Ein Programm soll einfach zu andern
sein. Dies wird durch eine gute
Struktur und reichlich Kommentar erleichtert (wenn man schon keine
¨
ausfuhrliche
Dokumentation schreibt).
• Ein Programm soll menschenfreundlich sein.
2.1.13
¨
Ubung
Grundbegriffe
Nehmen wir an, der Weg zu Ihrem Arbeitsplatz bestehe aus mehreren Teilstrecken mit unterschiedlichen Gegebenheiten. Sie wollen wissen, was es
bringt und kostet, wenn Sie einzelne Teilstrecken schneller oder langsamer
¨
zurucklegen.
Sie brauchen also ein Programm zur Analyse Ihres Arbeitsweges. Formulieren Sie die Aufgabe genauer, zerlegen Sie sie in Teilaufgaben, beschreiben
¨
Sie die Ein- und Ausgabe, berucksichtigen
Sie Fehler des Benutzers. Aus wel¨ die Rechnungen
chen Gr¨oßen besteht die Ausgabe, welche Eingaben sind fur
erforderlich? Kann eine Division durch Null vorkommen? Das Ergebnis soll¨
ten einige Blatter
Papier mit Worten, Formeln und Skizzen sein, nach denen
ein Programmierer arbeiten k¨onnte. Sie selbst sollen an dieser Stelle noch
nicht an eine Programmiersprache denken.
¨
¨ einen
Falls Ihnen die Ubung
zu einfach erscheint, machen Sie dasselbe fur
Vokabeltrainer, der außer Deutsch zwei Fremdsprachen beherrscht. Wortschatz anfangs je 1000 Vokabeln, erweiterbar. Erste Frage: Was geh¨ort alles
zu einer Vokabel?
2.2
Programmer’s Workbench
Unter der Werkbank des Programmierers werden UNIX-Werkzeuge zusammengefaßt, die zum Programmieren ben¨otigt werden. Auf Maschinen, die
nicht zur Programmentwicklung eingesetzt werden, k¨onnen sie fehlen. Das
Werkzeug make(1) und die Revisionskontrolle sind auch bei Projekten au¨
ßerhalb der Programmierung nutzlich,
vor allem beim Bearbeiten umfangreicher Manuskripte.
42
2.2.1
2 Programmieren in C/C++
Nochmals die Editoren
Editoren wurden bereits im UNIX-Kapitel, Abschnitt ?? Writer’s Workbench
¨
auf Seite ?? erlautert.
Hier geht es nur um einige weitere Eigenschaften des
Editors vi(1), die beim Schreiben von Programmquellen von Belang sind.
¨
¨
Im Quellcode werden ublicherweise
Schleifenrumpfe
und dergleichen um
¨
eine Tabulatorbreite eingeruckt,
die als Default 8 Leerzeichen entspricht. Bei
geschachtelten Schleifen st¨oßt der Text schnell an den rechten Seitenrand. Es
empfiehlt sich, in dem entsprechenden Verzeichnis eine Datei .exrc mit den
Zeilen:
set tabstop=4
set showmatch
set number
anzulegen. Die Option showmatch veranlaßt den vi(1), bei jeder Eingabe
einer rechten Klammer kurz zur zugeh¨origen linken Klammer zu springen.
¨
Die Option number fuhrt
zur Anzeige der Zeilennummern, die jedoch nicht
Bestandteil des Textes werden. Eine Zeile set lisp ist eine Hilfe beim Eingeben von LISP-Quellen.
¨ das Kommando % den Cursor
Steht der Cursor auf einer Klammer, so laßt
zur Gegenklammer springen und dort verbleiben.
Auch beim emacs(1) gibt es einige Wege, das Schreiben von Quellen
¨
zu erleichtern, insbesondere naturlich,
falls es um LISP geht. Der Editor
¨
¨
nedit(1) lasst
sich auf den Stil aller gangigen
Programmiersprachen einschließlich LaTeX einstellen und ist in vielen LINUX-Distributionen enthalten.
2.2.2
Compiler und Linker (cc, ccom, ld)
¨
Auf das Schreiben der Quelltexte mit einem Editor folgt ihre Ubersetzung
¨
in die Sprache der jeweiligen Maschine mittels eines Ubersetzungsprogram¨
¨ einen
mes, meist eines Compilers. Jedes vollstandige
UNIX-System enthalt
¨ weitere Programmiersprachen sind optional. Auf
C-Compiler; Compiler fur
¨
unserer Anlage sind zusatzlich
ein FORTRAN- und ein PASCAL-Compiler
¨
vorhanden, wobei von FORTRAN gegenwartig
die Versionen 77 und 90 nebeneinander laufen.
Kompilieren bedeutete vor der EDV-Zeit zusammentragen. Im alten Rom
¨
hatte es auch noch die Bedeutung von plundern.
In unseren Herzens¨
ergießungen haben wir viel aus Buchern,
Zeitschriften, WWW-Seiten und
Netnews kompiliert.
¨
Ein Compiler ubersetzt
den Quellcode eines Programmes in Maschinensprache. Die meisten Programme enthalten Aufrufe von externen Pro¨
grammodulen, die bereits vorubersetzt
und in Bibliotheken zusammengefaßt
sind. Beispiele sind Ausgaberoutinen oder mathematische Funktionen. Der
2.2 Programmer’s Workbench
43
¨
ausfuhrbare
Code dieser externen Module wird erst vom Linker14 mit dem
¨
¨
Programmcode vereinigt, so daß ein vollstandiges
ausfuhrbares
Programm
entsteht. Es gibt die M¨oglichkeit, die externen Module erst zur Laufzeit hinzuzunehmen; das heißt dynamisches Linken und spart Speicherplatz. Dabei werden die Module entweder beim Laden des Programms in den Arbeitsspeicher oder erst bei ihrem Aufruf hinzugeladen (load on demand). Benutzen
mehrere Programme ein in den Arbeitsspeicher kopiertes Modul gemeinsam
anstatt jeweils eine eigene Kopie anzulegen, so kommt man zu den Shared
Libraries und spart nochmals Speicherplatz.
Die Aufrufe lauten cc(1), f77(1), f90(1) und pc(1). Diese Kommandos rufen Compilertreiber auf, die ihrerseits die eigentlichen Compiler
/lib/ccom, f77comp, f90comp und pascomp starten und noch weitere Dinge erledigen. Ohne Optionen rufen die Compilertreiber auch noch den Linker
¨
/bin/ld(1) auf, so daß das Ergebnis ein lauffahiges
Programm ist, das als
¨
Default den Namen a.out(4) tragt.
Mit dem Namen a.out(4) sollte man
¨
¨
nur vorubergehend
arbeiten (mit mv(1) andern).
Der Aufruf des C-Compilers
sieht beispielsweise so aus:
cc source.c
cc -g source.c -lm -L./lib -I. -DMAX=100
¨
Die erste Zeile stellt den minimalen Aufruf dar, die zweite einen um gangige
¨
Optionen erweiterten. Die Option -g veranlaßt den Compiler, zusatzliche
In¨ den symbolischen Debugger zu erzeugen. Weitere Optionen
formationen fur
sind:
¨
¨
• -v (verbose) fuhrt
zu etwas mehr Bemerkungen beim Ubersetzen,
¨
• -o (output) benennt die ausfuhrbare
Datei mit dem auf die Option
folgenden Namen, meist derselbe wie die Quelle, nur ohne Kennung:
cc -o myprogram myprogram.c,
• -c h¨ort vor dem Linken auf, erzeugt Objektfile mit der Kennung .o,
• -p (profile) erzeugt beim Ablauf des Programmes eine Datei mon.out,
das mit dem Profiler prof(1) ausgewertet werden kann, um Zeitinformationen zum Programm zu erhalten,
¨
• -O optimiert das ausfuhrbare
Programm oder auch nicht.
Der Quelltext des C-Programmes steht in der Datei source.c, die einen beliebigen Namen tragen kann, nur sollte der Name mit der Kennung .c enden. Die anschließende Option -lm fordert den Linker auf, die mathematische
Standard-Bibliothek einzubinden. Die Option -L./lib wendet sich ebenfalls
an den Linker und teilt ihm mit, dass sich im Verzeichnis ./lib weitere
Bibliotheken befinden. Die Reihenfolge, in der Bibliotheken eingebunden wer¨
den, ist wichtig. Die Option -I. veranlasst den Praprozessor,
Include-Dateien
auch im aktuellen Verzeichnis zu suchen, was er nicht immer automatisch
14 Linker
werden auch Binder, Mapper oder Loader genannt. Manchmal wird auch
¨
zwischen Binder und Loader unterschieden, soll uns hier nicht beschaftigen.
44
2 Programmieren in C/C++
tut. Es k¨onnte auch ein anderes Verzeichnis angegeben werden. Die Option
-DMAX=100 definiert eine symbolische Konstante namens MAX und weist ihr
den Wert 100 zu, genau wie eine Zeile:
#define MAX 100
¨
im Quelltext, nur eben hier mit der M¨oglichkeit, den Wert bei der Ubersetzung zu bestimmen. Speichermodelle wie unter PC-DOS gibt es in UNIX
¨
nicht. Hat man Speicher, kann man ihn uneingeschrankt
nutzen.
¨ C-Programme gibt es einen Syntax-Prufer
¨
Fur
namens lint(1), den
man unbedingt verwenden sollte. Er reklamiert nicht nur Fehler, sondern
¨
auch Stilmangel.
Manchmal beanstandet er auch Dinge, die man bewußt gegen die Regeln geschrieben hat. Man muß seinen Kommentar sinnvoll interpretieren. Aufruf:
lint mysource.c
Ein verbesserter lint, ein Secure Programming Lint findet sich bei der University of Virginia unter:
http://www.splint.org/
¨
Unter LINUX ist lint(1) nicht uberall
vorhanden, dann kann man den
¨
Compiler gcc(1) mit einer Option aufrufen, die ihn nur zu einer Prufung
der Syntax veranlasst:
gcc -fsyntax-only -pedantic -Wall mysource.c
¨ C-Quelltexte einen Beautifier
Ferner gibt es unter einigen UNIXen fur
¨
namens cb(1), der den Text in eine standardisierte Form mit Einruckungen
usw. bringt und die Lesbarkeit erleichtert:
cb source.c > source.b
Wenn man mit dem Ergebnis source.b zufrieden ist, l¨oscht man die ur¨
sprungliche
Datei source.c und benennt source.b in source.c um.
2.2.3
Unentbehrlich (make)
Gr¨oßere Programme sind stark gegliedert und auf mehrere bis viele Datei¨
en und Verzeichnisse verteilt. Der Compileraufruf wird dadurch langlich,
und die Wahrscheinlichkeit, etwas zu vergessen, steigt. Hier hilft make(1).
¨ den Compiler in ein makefile (auch
Man schreibt einmal alle Angaben fur
¨ MaMakefile) und ruft dann zum Kompilieren nur noch make(1) auf. Fur
nuskripte ist make(1) ebenfalls zu gebrauchen. Statt Makefiles ließen sich
¨
auch Shellscripts einsetzen, die Starke
von make(1) liegt jedoch im Umgang
¨
mit Dateien unter Beachtung des Zeitstempels mtime (jungster
schreibender
Zugriff). Werkzeuge wie make(1) werden als Builder bezeichnet.
¨ das Projekt ein eigenes Unterverzeichnis an, denn make(1)
Man lege fur
¨
sucht zunachst
im Arbeits-Verzeichnis. Das makefile beschreibt die
2.2 Programmer’s Workbench
45
¨
¨
Abhangigkeiten
(dependencies) der Programmteile voneinander und enthalt
die Kommandozeilen zu ihrer Erzeugung. Ein einfaches makefile sieht so
¨
aus (Zeilen mit Kommandos mussen
durch einen Tabulatorstop – nicht durch
¨
Spaces – eingeruckt
sein):
pgm:
a.o:
b.o:
a.o b.o
cc a.o b.o
incl.h a.c
cc -c a.c
incl.h b.c
cc -c b.c
-o pgm
Quelle 2.7 : Einfaches Makefile
und ist folgendermaßen zu verstehen:
¨
¨
• Das ausfuhrbare
Programm (Ziel, Target) namens pgm hangt
ab von den
Modulen im Objektcode a.o und b.o. Es entsteht durch den Compileraufruf cc a.o b.o -o pgm.
¨
• Das Programmodul a.o hangt
ab von der include-Datei incl.h und
dem Modul im Quellcode a.c. Es entsteht durch den Aufruf des Compilers mit cc -c a.c. Die Option - c unterbindet das Linken.
¨
• Das Programmodul b.o hangt
ab von derselben include-Datei und
dem Modul im Quellcode b.c. Es entsteht durch den Compileraufruf
cc -c b.c.
¨
Ein makefile ist ahnlich
aufgebaut wie ein Backrezept: erst werden die
Zutaten aufgelistet, dann folgen die Anweisungen. Zu beachten ist, daß man
¨
¨
am Ziel startet und ruckw
arts
bis zu den Quellen geht. Kommentar beginnt
mit einem Doppelkreuz und reicht bis zum Zeilenende. Leerzeilen werden
ignoriert.
make(1) verwaltet auch verschiedene Versionen der Programmodule und
paßt auf, daß eine neue Version in alle betroffenen Programmteile eingebunden wird. Umgekehrt wird eine aktuelle Version eines Moduls nicht
unn¨otigerweise kompiliert. Warum wird im obigen Beispiel die include-Datei
¨
incl.h ausdrucklich
genannt? Der Compiler weiß doch auf Grund einer entsprechenden Zeile im Quelltext, daß diese Datei einzubinden ist? Richtig, aber
¨
make(1) muß das auch wissen, denn die include-Datei k¨onnte sich andern,
¨
¨
¨
und dann mussen
alle von ihm abhangigen
Programmteile neu ubersetzt
werden. make(1) schaut nicht in die Quellen hinein, sondern nur auf die Zeit¨
stempel (mtime) der Zutaten. Unveranderliche
include-Dateien wie stdio.h
¨
brauchen nicht im makefile aufgefuhrt
zu werden.
¨
Nun ein etwas umfangreicheres Beispiel, das aber langst
noch nicht alle
¨
Fahigkeiten
von make(1) ausreizt:
# Kommentar, wie ueblich
CC = /bin/cc
CFLAGS =
46
2 Programmieren in C/C++
FC = /usr/bin/f77
LDFLAGS = -lcl
all: csumme fsumme clean
csumme: csumme.c csv.o csr.o
$(CC) -o csumme csumme.c csv.o csr.o
csv.o: csv.c
$(CC) -c csv.c
csr.o: csr.c
$(CC) -c csr.c
fsumme: fsumme.c fsr.o
$(CC) -o fsumme fsumme.c fsr.o $(LDFLAGS)
fsr.o: fsr.f
$(FC) -c fsr.f
clean:
rm *.o
Quelle 2.8 : Makefile mit Makros und Dummy-Zielen
¨
¨
Zunachst
werden einige Makros definiert, z. B. der Compileraufruf CC. Uberall, wo im Makefile das Makro mittels $(CC) aufgerufen wird, wird es vor
¨
der Ausfuhrung
w¨ortlich ersetzt. Auf diese Weise kann man einfach einen
¨
anderen Compiler wahlen,
ohne im ganzen Makefile per Editor ersetzen zu
¨
¨
mussen.
Dann haben wir ein Dummy-Ziel all, das aus einer Aufzahlung
weiterer Ziele besteht. Mittels make all wird dieses Dummy-Ziel erzeugt, d. h.
¨
die aufgezahlten
Ziele. Unter diesen befindet sich auch eines namens clean,
¨
das ohne Zutaten daherkommt und offenbar nur bestimmte Tatigkeiten
wie
¨
das L¨oschen temporarer
Dateien bezweckt. Ein Dummy-Ziel ist immer out¨
of-date, die zugeh¨origen Kommandos werden immer ausgefuhrt.
Ein weiteres
¨ make(1) findet sich in Abschnitt 2.11.7.4 Arrays von Funktionen
Beispiel fur
auf Seite 226.
make(1) darf rekursiv aufgerufen werden, ein Makefile darf make-Aufrufe
enthalten, die sich auf andere Makefiles beziehen. Das kann so aussehen:
......
cd subdirectory ; make all ; make clean
......
Gelangt make an diese Zeile, springt es in das Unterverzeichnis, sucht dort
ein Makefile und erzeugt die Ziele all und clean. Anschließend macht es
im Makefile des aktuellen Verzeichnisses weiter. Eine Anwendung ist ein aus
mehreren Kapiteln bestehendes Skriptum, das komplett als Report formatiert werden soll, dazu noch die Kapitel in jeweils einem eigenen Unterver¨
zeichnis als Artikel samt Folien. Naturlich
sind die Makefiles in den Unterverzeichnissen weiche Links auf ein einziges Makefile. Ohne make(1) und
2.2 Programmer’s Workbench
47
¨
¨
eine entsprechende Verzeichnisstruktur wurde
man sich dumm und damlich
tippen.
¨ verschiedene Systeme
Im GNU-Projekt wird Software im Quellcode fur
ver¨offentlicht. In der Regel muß man die Quellen auf der eigenen Anlage kompilieren. Infolgedessen geh¨oren zu den GNU-Programmen fast immer um¨
fangreiche Makefiles oder sogar Hierarchien davon. Ubung
im Gebrauch von
make(1) erleichtert die Einrichtung von GNU-Software daher erheblich. Oft
wird ein an das eigene System angepaßtes Makefile erst durch ein Kommando
./configure erzeugt. Die Reihenfolge bei solchen Programmeinrichtungen
lautet dann:
./configure
(vi Makefile)
make
make install
make clean
wobei make install Schreibrechte in den betroffenen Verzeichnissen erfordert, also meist Superuserrechte. Gelegentlich wird make(1) aus einem
Shellscript heraus aufgerufen, das einige Dinge vorbereitet. So wird zum Beispiel sendmail(1) durch den Aufruf des mitgelieferten Shellscripts Build
erzeugt.
Das Skript configure erlaubt oft die Option --prefix=DIR, wobei DIR
das Verzeichnis ist, in dem das ganze Ger¨odel eingerichtet werden soll,
¨
defaultmaßig
meist /usr/local, aber manchmal besser /usr oder /opt.
¨
Da von configure alles Weitere abhangt,
sollte man sich die zugeh¨orige
Protokoll-Datei config.log ansehen, auch wenn anscheinend keine Probleme aufgetreten sind.
Statt make clean kann man auch make distclean versuchen, das
¨
¨
raumt
noch grundlicher
auf, so daß hinterher wieder mit ./configure ein
Neubeginn m¨oglich ist.
2.2.4
Debugger (xdb, gdb)
Programme sind Menschenwerk und daher fehlerhaft15 . Es gibt keine M¨oglichkeit, die Fehlerfreiheit eines Programmes festzustellen oder zu beweisen
¨
außer in trivialen oder idealen Fallen.
Die Fehler lassen sich in drei Klassen einteilen. Verst¨oße gegen die Regeln
der jeweiligen Programmiersprache heißen Grammatikfehler oder Syntax¨
fehler. Sie fuhren
bereits zu einem Abbruch des Kompiliervorgangs und las15 Es
irrt der Mensch, so lang er strebt. G OETHE, Faust. Oder errare humanum
¨
est, wie wir Lateiner sagen. Noch etwas alter:
αµαρτ ωλαι εν ανϑρωπoισιν επoντ αι
ϑνητ oις. Die entsprechende Aussage in babylonischer Keilschrift aus dem Codex
¨
Kombysis k¨onnen wir leider aus Mangel an einem TeX-Font vorlaufig
nicht wieder¨
geben. In der nachsten
Auflage werden wir jedoch eine eingescannte Zeichnung aus
¨
der H¨ohle von Rienne-Vaplus zeigen, die als alteste
Dokumentation obiger Weisheit
gilt.
48
2 Programmieren in C/C++
¨
sen sich schnell lokalisieren und beheben. Der C-Syntax-Prufer
lint ist das
¨ ein einfacher
beste Werkzeug zu ihrer Entdeckung. wihle statt while ware
Syntaxfehler. Fehlende oder unpaarige Klammern sind auch beliebt, deshalb
¨ der vi(1) eine Funktion zur Klammerprufung.
¨
¨
enthalt
Unzulassige
Operationen mit Pointern sind ebenfalls an der Tagesordnung. Geht es um Texte,
so fallen Tippfehler und Grammatikfehler in diese Klasse.
Falls das Programm die Kompilation ohne Fehlermeldung hinter sich gebracht hat, startet man es. Dann melden sich die Laufzeitfehler, die un¨
ter Umstanden
nur bei bestimmten und wom¨oglich seltenen Parameterkonstellationen auftreten. Ein typischer Laufzeitfehler ist die Division durch eine
Variable, die manchmal den Wert Null annimmt. Die Fehlermeldung lautet
¨
Floating point exception. Ein anderer haufig
vorkommender Laufzeitfehler
¨
ist die Uberschreitung
von Arraygrenzen oder die Verwechslung von Varia¨
blen und Pointern, was zu einem Memory fault, einem Speicherfehler fuhrt.
Die dritte Klasse bilden die logischen Fehler oder Denkfehler. Sie werden auch semantische Fehler genannt. Das Programm arbeitet einwandfrei, nur tut es nicht das, was sich der Programmierer vorgestellt hat. Ein
¨
typischer Denkfehler ist das Verzahlen
bei den Elementen eines Arrays oder
¨
bei Schleifendurchgangen
um genau eins. Hier hilft der Computer nur we¨
nig, da der Armste
ja gar nicht weiß, was sich der Programmierer vorstellt.
¨
¨
Diese Fehler kosten viel Muhe,
doch solcherlei Verdrusse
pflegen die Den¨
kungskrafte
anzuregen, meint W ILHELM B USCH und hat recht.
Eine vierte Fehlerklasse liegt fast schon außerhalb der Verantwortung des
Programmierers. Wenn das mathematische Modell zur Beschreibung eines
realen Problems ungeeignet ist, mag das Programm so fehlerarm sein wie
¨ bestimmte
es will, seine Ergebnisse gehen an der Wirklichkeit vorbei. Fur
¨ andeZwecke ist eine Speisekarte ein brauchbares Modell einer Mahlzeit, fur
re nicht.
In diese Klasse fallen auch Fehler, die dadurch entstehen, dass wir im
¨
¨
Computer stets mit Zahlen endlicher Lange
rechnen, wahrend
in Wirklichkeit die Zahl π unendlich viele Dezimalstellen hat und gemessene Gr¨oßen
statistischen Schwankungen unterliegen, also unscharf begrenzte Intervalle
darstellen. Grundkenntnisse in moderner numerischer Mathematik bewahren vor blindem Glauben an den Computer.
Ob und wie inhaltliche Fehler in Texten – falsche oder fehlende Angaben –
einer der vorstehenden Klassen sinnvoll zugeordnet werden k¨onnen, ist noch
¨
zu uberlegen.
Dann gibt es noch den Fehler Thema verfehlt, der vielleicht
zum Modell-Fehler passt. Hintergrund dieser Gedanken ist die Anwendung
von Software-Werkzeugen in Text-Projekten, was erwiesenermaßen die Arbeit erleichtert.
Ein Fehler wird im Englischen auch als bug bezeichnet, was soviel wie
Wanze oder Laus bedeutet. Ein Programm zu entlausen heißt Debugging.
Dazu braucht man einen Debugger (d´everminateur, d´eboguer). Das sind Pro¨
gramme, unter deren Kontrolle das verlauste Programm ablauft.
Man hat
¨
dabei vielfaltige
M¨oglichkeiten, in den Ablauf einzugreifen. Ein absoluter
¨
Debugger wie der adb(1) bezieht sich dabei auf das lauffahige
Programm
2.2 Programmer’s Workbench
49
¨ die meisten
im Arbeitsspeicher – nicht auf den Quellcode – und ist somit fur
Aufgaben wenig geeignet. Ein symbolischer Debugger wie der sdb(1), der
GNU gdb(1) oder der xdb(1) bezieht sich auf die jeweilige Stelle im Quell¨
text16 . Debugger sind machtige
und hilfreiche Werkzeuge. Manche Programmierer gehen so weit, daß sie das Schreiben eines Programms als Debuggen
¨
einer leeren Datei bzw. eines weißen Blattes Papier ansehen. In der Ubung
¨
wird eine einfache Anwendung des Debuggers vorgefuhrt.
¨
Falls Sie auch mit dem UNIX-Debugger nicht alle Wurmer
in Ihrem Programm finden und vertreiben k¨onnen, m¨ochten wir Ihnen noch ein altes
Hausrezept verraten, das aus einer Handschrift des 9. Jahrhunderts stammt.
¨
Das Rezept ist im Raum Wien – Munchen
entstanden und unter den Namen
Contra vermes oder Pro nescia bekannt. Leider ist die README-Datei, welche
¨
die Handhabung erklart,
verlorengegangen. Wir schlagen vor, die Zeilen als
¨
Kommentar in das Programm einzufugen.
Hier der Text:
´ nesso, mid nigun nessiklinon,
Gang ut,
ˆ fana themo marge an that bˆen,
ut
fan thˆemo bˆene an that flˆesg,
ˆ fan themo flˆesgke an thia hud,
ˆ
ut
ˆut fan thera hud
ˆ an thesa strala.
ˆ
Drohtin. Uuerthe sˆo!
2.2.5
Profiler (time, gprof)
Profiler sind ebenfalls Programme, unter deren Kontrolle ein zu untersu¨
chendes Programm ablauft.
Ziel ist die Ermittlung des Zeitverhaltens in der
Absicht, das Programm schneller zu machen. Ein einfaches UNIX-Werkzeug
ist time(1):
time prim 1000000
Die Ausgabe sieht so aus:
real
user
sys
0m 30.65s
0m 22.53s
0m 1.07s
und bedeutet, daß die gesamte Laufzeit des Programms prim 30.65 s betrug,
¨
davon entfielen 22.53 s auf die Ausfuhrung
von Benutzeranweisungen und
¨
1.07 s auf Systemtatigkeiten.
Die Ausgabe wurde durch einen Aufruf des
Primzahlenprogramms aus Abschnitt 2.11.7 Ein Herz fur
¨ Pointer auf Seite 219 erzeugt, das selbst Zeiten mittels des Systemaufrufs time(2) mißt
¨ die Rechnung und 4 s fur
¨ die Bildschirmausgabe meldet.
und rund 22 s fur
Ein weiterer Profiler ist gprof(1). Seine Verwendung setzt voraus, daß
das Programm mit der Option -G kompiliert worden ist. Es wird gestartet und erzeugt neben seiner normalen Ausgabe eine Datei gmon.out, das
mit gprof(1) betrachtet wird. Besser noch lenkt man die Ausgabe von
¨
gprof(1) in eine Datei um, die sich lesen und editieren laßt:
16 Real
programmers don’t use source language debuggers.
50
2 Programmieren in C/C++
gprof prim > prim.gprofile
¨
Eine stark gekurzte
Analyse mittels gprof(1) sieht so aus:
%time
the percentage of the total running time of the
program used by this function.
cumsecs a running sum of the number of seconds accounted
for by this function and those listed above it.
seconds the number of seconds accounted for by this
function alone. This is the major sort for this
listing.
calls
the number of times this function was invoked, if
this function is profiled, else blank.
name
the name of the function.
for this listing.
This is the minor sort
%time cumsecs seconds calls msec/call name
52.1
12.18
12.18
$$remU
22.2
17.38
5.20
$$mulU
20.8
22.25
4.87 333332
0.01 ttest
2.1
22.74
0.49
9890
0.05 _doprnt
0.8
22.93
0.19
_mcount
0.6
23.08
0.15
$$divide_by_const
0.6
23.22
0.14
1
140.00 main
0.3
23.29
0.07
9890
0.01 _memchr
0.2
23.34
0.05
_write_sys
0.1
23.36
0.02
9890
0.00 _printf
0.0
23.37
0.01
9887
0.00 _write
0.0
23.38
0.01
9887
0.00 _xflsbuf
0.0
23.39
0.00
9890
0.00 _wrtchk
0.0
23.39
0.00
1
0.00 _sscanf
0.0
23.39
0.00
1
0.00 _start
0.0
23.39
0.00
1
0.00 _strlen
0.0
23.39
0.00
1
0.00 atexit
0.0
23.39
0.00
1
0.00 exit
0.0
23.39
0.00
1
0.00 ioctl
Wir sehen, daß die Funktion ttest() sehr oft aufgerufen wird und 4,87 s
¨ Die beiden ersten Funktionen werden vom Compiler zur Verfugung
¨
verbrat.
gestellt (Millicode aus /usr/lib/milli.a) und liegen außerhalb unserer
Reichweite.
¨ genauere Auskunfte
¨
Fur
zieht man den Systemaufruf times(2), den Debugger oder das UNIX-Kommando prof(1) in Verbindung mit der Subroutine monitor(3) heran.
2.2 Programmer’s Workbench
2.2.6
51
Archive, Bibliotheken (ar)
Viele Teilaufgaben in den Programmen wiederholen sich immer wieder. Das
sind Aufgaben, die mit dem System zu tun haben, Befehle zur Bildschirmsteuerung, mathematische Berechnungen wie Logarithmus oder trigonometrische Funktionen, Datenbankfunktionen oder Funktionen zur Abfrage von
¨
Meßgeraten
am Bus.
Damit man diese Funktionen nicht jedesmal neu zu erfinden braucht, wer¨
den sie in Bibliotheken gepackt, die dem Programmierer zur Verfugung
ste¨
hen. Teils stammen sie vom Hersteller des Betriebssystems (also ursprunglich AT&T), teils vom Hersteller der Compiler (bei uns Hewlett-Packard und
GNU) oder der Anwendungssoftware, teils von Benutzern. Bibliotheken enthalten Programmbausteine, es lassen sich aber auch andere Dateien (Texte,
Grafiken) in gleicher Weise zusammenfassen. Dann spricht man allgemeiner
von Archiven. Außer den Dateien enthalten Archive Verwaltungsinformationen (Index) zum schnellen Finden der Inhalte. Diese Informationen wurden
¨
fruher
mit dem Kommando ranlib(1) eigens erzeugt, heute erledigt ar(1)
das mit. Die Verwendung von Bibliotheken beim Programmieren wird in Ab¨
schnitt 2.5 Funktions-Bibliotheken auf Seite 150 erlautert.
¨
Außer den mit dem Compiler gelieferten Bibliotheken kann man zusatzlich erworbene oder selbst erstellte Bibliotheken verwenden. Im Handel sind
¨ Bildschirmmasken, zur Verbeispielsweise Bibliotheken mit Funktionen fur
¨ Grafik, zur Meßwerterfassung und
waltung index-sequentieller Dateien, fur
¨ besondere mathematische Aufgaben. Auch aus dem
-aufbereitung und fur
Netz laufen Bibliotheken zu. Eigene Bibliotheken erzeugt man mit dem
UNIX-Kommando ar(1); das Datei-Format ist unter ar(4) beschrieben. Ein
Beispiel zeige den Gebrauch. Wir haben ein Programm statistik.c zur Berechnung von Mittelwert und Varianz der in der Kommandozeile mitgegebenen ganzen Zahlen geschrieben:
/* Statistische Auswertung von eingegebenen Werten
Privat-Bibliothek ./libstat.a erforderlich
Compileraufruf cc statistik.c -L . -lstat
*/
#define MAX 100
#include <stdio.h>
/* max. Anzahl der Werte */
void exit(); double mwert(), varianz();
main(int argc, char *argv[])
{
int i, a[MAX];
if (argc < 3) {
puts("Zuwenig Werte"); exit(-1);
}
if (argc > MAX + 1) {
52
2 Programmieren in C/C++
puts("Zuviel Werte"); exit(-1);
}
/* Uebernahme der Werte in ein Array */
a[0] = argc - 1;
for (i = 1; i < argc; i++) {
sscanf(argv[i], "%d", a + i);
}
/* Ausgabe des Arrays */
for (i = 1; i < argc; i++) {
printf("%d\n", a[i]);
}
/* Rechnungen */
printf("Mittelwert: %f\n", mwert(a));
printf("Varianz:
%f\n", varianz(a));
return 0;
}
Quelle 2.9 : C-Programm Statistik mit Benutzung einer eigenen Funktionsbibliothek
Das Programm verwendet die Funktionen mwert() und varianz(), die
wir aus einer hausgemachten Funktionsbibliothek namens libstat.a entnehmen. Der im Kommentar genannte Compileraufruf mit der Option -L .
veranlaßt den Linker, diese Bibliothek im Arbeits-Verzeichnis zu suchen. Die
Funktionen sehen so aus:
double mwert(x)
int *x;
{
int j, k;
double m;
for (j = 1, k = 0; j <= *x; j++) {
k = k + x[j];
}
m = (double)k / (double)*x;
return m;
}
Quelle 2.10 : C-Funktion Mittelwert ganzer Zahlen
extern double mwert();
double varianz(x)
2.2 Programmer’s Workbench
53
int *x;
{
int j;
double m, s, v;
m = mwert(x);
for (j = 1, s = 0; j <= *x; j++) {
s = s + (x[j] - m) * (x[j] - m);
}
v = s / (*x - 1);
return v;
}
Quelle 2.11 : C-Funktion Varianz ganzer Zahlen
Diese Funktionen werden mit der Option -c kompiliert, so daß wir zwei
Objektfiles mwert.o und varianz.o erhalten. Mittels des Aufrufes
ar -r libstat.a mwert.o varianz.o
erzeugen wir die Funktionsbibliothek libstat.a, auf die mit der Compileroption -lstat zugegriffen wird. Der Vorteil der Bibliothek liegt darin, daß
man sich nicht mit vielen einzelnen Funktionsfiles herumzuschlagen braucht,
¨
sondern mit der Compileroption gleich ein ganzes Bundel
verwandter Funktionen erwischt. In das Programm eingebunden werden nur die Funktionen,
die wirklich ben¨otigt werden.
¨
¨ sind anMerke: Ein Archiv ist weder verdichtet noch verschlusselt.
Dafur
¨
dere Werkzeuge (gzip(1), crypt(1)) zustandig.
2.2.7
Weitere Werkzeuge
Das Werkzeug cflow(1) ermittelt die Funktionsstruktur zu einer Gruppe
von C-Quell- und Objektfiles. Der Aufruf:
cflow statistik.c
liefert auf stdout
1
2
3
4
5
6
7
main: int(), <statistik.c 15>
puts: <>
exit: <>
sscanf: <>
printf: <>
mwert: <>
varianz: <>
was besagt, daß die Funktion main() vom Typ int ist und in Zeile 15 des
Quelltextes statistik.c definiert wird. main() ruft seinerseits die Funktionen puts, exit, sscanf und printf auf, die in statistik.c nicht definiert werden, da sie Teil der Standardbibliothek sind. Die Funktionen mwert
54
2 Programmieren in C/C++
und varianz werden ebenfalls aufgerufen und nicht definiert, da sie aus einer Privatbibliothek stammen.
Das Werkzeug cxref(1) erzeugt zu einer Gruppe von C-Quellfiles eine
Kreuzreferenzliste aller Symbole, die nicht rein lokal sind. Der Aufruf
cxref fehler.c
gibt nach stdout eine Liste aus, deren erste Zeilen so aussehen:
fehler.c:
SYMBOL
FILE
FUNCTION LINE
BUFSIZ
EOF
FILE
/usr/include/stdio.h
/usr/include/stdio.h
/usr/include/stdio.h
----
FILENAME_MAX /usr/include/stdio.h -FOPEN_MAX
/usr/include/stdio.h -L_ctermid
/usr/include/stdio.h -L_cuserid
/usr/include/stdio.h -L_tmpnam
/usr/include/stdio.h -NULL
/usr/include/stdio.h -PI
fehler.c
-P_tmpdir
/usr/include/stdio.h -SEEK_CUR
/usr/include/stdio.h -SEEK_END
/usr/include/stdio.h -SEEK_SET
/usr/include/stdio.h -TMP_MAX
/usr/include/stdio.h -_CLASSIC_ANSI_TYPES /usr/include/stdio.h --
*10
70 *71
*18 78 123
127 128 201
223
*67
*68
*193
*194
*61
35 *36
*27
*209
*55
*56
53 *54
63 *64
162
Durch die include-Datei stdio.h und gegebenenfalls durch Bibliotheksfunktionen geraten viele Namen in das Programm, von denen man nichts
ahnt. Ferner gibt es einige Werkzeuge zur Ermittlung und Bearbeitung von
¨
¨
Strings in Quellfiles und ausfuhrbaren
Programmen, teilweise beschrankt
auf
C-Programme (tt strings(1), xstr(1)).
Weitere wichtige Werkzeuge sind ein Lineal und Buntstifte, mit denen
man zusammengeh¨orende Namen oder Teile im Quelltext markiert.
2.2.8
Versionsverwaltung mit RCS, SCCS und CVS
¨
Gr¨oßere Projekte werden von zahlreichen, unter Umstanden
wechselnden
Programmierern oder Autoren gemeinsam bearbeitet. In der Regel werden
¨
die so entstandenen Programmpakete uber
Jahre hinweg weiterentwickelt
und vielleicht auf mehrere Systeme portiert. Die Arbeit vollzieht sich in mehreren Stufen parallel zur Zeitachse (siehe auch Abschnitt 2.1.8 Programmiertechnik auf Seite 35):
2.2 Programmer’s Workbench
55
• Aufgabenstellung
• Aufgabenanalyse
• Umsetzung in eine Programmiersprache
• Testen
• Dokumentieren
¨
• vorlaufige
Freigabe
¨
• endgultige
Freigabe
• Weiterentwicklung, Pflege
¨
Des weiteren wird ein Programmpaket in viele uberschaubare
Module aufgeteilt. Von jedem Modul entstehen im Verlauf der Arbeit mehrere Fassungen
¨ sich in einem dreioder Versionen. Der Zustand des ganzen Projektes laßt
dimensionalen Koordinatensystem mit den Achsen Modul, Stufe (Zeit) und
Version darstellen. Das von WALTER F. T ICHY entwickelte Revision Control System RCS ist ein Werkzeug, um bei dieser Entwicklung Ordnung zu
¨ sich gut mit make(1). Das
halten. Es ist einfach handzuhaben und vertragt
RCS erledigt drei Aufgaben:
¨
¨
¨
• Es fuhrt
Buch uber
die Anderungen
an den Texten.
¨
• Es erm¨oglicht, altere
Versionen wiederherzustellen, ohne daß diese voll¨
standig
gespeichert zu werden brauchen (Speichern von Differenzen).
• Es verhindert gleichzeitige schreibende Zugriffe mehrerer Benutzer auf
denselben Text.
Sowie es um mehr als Wegwerfprogramme geht, sollte man make(1) und
RCS einsetzen. Der geringe Aufwand zum Einarbeiten wird bei der weiteren
Arbeit mehr als wett gemacht. Arbeiten mehrere Programmierer an einem
¨
Projekt, kommt man um RCS oder ahnliches
nicht herum. Beide Werkzeuge
¨ Manuskripte oder WWW-Dateien zu verwenden. RCS ist in den
sind auch fur
meisten LINUX-Distributionen enthalten. Man beginnt folgendermaßen:
• Unterverzeichnis anlegen, hineinwechseln.
• Mit einem Editor die erste Fassung des Quelltextes schreiben. Irgendwo im Quelltext - z. B. im Kommentar - sollte $Header$ oder $Id$
¨
vorkommen, siehe unten. Dann ubergibt
man mit dem Kommando
¨
ci filename (check in) die Datei dem RCS. Dieses erganzt
die Datei durch Versionsinformationen und macht eine nur lesbare RCS-Datei
¨
(444) mit der Kennung ,v daraus. Die ursprungliche
Datei l¨oschen.
• Mit dem Kommando co filename (check out, ohne ,v) bekommt man
¨
eine Kopie seiner Datei zuruck,
und zwar nur zum Lesen. Diese Ko¨
pie kann man mit allen UNIX-Werkzeugen bearbeiten, nur das Zuruckschreiben mittels ci verweigert das RCS.
56
2 Programmieren in C/C++
• Mit dem Kommando co -l filename wird eine les- und schreibba¨ weitere, gleichzeitige
re Kopie erzeugt. Dabei wird die RCS-Datei fur
Schreibzugriffe gesperrt (l = lock). Die Kopie kann man mit allen UNIX¨ jedoch ein schlechter EinWerkzeugen bearbeiten, Umbenennen ware
fall.
¨
• Beim Zuruckstellen
mittels ci filename hat man Gelegenheit, einen
kurzen Kommentar in die Versionsinformationen zu schreiben wie
¨
Grund und Umfang der Anderung.
Mittels rlog filename werden die
¨ der Quelltext die
Versionsinformationen auf den Schirm geholt. Enthalt
¨
Zeichenfolge $Log$ – zweckmaßig
im Kommentar am Anfang – so wer¨
den die Versionsinformationen auch dorthin ubernommen.
Dann hat
man alles im Quellfile beisammen.
• Falls Sie sich mit co -l filename eine Kopie zum Editieren geholt
¨ weitere Schreibzugriffe geund damit gleichzeitig das Original fur
sperrt haben, anschließend die Kopie mit rm(1) l¨oschen, so haben Sie
¨
¨
nichts mehr zum Zuruckstellen.
In diesem Fall laßt
sich die Sperre
mit rcs -u filename aufheben. Besser ist es jedoch, auf die UNIXKommandos zu verzichten und nur mit den RCS-Kommandos zu arbeiten.
¨ den Anfang alles. Die RCS-Kommandos lassen sich in MakefiDas ist fur
les verwenden. Die vom RCS vergebenen Zugriffsrechte k¨onnen von UNIX¨
Kommandos (chmod(1)) uberrannt
werden, aber das ist nicht Sinn der Sache; der Einsatz von RCS setzt voraus, daß sich die Beteiligten diszipliniert
verhalten.
¨ das nachstehende SortierproHier ein Makefile mit RCS-Kommandos fur
gramm:
# makefile zu mysort.c, im RCS-System
# $Header: makefile,v 1.5 95/07/04 14:56:09 wualex1 Exp $
CC = /bin/cc
CFLAGS = -Aa -DDEBUG
all: mysort clean
mysort: mysort.o bubble.o
$(CC) $(CFLAGS) -o mysort mysort.o bubble.o
mysort.o: mysort.c myheader.h
$(CC) $(CFLAGS) -c mysort.c
bubble.o: bubble.c myheader.h
$(CC) $(CFLAGS) -c bubble.c
mysort.c: mysort.c,v
co mysort.c
bubble.c: bubble.c,v
co bubble.c
2.2 Programmer’s Workbench
57
myheader.h: myheader.h,v
co myheader.h
clean:
/bin/rm
-f *.c *.o *.h makefile
Quelle 2.12 : Makefile zum Sortierprogramm mysort.c
Da dieses Beispiel sich voraussichtlich zu einer kleinen Familie von Quelltexten ausweiten wird, legen wir eine privates include-Datei mit unseren eige¨ alle Teile gultigen
¨
nen, fur
Werten an:
/* myheader.h zum Sortierprogramm, RCS-Beispiel
W. Alex, Universitaet Karlsruhe, 04. Juli 1995
*/
/*
$Header: myheader.h,v 1.5 95/07/04 14:58:41 wualex1 Exp $
*/
int bubble(char *text);
int insert(char *text);
#define
#define
#define
#define
USAGE "Aufruf: mysort filename"
NOTEXIST "File existiert nicht"
NOTREAD "File ist nicht lesbar"
NOTSORT "Problem beim Sortieren"
#define
#define
LINSIZ
MAXLIN
64
256
/* Zeilenlaenge */
/* Anzahl Zeilen */
Quelle 2.13 : Include-Datei zum Sortierprogramm mysort.c
¨
Nun das Hauptprogramm, das die Verantwortung tragt,
aber sonst nicht viel
tut. Hier ist der Platzhalter $Header$ Bestandteil des Codes, die Versionsin¨
formationen stehen also auch im ausfuhrbaren
Programm. Man k¨onnte sogar
mit ihnen etwas machen, ausgeben beispielsweise:
/* Sortierprogramm mysort, als Beispiel fuer RCS */
/*
$Log$
*/
static char rcsid[] =
"$Header: mysort.c,v 1.9 95/07/04 14:18:37 wualex1 Exp $";
#include <stdio.h>
#include "myheader.h"
int main(int argc, char *argv[])
{
58
2 Programmieren in C/C++
long time1, time2;
/* Pruefung der Kommandozeile */
if (argc != 2) {
puts(USAGE); return(-1);
}
/* Pruefung des Textfiles */
if (access(argv[1], 0)) {
puts(NOTEXIST); return(-2);
}
if (access(argv[1], 4)) {
puts(NOTREAD); return(-3);
}
/* Sortierfunktion und Zeitmessung */
time1 = time((long *)0);
if (bubble(argv[1])) {
puts(NOTSORT); return(-4);
}
time2 = time((long *)0);
/* Ende */
printf("Das Sortieren dauerte %ld sec.\n", time2 - time1);
return 0;
}
¨ RCS
Quelle 2.14 : C-Programm Sortieren, fur
Hier die Funktion zum Sortieren (Bubblesort, nicht optimiert). Der einzige
Witz in dieser Funktion ist, daß wir nicht die Strings durch Umkopieren sortieren, sondern nur die Indizes der Strings. Ansonsten kann man hier noch
einiges verbessern und vor allem auch andere Sortieralgorithmen nehmen.
Man sollte auch das Einlesen und die Ausgabe vom Sortieren trennen:
/* Funktion bubble() (Bubblesort), als Beispiel fuer RCS
W. Alex, Universitaet Karlsruhe, 04. Juli 1995 */
/*
$Header: bubble.c,v 1.2 95/07/04 18:11:04 wualex1 Exp $
*/
#include &#60;stdio.h&#62;
#include &#60;string.h&#62;
#include "myheader.h"
2.2 Programmer’s Workbench
int bubble(char *text)
{
int i = 0, j = 0, flag = 0, z, line[MAXLIN];
char array[MAXLIN][LINSIZ];
FILE *fp;
#if DEBUG
printf("Bubblesort %s\n", text);
#endif
/* Einlesen */
if ((fp = fopen(text, "r")) == NULL) return(-1);
while ((!feof(fp)) && (i < MAXLIN)) {
fgets(array[i++], LINSIZ, fp);
}
fclose(fp);
#if DEBUG
puts("Array:");
j = 0;
while (j < i) {
printf("%s", array[j++]);
}
puts("Ende Array");
#endif
/* Sortieren (Bubblesort) */
for (j = 0; j < MAXLIN; j++)
line[j] = j;
while (flag == 0) {
flag = 1;
for (j = 0; j < i; j++) {
if (strcmp(array[line[j]], array[line[j + 1]]) > 0) {
z = line[j + 1];
line[j + 1] = line[j];
line[j] = z;
flag = 0;
}
}
}
/* Ausgeben nach stdout */
#if DEBUG
puts("Array:");
j = 0;
while (j < i) {
printf("%d\n", line[j++]);
}
59
60
2 Programmieren in C/C++
puts("Ende Array");
#endif
j = 0;
while (j < i) {
printf("%s", array[line[j++]]);
}
/* Ende */
return 0;
}
Quelle 2.15 : C-Funktion Bubblesort
¨ kleine Sortieraufgaben mit bis zu etwa hundert
Bubblesort eignet sich fur
Elementen. Kopieren Sie sich die Bausteine in ein eigenes Verzeichnis und
¨
entwickeln Sie das Programm unter Verwendung des RCS weiter. Naheres
siehe rcsintro(5).
¨
Anfangs erscheint das Arbeiten mit RCS bei kleinen Projekten als lastig,
¨
ahnlich
wie das Anlegen eines Makefiles. Man gew¨ohnt sich aber schnell dar¨
an und spart sofort das Eintragen des Anderungsdatums
von Hand. Nach
¨ die selbst auferlegte Ordnung dankbar.
kurzer Zeit ist man fur
Das Source Code Control System SCCS verwaltet die Versionen der
¨
Module, indem es die erste Fassung vollstandig
speichert und dann jeweils die
¨
¨
¨
Differenzen zur nachsten
Version, wahrend
RCS die jungste
Version speichert
¨
und die alteren
aus den Differenzen rekonstruiert.
Alle Versionen eines Programmes samt den Verwaltungsdaten werden in
einer einzigen SCCS-Datei namens s.filename abgelegt, auf das schrei¨
bend nur uber
besondere SCCS-Kommandos zugegriffen werden kann. Das
erste dieser Kommandos ist admin(1) und erzeugt aus einem C-Quellfile
program.c das zugeh¨orige SCCS-Dokument:
admin -iprogram.c s.program.c
Mit admin(1) lassen sich noch weitere Aufgaben erledigen, siehe ReferenzHandbuch. Mittels get(1) holt man das Quellfile wieder aus dem SCCS¨
Dokument heraus, mitttels delta(1) gibt man eine geanderte
Fassung des
¨
Quellfiles an das SCCS-Dokument zuruck.
RCS und SCCS arbeiten auf Datei-Ebene. Bei gr¨oßeren Projekten ist es
¨
wunschenswert,
mehrere Dateien gemeinsam oder ganze Verzeichnisse in
die Versionsverwaltung einzubeziehen. Dies leistet das Concurrent Versions System (CVS). Es baut auf RCS auf und erweitert dessen Funktiona¨ außerdem um eine Client-Server-Architektur. Die beteiligten Dateien
litat
und Verzeichnisse k¨onnen auf verschiedenen Computern im Netz liegen. Im
Gegensatz zu RCS, das zu einem Zeitpunkt immer nur einem Benutzer das
Schreiben gestattet, verfolgt CVS eine sogenannte optimistische Kooperationsstrategie. Mehrere Programmierer k¨onnen gleichzeitig auf Kopien dersel¨
ben Version (Revision) arbeiten. Beim Zuruckschreiben
wird ein Abgleich mit
2.2 Programmer’s Workbench
61
der in der zentralen Versionsbibliothek (Repository) abgelegten Fassung er¨
¨
zwungen, um zu verhindern, daß parallel durchgefuhrte
und bereits zuruck¨
geschriebene Versionen uberschrieben
werden. Diese Strategie kann zu Kon¨
¨
¨
flikten fuhren,
die per Hand aufgel¨ost werden mussen.
Wahrend
das Ein¨
richten eines CVS-Projektes Uberblick erfordert, ist das Arbeiten unter CVS
nicht schwieriger als unter RCS. Einzelheiten wie so oft am einfachsten aus
¨
dem Netz, wo außer dem Programmpaket selbst auch kurze oder ausfuhrliche, deutsche oder englische Anleitungen zu finden sind. Unter den Namen
¨ weitere Betriebssysteme im Netz.
WinCVS und MacCVS liegen Fassungen fur
Der Oberbegriff des ganzen Gebietes lautet Software Configuration Management (SCM) oder allgemeiner Configuration Management (CM). Lassen Sie
einmal eine Suchmaschine darauf los, es gibt mehrere freie oder kommerzielle
¨
¨
Produkte sowie Ubersichten,
Einfuhrungen
und Tutorials dazu.
¨
Ist die Entwicklung einer Software oder eines Manuskriptes vorlaufig
abgeschlossen, geht es an die Pflege. Dazu geh¨ort unter anderem das Manage¨ gibt
ment der im Betrieb der Software auftauchenden Probleme. Auch hierfur
es Werkzeuge, beispielsweise gnats aus dem GNU-Projekt. Aber das sprengt
den Rahmen dieses Buches.
CASE bedeutet Computer Aided Software Engineering. An sich ist das
nichts Neues, beim Programmieren hat man schon immer Computer eingesetzt. Das Neue bei CASE Tools wie SoftBench von Hewlett-Packard besteht
darin, daß die einzelnen Programmierwerkzeuge wie syntaxgesteuerte Editoren, Compiler, Linker, Builder (make(1)), Analysewerkzeuge, Debugger,
Versionskontrollsysteme sowie die Dokumentation unter einer einheitlichen,
¨
heutzutage grafischen Oberflache
– hier das X Window System und Motif zusammengefaßt werden. Allgemein heißt das Ganze Programmier- oder Entwicklungsumgebung (Integrated development environment, IDE). Damit zu
arbeiten ist die moderne Form des Programmierens und kann effektiv sein.
2.2.9
Systemaufrufe
2.2.9.1
Was sind Systemaufrufe?
¨
Dem Programmierer stehen zwei Hilfsmittel17 zur Verfugung,
um seine
¨
¨
Wunsche
auszudrucken:
¨
• die Schlusselw¨
orter (Wortsymbole) der Programmiersprache,
• die Systemaufrufe des Betriebssystems.
¨
¨
Die Schlusselw
orter
(keyword, mot-cl´e) der Programmiersprache (C/C++,
FORTRAN oder PASCAL) sind auch unter verschiedenen Betriebssystemen
(PC-DOS, OS/2 oder UNIX) dieselben. Sie geh¨oren zur Programmiersprache,
das heißt zum Compiler. Die Systemaufrufe (system call, system primitive,
17 Standardfunktionen
schrieben haben.
¨
sind erst verfugbar,
nachdem andere Programmierer sie ge-
62
2 Programmieren in C/C++
¨ alle Programmierfonction syst`eme) eines Betriebssystems (UNIX) sind fur
sprachen (C, FORTRAN, PASCAL, COBOL) dieselben. Sie geh¨oren zum Betriebssystem. Man findet auch die Bezeichnung Kernschnittstellenfunktion,
die besagt, daß ein solcher Aufruf sich unmittelbar an den Kern des Betriebssystems richtet. Der Kreis der Systemaufrufe liegt fest und kann nicht oh¨
ne Eingriffe in den Kern des Betriebssystems verandert
werden. Da UNIX zum großen Teil in C geschrieben ist, sind die Systemaufrufe von UNIX
C-Funktionen, die sich in ihrer Syntax nicht von eigenen oder fremden C¨
Funktionen unterscheiden. Deshalb mussen
auch FORTRAN- oder PASCALProgrammierer etwas von der Programmiersprache C verstehen. Im Handbuch werden die Systemaufrufe in Sektion (2) beschrieben.
Bei POSIX-konformen Betriebssystemen spricht man statt von System¨
aufrufen besser von POSIX-Funktionen, da der POSIX-Standard offen lasst,
¨
ob diese vom Betriebssystem zur Verfugung
gestellten Funktionen als Systemaufrufe oder als Bibliothek verwirklicht sind. Auf jeden Fall geh¨oren sie
zum Betriebssystem, nicht zum Compiler. Die Unterscheidung spielt eine Rol¨ verschiedene Betriebssysteme und/oder Compiler programle, wenn man fur
miert. Der Programmierer muss wissen, woher seine Funktionen stammen.
In Sektion (3) finden sich vorgefertigte Unterprogramme, Subroutinen oder Standardfunktionen (standard function, fonction e´ l´ementaire)
¨ haufig
¨
¨ den Anwender besteht kein Unterfur
vorkommende Aufgaben. Fur
schied zu den Systemaufrufen. Streng genommen geh¨oren diese Standardfunktionen jedoch zu den jeweiligen Programmiersprachen (zum Compiler)
und nicht zum Betriebssystem. Der Kreis der Standardfunktionen ist belie¨
big erganzbar.
Um den Benutzer zu verwirren, sind die Systemaufrufe und
die Standardfunktionen in einer Funktionsbibliothek (/lib/libc.a und andere) vereinigt.
¨
Die Aufgabenverteilung zwischen Schlusselw¨
ortern, Systemaufrufen und
¨
Standardfunktionen ist in gewissem Umfang willkurlich.
Systemaufrufe erledigen Aufgaben, die aus dem Aufbau und den kennzeichnenden Eigenschaf¨
ten des Betriebssystems herruhren,
bei UNIX also in erster Linie
• Ein- und Ausgabe auf unterster Stufe,
• Umgang mit Prozessen,
• Umgang mit dem File-System,
• Sicherheitsvorkehrungen.
¨
Das Offnen
eines Files zum Lesen oder Schreiben ist Sache eines Systemaufrufs (open(2)), Sortieren hingegen Sache einer Standardfunktion
¨
(qsort(3)). Es gibt aber zusatzlich
auch Standardfunktionen zum Umgang mit Files, die den jeweiligen Systemaufruf komfortabel verpacken
(fopen(3)). Nach außen definiert die Menge der Systemaufrufe das Betriebs¨
¨ den
system. Zwei Systeme, die in ihren Aufrufen ubereinstimmen,
sind fur
¨
Benutzer identisch. Neue Funktionalitaten
des Betriebssystems stellen sich
dem Programmierer als neue Systemaufrufe dar, siehe zum Beispiel unter
stream(2).
2.2 Programmer’s Workbench
63
¨
Einige UNIX-Systemaufrufe haben gleiche oder ahnliche
Aufgaben wie
Shell-Kommandos. Wenn man die Zeit wissen m¨ochte, verwendet man im
Dialog das Shell-Kommando date(1). Will man diese Information aus einem eigenen Programm heraus abfragen, greift man auf den Systemaufruf
¨
time(2)18 zuruck.
Das Shell-Kommando ist ein in ein C-Programm verpackter Systemaufruf.
In UNIX sind Systemaufrufe Funktionen der Programmiersprache C. Ei¨
ne Funktion ubernimmt
beim Aufruf Argumente oder Parameter und gibt ein
¨
¨
Ergebnis zuruck. Dieser Mechanismus wird Parameterubergabe
genannt.
Man muß ihn verstanden haben, um Funktionen in eigenen Programmen ver¨
wenden zu k¨onnen. Eine Erklarung
findet sich in Abschnitt 2.4.3 Parameterubergabe
¨
auf Seite 124.
2.2.9.2
Beispiel Systemzeit (time)
Im folgenden Beispiel wird der Systemaufruf time(2) verwendet. time(2)
liefert die Zeit in Sekunden seit 00:00:00 Greenwich Mean Time, 1. Januar
¨
1970. Computeruhren laufen ubrigens
erstaunlich ungenau, falls sie nicht
¨
durch eine Funkuhr oder uber
das Netz synchronisiert werden. Ferner brauchen wir die Standardfunktion gmtime(3), Beschreibung unter ctime(3),
die aus den obigen Sekunden eine Struktur erzeugt, die Datum und Uhrzeit
¨ Die Umrechnung von Greenwich auf Karlsruhe nehmen wir selbst
enthalt.
¨ ein Ruckgriff
¨
vor. Eleganter ware
auf die Zeitzonen-Variable der Umgebung.
Laut Referenz-Handbuch hat time(2) die Syntax
long time ((long *) 0)
Die Funktion verlangt ein Argument vom Typ Pointer auf long integer, und
zwar im einfachsten Fall den Nullpointer. Der Returnwert ist vom Typ long
¨
integer. Der gr¨oßte Wert dieses Typs liegt etwas uber
2 Milliarden. Damit
¨
lauft
diese Uhr etwa 70 Jahre. Die Subroutine gmtime(3) hat die Syntax
#include <time.h>
struct tm *gmtime(clock)
long *clock
Die Funktion gmtime(3) verlangt ein Argument clock vom Typ Pointer auf
¨
long integer. Wir mussen
also den Returnwert von time(2) in einen Pointer
¨
umwandeln (referenzieren). Der Ruckgabewert
der Funktion gmtime(3) ist
ein Pointer auf eine Struktur namens tm. Diese Struktur ist im include-File
time.h definiert. Die include-Files sind lesbarer Text; es ist ratsam hineinzuschauen. In der weiteren Beschreibung zu ctime(3) wird die Struktur tm
¨
erlautert:
struct tm {
int tm_sec;
int tm_min;
18 In
/* seconds (0 - 59) */
/* minutes (0 - 59) */
HP-UX. In ANSI-C ist eine Standardfunktion time(3) enthalten.
64
2 Programmieren in C/C++
int
int
int
int
int
int
int
tm_hour;
tm_mday;
tm_mon;
tm_year;
tm_wday;
tm_yday;
tm_isdst;
/*
/*
/*
/*
/*
/*
/*
hours (0 - 23) */
day of month (1 - 31) */
month of year (0 - 11) */
year - 1900 */
day of week (sunday = 0) */
day of year (0 - 365) */
daylight saving time */
}
Von den beiden letzten Komponenten der Struktur machen wir keinen Gebrauch. Da die Komponenten alle vom selben Typ sind, ist statt der Struktur
auch ein Array denkbar. Vermutlich wollte sich der Programmierer den Weg
¨
offenhalten, kunftig
auch andere Typen aufzunehmen (Zeitzone). Das Pro¨
gramm, das die Quelle zu dem Kommando zeit aus der ersten Ubung
ist,
sieht folgendermaßen aus:
/* Ausgabe der Zeit auf Bildschirm */
/* Compileraufruf cc -o zeit zeit.c */
#include <stdio.h>
#include <time.h>
char *ptag[] = {"Sonntag,
", "Montag,
",
"Dienstag, ", "Mittwoch, ",
"Donnerstag,", "Freitag,
",
"Samstag,
"};
char *pmon[] = {"Januar", "Februar", "Maerz", "April",
"Mai", "Juni", "Juli", "August",
"September", "Oktober", "November",
"Dezember"};
main()
{
long sec, time();
struct tm *gmtime(), *p;
sec = time((long *) 0) + 3600;
/* MEZ = GMT + 3600 */
p = gmtime(&sec);
printf("%s %d. ", ptag[p->tm wday], p->tm mday);
printf("%s %d
", pmon[p->tm mon], p->tm year +1900);
printf("%d:%02d MEZ\n", p->tm hour, p->tm min);
}
Quelle 2.16 : C-Programm zur Anzeige der Systemzeit
Nun wollen wir dieselbe Aufgabe mit einem FORTRAN-Programm
¨
¨ die C-Standardbewaltigen.
Der UNIX-Systemaufruf time(2) bleibt, fur
funktion gmtime(3) suchen wir die entsprechende FORTRAN-Routine. Da
¨
wir keine finden, mussen
wir sie entweder selbst schreiben (was der erfahrene Programmierer scheut) oder nach einem Weg suchen, eine beliebige CStandardfunktion in ein FORTRAN-Programm hineinzuquetschen.
2.2 Programmer’s Workbench
65
Der Systemaufruf time(2) macht keinen Kummer. Er ben¨otigt ein Argument vom Typ Pointer auf long integer, was es in FORTRAN gibt.
¨
Der Ruckgabewert
ist vom Typ long integer, auch kein Problem. Die CStandardfunktion gmtime(3) erwartet ein Argument vom Typ Pointer auf
¨
long integer, was machbar ware,
aber ihr Ergebnis ist ein Pointer auf eine
Struktur. Das hat FORTRAN noch nie gesehen19 . Deshalb weichen wir auf
¨
die C-Standardfunktion ctime(3) aus, deren Ruckgabewert
vom Typ Poin¨
ter auf character ist, was es in FORTRAN naherungsweise
gibt. In FORTRAN
¨
¨
ist ein Zeichen ein String der Lange eins. Strings werden per Deskriptor ubergeben. Ein String-Deskriptor ist der Pointer auf das erste Zeichen und die
Anzahl der Zeichen im String als Integerwert. Das Programm sieht dann so
aus:
program zeit
$ALIAS foratime = ’sprintf’ c
integer*4 time, tloc, sec, ctime
character atime*26
sec = time(tloc)
call foratime(atime, ’%s’//char(0), ctime(sec))
write(6, ’(a)’) atime
end
Quelle 2.17 : FORTRAN-Programm zur Anzeige der Systemzeit
Die ALIAS-Anweisung ist als Erweiterung zu FORTRAN 77 in vielen
Compilern enthalten und dient dazu, den Aufruf von Unterprogrammen anderer Sprachen zu erm¨oglichen. Der Compiler weiß damit, daß das Unterprogramm außerhalb des Programms – zum Beispiel in einer Bibliothek –
einen anderen Namen hat als innerhalb des Programms. Wird eine Sprache
¨
¨ der Syntax dieangegeben (hier C), so erfolgt die Parameterubergabe
gemaß
ser Sprache. Einzelheiten siehe im Falle unserer Anlage im HP FORTRAN
77/HP-UX Reference Manual im Abschnitt Compiler Directives.
Die Anweisung teilt dem Compiler mit, daß hinter der FORTRANSubroutine foratime die C-Standard-Funktion sprintf(3) steckt und daß
¨
diese nach den Regeln von C behandelt werden soll. Der Ruckgabewert
von
sprintf(3) (die Anzahl der ausgegebenen Zeichen) wird nicht verwertet,
deshalb ist foratime eine FORTRAN-Subroutine (keine Funktion), die im
Programm mit call aufgerufen werden muß.
Der Systemaufruf time(2) verlangt als Argument einen Pointer auf
long integer, daher ist tloc als vier Bytes lange Integerzahl deklariert.
¨
tloc spielt weiter keine Rolle. Die Ubergabe
als Pointer (by reference) ist in
¨ Zahlenvariable und braucht nicht eigens vereinbart
FORTRAN Standard fur
19 FORTRAN
90 kennt Strukturen.
66
2 Programmieren in C/C++
¨
zu werden. Der Ruckgabewert
von time geht in die Variable sec vom Typ
long integer = integer*4.
Die call-Zeile ruft die Subroutine foratime alias C-Funktion
sprintf(3) auf. Diese C-Funktion erwartet drei Argumente: den Ausgabestring als Pointer auf char, einen Formatstring als Pointer auf char und
die auszugebende Variable von einem Typ, wie er durch den Formatstring
¨
bezeichnet wird. Der Ruckgabewert
der Funktion ctime(3) ist ein Pointer
¨
auf char. Da dies kein in FORTRAN zulassiger
Typ ist, deklarieren wir die
¨ sich auf
Funktion ersatzweise als vom Typ 4-Byte-integer. Der Pointer laßt
jeden Fall in den vier Bytes unterbringen. Nach unserer Erfahrung reichen
auch zwei Bytes, ebenso funktioniert der Typ logical, nicht jedoch real.
Der Formatstring besteht aus der Stringkonstanten %s, gefolgt von dem
¨ sprintf(3)
ASCII-Zeichen Nr. 0, wie es bei Strings in C Brauch ist. Fur
¨
besagt dieser Formatstring, das dritte Argument – den Ruckgabewert
von
ctime(3) – als einen String aufzufassen, das heißt als Pointer auf das erste
Element eines Arrays of characters.
atime ist ein FORTRAN-String-Deskriptor, dessen erste Komponente ein
Pointer auf character ist. Damit weiß sprintf(3), wohin mit der Ausgabe.
Die write-Zeile ist wieder pures FORTRAN.
An diesem Beispiel erkennen Sie, daß Sie auch als FORTRAN- oder
¨
PASCAL-Programmierer etwas von C verstehen mussen,
um die Systemaufrufe und C-Standardfunktionen syntaktisch richtig zu gebrauchen.
Bei manchen FORTRAN-Compilern (Hewlett-Packard, Microsoft) lassen
sich durch einen einfachen Interface-Aufruf Routinen fremder Sprachen
¨
so verpacken, daß man sie ubernehmen
kann, ohne sich um Einzelheiten
¨
¨
kummern
zu mussen.
2.2.9.3
Beispiel Datei-Informationen (access, stat, open, close)
In einem weiteren Beispiel wollen wir mithilfe von Systemaufrufen In¨
formationen uber
eine Fatei gewinnen, dazu noch eine Angabe aus der
Sitzungsumgebung. Die Teile des Programms lassen sich einfach in andere
¨
C-Programme ubernehmen.
Dieses Programm soll beim Aufruf (zur Laufzeit, in der Kommandozei¨
le) den Namen der Datei als Argument ubernehmen,
wie wir es von UNIXKommandos her kennen. Dazu ist ein bestimmter Formalismus vorgesehen:
int main(int argc, char *argv[], char *envp[])
¨
Die Funktion main() ubernimmt
die Argumente argc, argv und gegebenenfalls envp. Das Argument argc ist der Argument Counter, eine Ganzzahl.
Sie ist gleich der Anzahl der Argumente in der Kommandozeile beim Aufruf
des Programms. Das Kommando selbst ist das erste Argument, also hat argc
mindestens den Wert 1. Das Argument argv ist der Argument Vector, ein
Array of Strings, also ein Array of Arrays of Characters. Der erste String, Index 0, ist das Kommando; die weiteren Strings sind die mit dem Kommando
2.2 Programmer’s Workbench
67
¨
ubergebenen
Argumente, hier der Name des gefragten Files. Der Environment Pointer envp wird nur ben¨otigt, falls man Werte aus der Umgebung
abfragt. Es ist wie argv ein Array of Strings. Die Namen argc, argv und
¨
¨
envp sind willkurlich,
aber ublich.
Typ und Reihenfolge sind vorgegeben.
Die Umgebung besteht aus Strings (mit Kommando set (Shell) anschauen). In der for-Schleife werden die Strings nacheinander mittels der
Funktion strncmp(3) (siehe string(3)) mit dem String LOGNAME verglichen. Das Ergebnis ist der Index i des gesuchten Strings im Array envp[].
Den Systemaufruf access(2) finden wir in der Sektion (2) des ReferenzHandbuches. Er untersucht die Zugriffsm¨oglichkeiten auf ein File und hat die
Syntax
int access(char *path, int mode)
¨
Der Systemaufruf erwartet als erstes Argument einen String, namlich
den
¨ argv[1] einsetzen. Als zweites steht
Namen des Files. Wir werden hierfur
eine Ganzzahl, die die Art des gefragten Zugriffs kennzeichnet. Falls der ge¨
fragte Zugriff m¨oglich ist, liefert access(2) den Wert null zuruck,
der in
einem C-Programm zugleich die Bedeutung von logisch falsch (FALSE) hat
und deshalb in den if-Zeilen negiert wird.
Den Systemaufruf stat(2) finden wir ebenfalls in Sektion 2. Er ermittelt
Fileinformationen aus der Inode und hat die Syntax
#include <sys/types.h>
#include <sys/stat.h>
int stat(path, buf)
char *path;
struct stat *buf;
Sein erstes Argument ist wieder der Filename, das zweite der Name eines Puffers zur Aufnahme einer Struktur, die die Informatio¨
nen enthalt.
Diese Struktur vom Typ stat ist in dem include-File
/usr/include/sys/stat.h deklariert, das seinerseits Bezug nimmt auf
Deklarationen in /usr/include/types.h. Auch einige Informationen wie
S_IFREG sind in sys/stat.h definiert. Die Zeitangaben werden wie im vorigen Abschnitt umgerechnet.
¨ jedes File am Anfang eine Magic NumIn UNIX-File-Systemen enthalt
¨
ber, die uber
die Art des Files Auskunft gibt (man magic). Mittels des Systemaufrufs open(2) wird das fragliche File zum Lesen ge¨offnet, mittels
lseek(2) der Lesezeiger auf die Magic Number gesetzt und mittels read(2)
die Zahl gelesen. Der Systemaufruf close(2) schließt das File wieder. Die
¨
Systemaufrufe findet man unter ihren Namen in Sektion (2), eine Erlauterung der Magic Numbers unter magic(4). Nun das Programm:
/* Informationen ueber eine Datei */
#define
MEZ 3600
68
2 Programmieren in C/C++
#include
#include
#include
#include
#include
#include
<stdio.h>
<sys/types.h>
<sys/stat.h>
<time.h>
<fcntl.h>
<magic.h>
void exit(); long lseek();
int main(argc, argv, envp)
int argc; char *argv[], *envp[];
{
int i, fildes;
struct stat buffer;
long asec, msec, csec;
struct tm *pa, *pm, *pc;
if (argc < 2) {
puts("Dateiname fehlt"); return (-1);
}
/* Informationen aus dem Environment */
for (i = 0; envp[i] != NULL; i++)
if (!(strncmp(envp[i], "LOGNAME", 4)))
printf("\n%s\n", envp[i]);
/* Informationen mittels Systemaufruf access(2) */
printf("\nFile heisst: %8s\n", argv[1]);
if (!access(argv[1], 0))
puts("File existiert");
else
puts("File existiert nicht");
if (!access(argv[1], 1))
puts("File darf ausgefuehrt werden");
else
puts("File darf nicht ausgefuehrt werden");
if (!access(argv[1], 2))
puts("File darf beschrieben werden");
else
puts("File darf nicht beschrieben werden");
if (!access(argv[1], 4))
puts("File darf gelesen werden");
else
puts("File darf nicht gelesen werden");
2.2 Programmer’s Workbench
/* Informationen aus der Inode, Systemaufruf stat(2) */
if (!(stat(argv[1], &buffer))) {
printf("\nDevice:
%ld\n", buffer.st dev);
printf("Inode-Nr.:
%lu\n", buffer.st ino);
printf("File Mode:
%hu\n\n", buffer.st mode);
switch(buffer.st mode & S IFMT) {
case S IFREG:
{
puts("File ist regulaer");
break;
}
case S IFDIR:
{
puts("File ist ein Verzeichnis");
break;
}
case S IFCHR:
case S IFBLK:
case S IFNWK:
{
puts("File ist ein Special File");
break;
}
case S IFIFO:
{
puts("File ist eine Pipe");
break;
}
default:
{
puts("Filetyp unbekannt (Inode)");
}
}
printf("\nLinks:
%hd\n", buffer.st nlink);
printf("Owner-ID:
%hu\n", buffer.st uid);
printf("Group-Id:
%hu\n", buffer.st gid);
printf("Device-ID:
%ld\n", buffer.st rdev);
printf("Filegroesse:
%ld\n", buffer.st size);
asec = buffer.st atime + MEZ; pa = gmtime(&asec);
msec = buffer.st mtime + MEZ; pm = gmtime(&msec);
csec = buffer.st ctime + MEZ; pc = gmtime(&csec);
printf("Letzter Zugriff: %d. %d. %d\n",
pa->tm mday, pa->tm mon + 1, pa->tm year);
printf("Letzte Modifik.: %d. %d. %d\n",
pm->tm mday, pm->tm mon + 1, pm->tm year);
printf("Letzte Stat.Ae.: %d. %d. %d\n",
pc->tm mday, pc->tm mon + 1, pc->tm year);
}
69
70
2 Programmieren in C/C++
else
puts("Kein Zugriff auf Inode");
/* Pruefung auf Text oder Code (magic number) */
/* Systemaufrufe open(2), lseek(2), read(2), close(2) */
/* Magic Numbers siehe magic(4) */
{
MAGIC
magbuf;
fildes = open(argv[1], O RDONLY);
if (lseek(fildes, MAGIC OFFSET, 0) >= (long)0) {
read(fildes, &magbuf, sizeof magbuf);
switch(magbuf.file type) {
case RELOC MAGIC:
{
puts("File ist relocatable");
break;
}
case EXEC MAGIC:
case SHARE MAGIC:
case DEMAND MAGIC:
{
puts("File ist executable");
break;
}
case DL MAGIC:
case SHL MAGIC:
{
puts("File ist Library");
break;
}
default:
puts("Filetyp unbekannt (Magic Number)");
lseek(fildes, 0L, 0);
}
}
else {
puts("Probleme mit dem Filepointer");
}
}
close(fildes);
}
¨
Quelle 2.18 : C-Programm zum Abfragen von Informationen uber
ein File
Die Verwendung von Systemaufrufen oder Standardfunktionen in CProgrammen ist nicht schwieriger als der Gebrauch anderer Funktionen.
Man muß sich nur an die im Referenz-Handbuch Sektionen (2) und (3) nachzulesende Syntax halten. Es empfiehlt sich, die genannten Sektionen einmal
¨
¨ es Systemdurchzublattern,
um eine Vorstellung davon zu gewinnen, wofur
aufrufe und Standardfunktionen gibt. Die Ausgabe des Programms sieht fol-
2.2 Programmer’s Workbench
71
gendermaßen aus:
LOGNAME=wualex1
File
File
File
File
File
heisst:
a.out
existiert
darf ausgefuehrt werden.
darf nicht beschrieben werden.
darf gelesen werden.
Device:
Inode-Nr.:
File Mode:
13
43787
33216
File ist regulaer
Links:
Owner-ID:
Group-ID:
Device-ID:
Filegroesse:
Letzter Zugriff:
Letzte Modifik.:
Letzte Stat.Ae.:
File ist executable
1
101
20
102536
53248
24. 1. 91
24. 1. 91
24. 1. 91
Die Bedeutung von File Mode finden Sie bei mknod(2). Es handelt sich um
¨
¨
¨
¨
ausfuhrliche
Informationen uber
die Zugriffsrechte usw. Ahnliche
Auskunfte
¨
uber
ein File liefert das Kommando chatr(1).
2.2.9.4
Beispiel Prozesserzeugung (exec, fork)
¨
Zunachst
ein kleines, aber fieses Programm namens forkbomb, mit dem man
die Robustheit seines Systems auf die Probe stellen kann.
(kommt demnaechst)
Quelle 2.19 : C-Programm zum Erzeugen vieler Prozesse (Fork-Bombe)
Der Systemaufruf fork(2) erzeugt eine Kopie des aufrufenden Prozesses
mit einer neuen Prozess-ID. Im Beispiel wird fork(2) in einer ewigen forSchleife aufgerufen.
2.2.10
Begriffe Programmer’s Workbench
Folgende Begriffe sollten klarer geworden sein:
• Archiv, Bibliothek
72
2 Programmieren in C/C++
• Builder (make)
• Debugger
• Linker
• Profiler
¨
• Quelltext oder -code, ausfuhrbarer
Code
¨
• Ubersetzer,
Compiler, Interpreter
• Systemaufruf – Standardfunktion
• Versionsverwaltung
Folgende Kommandos sollten beherrscht werden:
• cc oder gcc
• lint
¨
• Anfange
von make
¨
• Anfange
von RCS (ci, co)
2.2.11
Memo Programmer’s Workbench
• Die Programmquellen werden mit einem Editor geschrieben.
¨
¨ sich die syntaktische Richtigkeit
• Mit dem Syntaxprufer
lint(1) laßt
¨
von C-Programmen prufen,
leider nicht die von C++-Programmen.
• Schon bei kleinen Programmierprojekten ist das Werkzeug make(1)
dringend zu empfehlen. Der Compileraufruf vereinfacht sich wesentlich.
¨ Texte verwendbar.
Auch fur
• Mit einem Compiler wird der Quellcode in den Maschinencode des je¨
weiligen Prozessors ubersetzt.
• Der schwerste Hammer bei der Fehlersuche ist ein Debugger, lern¨
bedurftig,
aber nicht immer vermeidbar.
• Programmfunktionen (aber auch andere Dateien) lassen sich in Bibliotheken archivieren, die bequemer zu handhaben sind als eine Menge
von einzelnen Funktionen.
• Bei gr¨oßeren Projekten kommt man nicht um ein Kontrollsystem wie
RCS oder CVS herum, vor allem dann, wenn mehrere Personen beteiligt
sind. Das Lernen kostet Zeit, die aber beim Ringen mit dem Chaos mehr
als wettgemacht wird.
• CASE-Tools vereinigen die einzelnen Werkzeuge unter einer gemeinsa¨
men Benutzeroberflache.
Der Programmierer braucht gar nicht mehr zu
wissen, was ein Compiler ist.
• Systemaufrufe sind die Verbindungen des Betriebssystems nach oben,
zu den Anwendungsprogrammen hin. Sie sind Teil des Betriebssystems.
2.2 Programmer’s Workbench
73
• Systemaufrufe haben vorwiegend mit Prozessen, den Datei-Systemen
und der Ein- und Ausgabe zu tun.
• UNIX-Systemaufrufe sind C-Funktionen, die sich im Gebrauch nicht
von anderen C-Funktionen unterscheiden.
• C-Standardfunktionen geh¨oren zum C-Compiler, nicht zum Betriebssystem.
• Ein FORTRAN-Programmierer auf einem UNIX-System ist auf
die UNIX-Systemaufrufe angewiesen, nicht aber auf die C¨ gibt es FORTRAN-Standardfunktionen).
Standardfunktionen (dafur
¨ jede andere Programmiersprache.
Dasselbe gilt fur
2.2.12
¨
Ubung
Programmer’s Workbench
¨
Anmelden wie gewohnt. Zum Uben
brauchen wir ein kleines Programm mit
bestimmten Fehlern. Legen Sie mit mkdir prog ein Unterverzeichnis prog
an, wechseln Sie mit cd prog dorthin und geben Sie mit vi fehler.c folgendes C-Programm (ohne den Kommentar) unter dem Namen fehler.c
ein:
/* Uebungsprogramm mit mehreren Fehlern */
/* 1. Fehler: Es wird eine symbolische Konstante PI
definiert, die nicht gebraucht wird. Dieser Fehler
hat keine Auswirkungen und wird von keinem
Programm bemerkt.
2. Fehler: Eine Ganzzahl-Variable d wird deklariert,
aber nicht gebraucht. Dieser Fehler hat keine
Auswirkungen, wird aber von lint beanstandet.
3. Fehler: Die Funktion scanf verlangt Pointer als
Argument, es muss &a heissen. Heimtueckischer
Syntaxfehler. lint gibt eine irrefuehrende Warnung
aus, der Compiler merkt nichts. Zur Laufzeit ein
memory fault.
4. Fehler: Es wird durch nichts verhindert, dass fuer
b eine Null eingegeben wird. Das kann zu einem
Laufzeitfehler fuehren, wird weder von lint noch
vom Compiler bemerkt.
5. Fehler: Es sollte die Summe ausgerechnet werden,
nicht der Quotient. Logischer Fehler, wird weder
von lint noch vom Compiler bemerkt.
6. Fehler: Abschliessende Klammer fehlt. Syntaxfehler,
wird von lint und Compiler beanstandet.
Darueberhinaus spricht lint noch Hinweise bezueglich
main, printf und scanf aus. Diese Funktionen sind
aber in Ordnung, Warnungen ueberhoeren. */
#define PI 3.14159
#include <stdio.h>
74
2 Programmieren in C/C++
int main()
{
int a, b, c, d;
puts("Bitte
scanf("%d",
puts("Bitte
scanf("%d",
c = a / b;
printf("Die
1. Summanden eingeben: ");
a);
2. Summanden eingeben: ");
&b);
Summe ist: %d\n", c);
Quelle 2.20 : C-Programm mit Fehlern
¨
Als erstes lassen wir den Syntaxprufer
lint(1) auf das Programm los:
lint fehler.c
und erhalten das Ergebnis:
fehler.c
==============
(36) warning: a may be used before set
(41) syntax error
(41) warning: main() returns random value to environment
==============
function returns value which is always ignored
printf
scanf
Zeile 41 ist das Programmende, dort steckt ein Fehler. Die Warnungen sind
¨
nicht so dringend. Mit dem vi(1) erganzen
wir die fehlende geschweif¨
te Klammer am Schluß. Der Fehler hatte
uns eigentlich nicht unterlaufen
¨
¨
durfen,
da der vi(1) eine Hilfe zur Klammerprufung
bietet (Prozentzeichen).
Neuer Lauf von lint(1):
fehler.c
==============
(36) warning: a may be used before set
(33) warning: d unused in function main
(41) warning: main() returns random value to environment
==============
function returns value which is always ignored
printf
scanf
¨
¨
Wir werfen die uberfl
ussige
Variable d in der Deklaration heraus. Nochmals
lint(1).
2.2 Programmer’s Workbench
75
fehler.c
==============
(36) warning: a may be used before set
(41) warning: main() returns random value to environment
==============
function returns value which is always ignored
printf
scanf
¨
Jetzt ignorieren wir die Warnung von lint(1) bezuglich
der Variablen a (ob¨
wohl heimtuckischer
Fehler, aber das ahnen wir noch nicht). Wir lassen kompilieren und rufen das kompilierte Programm a.out(4) auf:
cc fehler.c
a.out
Der Compiler hat nichts zu beanstanden. Ersten Summanden eingeben, Antwort: memory fault oder Bus error - core dumped. Debugger20 einsetzen, dazu nochmals mit der Option -g und dem vom Debugger verwendeten
Objektfile /usr/lib/xdbend.o kompilieren und anschließend laufen lassen,
um einen aktuellen Speicherauszug (Coredump) zu erzeugen:
cc -g fehler.c /usr/lib/xdbend.o
chmod 700 a.out
a.out
xdb
¨
¨
Standardmaßig
greift der Debugger auf die ausfuhrbare
Datei a.out(4) und
¨
das beim Zusammenbruch erzeugte Corefile core(4) zuruck.
Er promptet
¨
¨
mit >. Wir wahlen
mit der Eingabe s Einzelschritt-Ausfuhrung.
Mehrmals
mit RETURN weitergehen, bis Aufforderung zur Eingabe von a kommt (kein
¨ a eingeben. Fehlermeldung des Debuggers
Prompt). Irgendeinen Wert fur
Bus error. Wir holen uns weitere Informationen vom Debugger:
T
s
q
(stack viewing)
(Einzelschritt)
(quit)
Nachdem wir wissen, daß der Fehler nach der Eingabe von a auftritt, schauen
wir uns die Zeile mit scanf( ..., a) an und bemerken, daß wir der Funkti¨
on scanf(3) eine Variable statt eines Pointers ubergeben
haben (man scanf
oder im Anhang nachlesen). Wir ersetzen also a durch &a. Das Compilieren erleichtern wir uns durch make(1). Wir schreiben eine Datei namens
makefile mit folgenden Zeilen:
fehler: fehler.c
cc fehler.c -o fehler
20 Real
programmers can read core dumps.
76
2 Programmieren in C/C++
und rufen anschließend nur noch das Kommando make(1) ohne Argumente
¨
auf. Das Ergebnis ist ein lauffahiges
Programm mit Namen fehler. Der Auf¨
ruf von fehler fuhrt
bei sinnvollen Eingaben zu einer Ausgabe, die richtig
sein k¨onnte. Wir haben aber noch einen Denkfehler darin. Statt der Summe wird der Integer-Quotient berechnet. Wir berichtigen auch das und testen das Programm mit einigen Eingaben. Da unser Quelltext richtig zu sein
¨
¨
scheint, versch¨onern wir seine vorlaufig
endgultige
Fassung mit dem Beautifier cb(1):
cb fehler.c > fehler.b
rm fehler.c
mv fehler.b fehler.c
Schließlich l¨oschen wir das nicht mehr ben¨otigte Corefile und untersuchen
das Programm noch mit einigen Werkzeugen:
time fehler
cflow fehler.c
cxref fehler.c
strings fehler
nm fehler
size fehler
ls -l fehler
strip fehler
ls -l fehler
¨
strings(1) ist ein ziemlich dummes Werkzeug, das aus einer ausfuhrbaren
Datei alles heraussucht, was nach String aussieht. Das Werkzeug nm(1) gibt
eine Liste aller Symbole aus, die lang werden kann. strip(1) wirft aus einer
¨
¨ den Debugger, nicht aber fur
¨ die Ausfuhrung
¨
ausfuhrbaren
Datei die nur fur
¨
wichtigen Informationen heraus und verkurzt
dadurch die Datei. Abmelden
mit exit.
Schreiben Sie in einer Programmiersprache Ihrer Wahl (ich empfehle C)
ein Programm, das
• eine Datei mittels creat(2) erzeugt,
• dessen Zugriffsrechte mittels chmod(2) und seine Zeitstempel mittels
utime(2) setzt,
• die verwendeten Werte mittels fprintf(3) als Text in die Datei
schreibt. fprintf(3) finden Sie unter printf(3).
¨
Schreiben Sie ein Programm ahnlich
who(1). Sie brauchen dazu getut(3)
und utmp(4).
2.2.13
Fragen Programmer’s Workbench
• Wozu braucht man einen Compiler? Einen Linker?
• Was ist lint?
2.3 Bausteine eines Quelltextes
77
• Was macht make? Wie sieht ein einfaches Makefile aus?
• Wozu braucht man Debugger?
• Was ist eine Funktionsbibliothek? Vorteil?
• Wozu braucht man eine Versionsverwaltung? Wie benutzt man RCS?
• Was sind Systemaufrufe? Wer braucht sie?
• Unterschied zu Standardfunktionen?
¨
• Welche Aufgaben erledigen die Systemaufrufe hauptsachlich?
2.3
2.3.1
Bausteine eines Quelltextes
¨
Ubersicht
Alle Zeichen oder Zeichengruppen eines Programmes im Quellcode sind entweder
• Kommentar (comment),
• Namen (identifier),
¨
• Schlusselw¨
orter (Wortsymbole) (keyword),
• Operatoren (operator),
• Konstanten (Literale) (constant, literal),
• Trennzeichen (separator) oder
• bedeutungslos.
Ein Quelltext (Programmquelle, Source) ist ein Textfile, bestehend aus Zeilen, diese wiederum aus druck- und sichtbaren Zeichen (fast immer des USASCII-Zeichensatzes) einschließlich des Zwischenraums (space). Die Zeichen
sind zu W¨ortern gruppiert, die durch Trennzeichen voneinander abgetrennt
sind, meist durch mindestens einen Zwischenraum. Zeilen werden durch das
Zeilenende markiert, meist durch die ASCII-Zeichen CR und/oder LF. Sinneinheiten wie W¨orter, Zahlen oder Operatoren werden als Token bezeichnet,
¨
sie durfen
nicht durch Trennzeichen oder Zeilenwechsel unterbrochen werden.
¨ den menschlichen Leser bestimmt und gelangt
Kommentar ist nur fur
¨
in C/C++ gar nicht bis zum Ubersetzungsvorgang,
sondern wird schon vom
¨
Praprozessor
entfernt und kann bis auf seine Begrenzungen frei gestal¨
tet werden. Ebenso entfernt der Praprozessor
das Zeichenpaar BackslashZeilenwechsel und verbindet somit zwei Zeilen. Auf diese Weise lassen sich
¨
¨
lange Anweisungen auf mehrere Zeilen verteilen. Schlusselw
orter
und
Operatoren sind festgelegte Zeichen oder Zeichengruppen, an die jeder gebunden ist. Namen werden nach gewissen Regeln vom Programmierer gebildet, ebenso Konstanten. Trennzeichen trennen die genannten Bausteine
78
2 Programmieren in C/C++
oder ganze Anweisungen voneinander und sind festgelegt, meist Leerzeichen
¨
¨
(space), Semikolons und Linefeeds. Bedeutungslose Zeichen sind uberz
ahlige
Leerzeichen, Tabs oder Linefeeds.
¨
Der C-Standard – gegenwartig
ISO/IEC 9899:1999 – legt nicht alle Einzelheiten fest. Zu manchen Fragen spricht er nur Empfehlungen aus oder
¨
¨
¨
uberl
asst
sogar die Wahl dem Compiler und/oder dem Betriebssystem. Gerat
man an solche Probleme, braucht man eine genaue Beschreibung der beiden,
¨
¨
sollte experimentell prufen,
was geschieht, und sein Programm ausfuhrlich
kommentieren.
2.3.2
Syntax-Diagramme
Die Syntax der einzelnen Bausteine – das heißt ihr regelgerechter Gebrauch
¨
– kann mittels Text beschrieben werden. Das ist oft umstandlich
und teilweise schwer zu verstehen. Deshalb nimmt man Beispiele zu Hilfe, die aber
¨
selten die Syntax vollstandig
erfassen. So haben sich Syntax-Diagramme
¨
¨
eingeburgert,
die nach etwas Ubung
leicht zu lesen sind. In Abb. 2.3 auf Sei¨
te 79 ist die Syntax zweier C-Bausteine dargestellt, namlich
die if-elseAnweisung und den Block. Die if-else-Anweisung besteht aus:
¨
• dem Schlusselwort
if,
• einer o¨ ffnenden runden Klammer,
• einem booleschen Ausdruck (true – false),
• einer schließenden runden Klammer,
• einer Anweisung – auch die leere Anweisung – oder einem Block,
• dann ist entweder Ende der if-Anweisung oder es folgt
¨
• das Schlusselwort
else, gefolgt von
• einer Anweisung oder einem Block.
¨
Ist der boolesche Ausdruck true, dann wird die erste Anweisung ausgefuhrt,
andernfalls die zweite. Fehlt der else-Zweig, so liegt eine bedingte Anwei¨
sung vor, die nur dann ausgefuhrt
wird, wenn der boolesche Ausdruck true
ist. Danach geht es im Programm weiter.
Ein Block seinerseits besteht aus:
• einer o¨ ffnenden geschweiften Klammer,
• dann entweder nichts (leerer Block) oder
• einer Anweisung,
• gegebenenfalls weiteren Anweisungen,
• und einer schließenden geschweiften Klammer.
Da ein Block syntaktisch gleichwertig einer Anweisung ist, lassen sich Bl¨ocke
¨
schachteln. Ein Block kann uberall
stehen, wo eine Anweisung erwartet wird.
2.3 Bausteine eines Quelltextes
79
if-else-Anweisung
- if - (
- bool. - )
- Anw.
Ausdr.
Block
6
- else - Anw.
Block
Block - { - Anweisung ? } 6
Abb. 2.3: Syntax-Diagramm der if-else-Anweisung und des Blockes
Ein weiterer Weg zur Beschreibung der Syntax einer Programmierspra¨
che ist die Backus-Naur-Form, die von J OHN B ACKUS, einem der Vater
von
¨
FORTRAN, und P ETER N AUR, einem der Vater
von ALGOL, als Metasprache
zu ALGOL 60 entwickelt worden ist. Weiteres siehe bei D. G RIES.
2.3.3
Kommentar
¨
Alle Programmiersprachen erm¨oglichen, Text in ein Programm einzufugen,
¨
¨ den menschlichen Leser beder vom Compiler uberlesen
wird und nur fur
stimmt ist. Dieser Kommentar muss mit einem besonderen Zeichen eingeleitet und gegebenenfalls beendet werden.
In C/C++ leitet die Zeichengruppe /* den Kommentar ein. Er kann sich
¨
uber
mehrere Zeilen erstrecken, darf aber nicht geschachtelt werden. Zu einer
ungewollten Schachtelung kommt es, wenn man kommentierte Programm¨
teile durch Einrahmen mit Kommentarzeichen vorubergehend
unwirksam
macht. Die Fehlermeldung des Compilers sagt irgendetwas mit Pointern und
¨
fuhrt
irre. Die Zeichengruppe */ kennzeichnet das Ende. Ein Zeilenende be¨
endet diesen Kommentar nicht. Ansonsten kann Kommentar uberall
stehen,
nicht nur auf einer eigenen Zeile. Ein Beispiel:
/*
Die ersten Zeilen enthalten Programmnamen, Zweck, Autor,
Datum, Compiler, Literatur und aehnliches.
*/
#include <stdio.h>
int main()
80
2 Programmieren in C/C++
{
/* Dies ist eine eigene Kommentarzeile */
puts("Erste Zeile");
puts("Zweite Zeile");
/* Kommentar */
/* Kommentar */
puts("Dritte Zeile");
/*
puts("Vierte Zeile");
*/
/* Kommentar geschachtelt!!! */
puts("Ende");
return 0;
}
Quelle 2.21 : C-Programm mit Kommentaren
¨
Auf unserem System haben wir folgende Regel eingefuhrt:
da Fehlermeldungen des Systems in Englisch ausgegeben werden, schreiben wir die
Meldungen unserer Programme in Deutsch (man sollte sie ohnedies mittels
#define-Anweisungen irgendwo zusammenfassen, so dass sie leicht ausgetauscht werden k¨onnen). Damit sieht man sofort, woher eine Meldung
stammt. Kommentar schreiben wir wieder in Englisch, da die Programmbeispiele auch per Mail oder News in die unendlichen Weiten des Internet
geschickt werden, wo Englisch nun einmal die lingua franca ist. An Kommentar21 soll man nicht sparen, denn er kostet wenig Aufwand und kann viel
¨
helfen, wahrend
die Dokumentation zum Programm nur zu oft ad calendas
Graecas (Sankt-Nimmerleins-Tag) verschoben wird.
In C++ kommt eine weitere Art von Kommentar hinzu. Er beginnt mit
¨
zwei Schragstrichen
und endet mit dem Zeilenwechsel, weshalb er Zeilenkommentar genannt wird. Dieser Kommentar darf innerhalb des oben ge¨
nannten Kommentars vorkommen. Die umgekehrte Folge ist auch zulassig,
aber selten anzutreffen.
2.3.4
Namen
Namen (identifier) bezeichnen Funktionen, Konstanten, Variable, Makros
¨
oder Sprungmarken (Labels). Sie mussen
mit einem Buchstaben oder einem
Unterstrich (underscore) beginnen. Benutzereigene Namen sollten immer mit
einem Buchstaben anfangen, der Unterstrich als erstes Zeichen wird vom
Compiler oder vom System verwendet. Die weiteren Zeichen des Namens
k¨onnen Buchstaben, Ziffern oder der Unterstrich sein. Groß- und Kleinbuch¨
¨
staben werden unterschieden. Die maximal zulassige
Lange
von Namen kann
durch den Compiler, den Linker oder das Bestriebssystem gegeben sein und
¨
lasst
sich daher nicht allgemein angeben. Ab 255 Zeichen wird es kritisch.
Signifikant sind mindestens die ersten sieben Zeichen, nach ANSI die ersten
einunddreißig. Verwendet man Funktionen fremder Herkunft, sollte man mit
21 Real
programmers don’t comment their code.
2.3 Bausteine eines Quelltextes
81
nur sechs signifikanten Zeichen rechnen sowie damit, dass Groß- und Kleinbuchstaben nicht unterschieden werden.
2.3.5
¨
¨
Schlusselw
orter
In C/C++ wie in jeder anderen Programmiersprache haben bestimmte W¨orter
eine besondere Bedeutung, beispielsweise main, while und if. Diese Wort22
¨
¨
¨
symbole oder Schlusselw
orter
durfen
auf keinen Fall als Namen verwendet werden, die Namen der Standardfunktionen wie printf() oder fopen()
sollen nicht umfunktioniert werden. C zeichnet sich durch eine geringe An¨
zahl von Schlusselw¨
ortern aus, etwa dreißig, siehe Anhang D.1 C-Lexikon,
Schlusselw¨
¨
orter auf Seite 280. Mit C++ kommen nochmal dreißig dazu. Un¨ Schlusselw¨
¨
terboten wird C/C++ darin nur von SMALLTALK mit funf
ortern.
2.3.6
Operanden
¨
Wir schranken
hier den Begriff Daten etwas ein und verstehen darunter nur
die passiven Objekte, mit denen ein Programm etwas tut, also Text, Zahlen,
Grafiken usw. Diese Objekte und ihre Untereinheiten nennen wir Operan¨
den (operand). Mit ihnen werden Operationen durchgefuhrt.
Das Wort Objekt23 vermeide ich hier, um keine Assoziationen an objektorientiertes Programmieren zu wecken. Ein Operand
• hat einen Namen (identifier),
• geh¨ort einem Typ (type) an,
• hat einen konstanten oder variablen Wert (value),
• belegt zur Laufzeit Speicherplatz im Computer,
• hat einen Geltungsbereich (scope) und
• eine Lebensdauer (lifetime).
¨
Auf den Operanden wird uber
den Namen oder die Speicheradresse zugegriffen. Die Speicheradresse eines Operanden kann in einem weiteren Operanden abgelegt werden, der Zeiger, Referenz, Adressvariable oder Pointer
genannt wird. Ich bevorzuge das englische Wort Pointer, weil das deutsche
22 Es
¨
gibt die Bezeichnungen Wortsymbol, Schlusselwort
und reserviertes Wort. Gemeint ist in jedem Fall, dass das Wort – eine bestimmte Zeichenfolge – nicht unein¨
¨
geschrankt
als Namen verwendet werden darf. In C durfen
diese W¨orter – außer im
¨ einen anderen als ihren besonderen Zweck verwendet
Kommentar – keinesfalls fur
¨
¨
werden. In FORTRAN durfen
diese W¨orter in Zusammenhangen,
die eine Deutung
¨
als Schlusselwort
ausschließen, auch als Namen verwendet werden. Man darf also
eine Variable if nennen, und in der Zuweisung if = 3 wird die Zeichenfolge if als
Variable und nicht als Wortsymbol im Sinne von falls verstanden.
23 K ERNIGHAN + R ITCHIE gebrauchen Objekt im Sinne eines Speicherbereiches,
auf den mittels eines Namens zugegriffen wird.
82
2 Programmieren in C/C++
Wort Zeiger drei Bedeutungen hat: Pointer, Index, Cursor. Außerdem bezeich¨
ne ich Pointer nicht als Variable, obwohl ihr Wert veranderlich
ist. Wer das
englische Wort nicht mag, sollte von Adressvariablen reden. Pointer auf Pointer sind Pointer 2. Ordnung usw. Der Geltungsbereich eines Operanden ist
ein Block, eine Funktion, ein File oder das ganze Programm. Gleiches gilt
¨ die Lebensdauer. In der Deklaration eines Operanden werden sein Nafur
¨ er einen
me und seine Eigenschaften vereinbart. In der Definition erhalt
¨
Wert und ben¨otigt spatestens
dann einen Platz im Arbeitsspeicher. Deklaration und Definition k¨onnen in einer Anweisung zusammengezogen sein. Die
erstmalige Zuweisung eines Wertes an eine Variable heißt Initialisierung.
Deklaration und Definition werden auch unter dem Begriff Vereinbarung
zusammengefasst.
Auf die Auswahl und Strukturierung der Operanden soll man Sorgfalt ver¨
wenden. Eine zweckmaßige
Datenstruktur erleichtert das Programmieren
¨
¨
¨
und fuhrt
zu besseren Programmen. Eine nachtragliche
Anderung
der Datenstruktur erfordert meist einen großen Aufwand, weil viele Programme oder
Programmteile davon betroffen sind. Die Namen der Operanden sollen ihre
¨
Bedeutung erklaren,
erforderlichenfalls ist ihre Bedeutung im Kommentar
¨
oder in einer Aufzahlung
festzuhalten.
2.3.6.1
Konstanten und Variable
¨
Operanden k¨onnen wahrend
des Ablaufs eines Programmes konstant blei¨
ben (wie die Zahl π) oder sich andern
(wie die Anzahl der Iterationen zur
L¨osung einer Gleichung oder das Ergebnis einer Berechnung oder Textsuche).
¨ einen Programmaufruf konstant ist,
Es kommt auch vor, dass ein Operand fur
¨
beim nachsten
Aufruf aber einen anderen Wert hat (wie der Mehrwertsteuersatz).
¨
Man tut gut, samtliche
Operanden eines Programmes an wenigen Stellen
zusammenzufassen und zu deklarieren. In den Funktionen oder Prozeduren
sollen keine geheimnisvollen Zahlen (magic numbers) auftauchen, sondern
¨
nur Namen. Konstanten, die im Programm uber
ihren Namen aufgerufen
werden, heißen symbolische Konstanten.
¨ den Computer sind Konstanten Bestandteil des Programmcodes, das
Fur
unter UNIX in das Codesegment des zugeh¨origen Prozesses kopiert und vor
¨
schreibenden Zugriffen geschutzt
wird. Diese Konstanten werden auch Lite¨
rale genannt. Variable hingegen belegen Speicherplatze
im User Data Segment, deren Adressen das Programm kennt und auf die es lesend und schreibend zugreift.
In ANSI-C sind die Typ-Attribute (type qualifier) const und volatile
¨
eingefuhrt
worden, die eine bestimmte Behandlung der zugeh¨origen Operanden erzwingen. Sie werden selten gebraucht.
2.3.6.2
Typen – Grundbegriffe
¨
Jeder Operand geh¨ort einem Typ an, der uber
2.3 Bausteine eines Quelltextes
83
• den Wertebereich (siehe /usr/include/limits.h),
¨
• die zulassigen
Operationen,
• den Speicherbedarf
entscheidet. Die Typen werden in drei Gruppen eingeteilt:
• einfache, skalare oder elementare Typen
• zusammengesetzte oder strukturierte Typen
• Pointer (Adressvariable)
In C gibt es nur konstante Typen, das heißt, ein Operand, der einmal als
¨
ganzzahlig deklariert worden ist, bleibt dies wahrend
des ganzen Programmes. Einige Programmiersprachen erlauben auch variable Typen, die erst zur
¨
¨
Laufzeit bestimmt werden oder sich wahrend
dieser andern.
Typfreie Sprachen kennen nur das Byte oder das Maschinenwort als Datentyp. Die Typisierung24 erleichtert die Arbeit und erh¨oht die Sicherheit sowie die Rechen¨
geschwindigkeit. Stellen Sie sich vor, Sie mussten
bei Gleitkommazahlen Exponent und Mantisse jedesmal selbst aus den Bytes herausdr¨oseln. Oder der
¨
Computer musste
jedesmal aus dem Zusammenhang einer Operation ermit¨ einen Typ von Operanden es sich handelt. Es gibt aber auch
teln, um was fur
Aufgaben, bei denen der Verzicht auf eine Typisierung Vorteile bringt. Oft ist
das bei Aufgaben der Fall, die mittels Skriptsprachen bearbeitet werden.
Die Typdeklarationen in C/C++ k¨onnen ziemlich schwierig zu verstehen
¨
sein, vor allem bei mangelnder Ubung.
Im Netz findet sich ein Programm
¨
¨
cdecl, das Typdeklarationen in einfaches Englisch ubersetzt.
Futtert
man
dem Programm folgende Deklaration:
char (*(*x[3]) ()) [5]
¨ man zur Antwort:
so erhalt
declare x as array 3 of pointer to function returning
pointer to array 5 of char
¨
So schnell wie cdecl hatte
ich die Antwort nicht gefunden.
2.3.6.3
Einfache Typen
In jeder Programmiersprache gibt es Grundtypen, aus denen alle h¨oheren
Typen zusammengesetzt werden. In C/C++ sind dies ganze Zahlen, Gleitkommazahlen und Zeichen.
24 Real
programmers don’t worry about types.
84
2 Programmieren in C/C++
Ganze Zahlen In C/C++ gibt es ganze Zahlen mit oder ohne Vorzeichen
¨
sowie in halber, einfacher oder doppelter Lange:
• int ganze Zahl mit Vorzeichen
• unsigned int ganze Zahl ohne Vorzeichen
• short kurze ganze Zahl mit Vorzeichen
• unsigned short kurze ganze Zahl ohne Vorzeichen
¨
• long ganze Zahl doppelter Lange
mit Vorzeichen
¨
• unsigned long ganze Zahl doppelter Lange
ohne Vorzeichen
Die Deklaration von Variablen als ganzzahlig sieht so aus:
int x, y, z;
unsigned long anzahl;
¨
Die Lange
der ganzen Zahlen in Bytes ist nicht festgelegt und beim Portieren
¨
zu beachten. Haufig
sind int und long gleich und belegen ein Maschinenwort, auf unserer Anlage also 4 Bytes gleich 32 Bits (32-Bit-Architektur).
Festgelegt ist nur die Reihenfolge:
char <= short <= int <= long
¨
Alle Annahmen, die daruber
hinausgehen, sind Vermutungen, die auf einer
Maschine zutreffen, auf einer anderen nicht. Auch die Annahme, dass die
Typen int und Pointer immer gleich viele Bytes belegen, ist schierer Aberglaube.
¨
Mit dem Aufkommen von 64-Bit-Maschinen ist die Diskussion der Lange
¨
von Datentypen neu entfacht. Beim Ubergang
von 16 auf 32 Bit gegen Ende
der siebziger Jahre waren der Kreis der UNIX- und C-Programmierer und damit das ganze Problem wesentlich kleiner als heute. Wenn 128-Bit-Maschinen
die Regel werden, wird sich die Diskussion nochmals wiederholen, allerdings
¨
aufbauend auf den Erfahrungen des gegenwartigen
Wechsels. Das Ziel sind
¨
Programme, die unabhangig
von der Datengr¨oße auf allen Architekturen laufen, und Daten, die zwischen verschiedenen Architekturen ausgetauscht werden k¨onnen.
Datentyp
char
short
int
long
Pointer
LP32
2/4/4
8
16
16
32
32
ILP32 ILP64 LLP64
4/4/4
8/8/8
4/4/8
8
8
8
16
16
16
32
64
32
32
64
32
32
64
64
LP64
4/8/8
8
16
32
64
64
¨
Tabelle 2.1: Lange
von Datentypen auf verschiedenen Architekturen
2.3 Bausteine eines Quelltextes
85
¨
Je nach Lange
der Datentypen int (I), long (L) und Pointer (P) unter¨
scheidet man heute die in Tabelle 2.1 auf Seite 84 aufgefuhrten
Architektu¨
¨
ren. Es wurde
zu weit fuhren,
hier die Vor- und Nachteile jeder Architektur
¨
gegeneinander abzuwagen.
Wichtig ist, die Architektur der eigenen Maschine
zu kennen (in unserem Fall ILP32) und die Programme m¨oglichst portabel zu
gestalten. Hierzu Empfehlungen im Abschnitt 2.13 Portieren von Programmen auf Seite 250.
¨ ganze Zahlen sind die Addition, die Subtraktion, die Multiplikation,
Fur
¨
die Modulo-Operation (Divisionsrest) und die Division unter Vernachlassigung des Divisionsrestes definiert, ferner Vergleiche mittels gr¨oßer – gleich
– kleiner.
Gleitkommazahlen Gleitkommazahlen – auch als Reals oder Floating
Point Numbers bezeichnet – werden durch eine Mantisse und einen Exponenten dargestellt. Der Exponent versteht sich nach außen zur Basis 10,
intern wird die Basis 2 verwendet. Die Mantisse ist auf eine Stelle ungleich 0
vor dem Dezimalkomma oder -punkt normiert. Es gibt:
• float Gleitkommazahl einfacher Genauigkeit
• double Gleitkommazahl doppelter Genauigkeit
• long double Gleitkommazahl noch h¨oherer Genauigkeit (extended
precision)
Die Deklaration von Gleitkomma-Variablen sieht so aus:
float x, y, z;
double geschwindigkeit;
Gleitkommazahlen haben immer ein Vorzeichen. Man beachte, daß die Typen
sich nicht nur in ihrem Wertebereich, sondern auch in ihrer Genauigkeit (Anzahl der signifikanten Stellen) unterscheiden, anders als bei Ganzzahlen. Der
Typ long double ist selten.
¨ Gleitkommazahlen sind die Addition, die Subtraktion, die MultiplikaFur
¨
tion, die Division sowie Vergleiche zulassig.
Die Abfrage auf Gleichheit ist
jedoch heikel, da aufgrund von Rundungsfehlern zwei Gleitkommazahlen
selten gleich sind. Wenn m¨oglich, mache man um Gleitkommazahlen einen
¨
¨
großen Bogen. Die Operationen dauern langer
als die entsprechenden fur
Ganzzahlen, und die Auswirkungen von Rundungsfehlern sind schwierig
¨
abzuschatzen.
Zur internen Darstellung von Gleitkommazahlen siehe Abschnitt ?? Arithmetikprozessoren auf Seite ??.
Alphanumerischer Typ Eine Gr¨oße, deren Wertevorrat die Zeichen der
ASCII-Tabelle oder einer anderen Tabelle sind, ist vom Typ alphanumerisch oder character, bezeichnet mit char. In C werden sie durch eine Inte¨
gerzahl zwischen 0 und 127 (7-bit-Zeichensatze)
beziehungsweise 255 (8-bit¨
¨ ein Byte. Mittlerweile
Zeichensatze)
dargestellt. Der Speicherbedarf betragt
¨
gibt es auch internationale Zeichensatze,
deren Zeichen je zwei Bytes belegen.
Die Deklaration von alphanumerischen Variablen sieht so aus:
86
2 Programmieren in C/C++
char a, b, c;
¨
Mit wachsender Verbreitung von 16-bit-Zeichensatzen
(Unicode, Intercode)
¨
ist zu erwarten, dass die Lange
des char-Typs angepasst wird.
Die Verwandtschaft zwischen Ganzzahlen und Zeichen in C verwirrt anfangs. Man mache sich die Gemeinsamkeiten an einem kleinen Programm
klar:
/* Programm zum Demonstrieren von character und integer */
#include <stdio.h>
int main()
{
int i, j, k; char a, b;
i = 65; j = 233; k = 333; a = ’B’; b = ’!’;
printf("Ganzzahlen: %d
printf("Zeichen
: %c
puts("Nun rechnen
printf("%c + %c =
printf("%c - %c =
printf("%c - %c =
%d
%c
%d
%c
%d\n", i, j, k, a);
%c\n", i, j, k, a);
wir mit Zeichen (B = 66, ! = 33):");
%d\n", a, b, a + b);
%d\n", b, a, b - a);
%c\n", b, a, b - a);
return 0;
}
Quelle 2.22 : C-Programm mit den Typen character und integer
Die Ausgabe des Programms lautet:
Ganzzahlen: 65 233 333 66
Zeichen
: A
M B
Nun rechnen wir mit Zeichen (B = 66, ! = 33):
B + ! = 99
! - B = -33
! - B =
In der ersten Zeile werden alle Werte entsprechend dem Formatstring der
Funktion printf(3) als dezimale Ganzzahlen ausgegeben, wobei der Buchstabe B durch seine ASCII-Nummer 66 vertreten ist. In der zweiten Zeile
werden alle Werte als 7-bit-ASCII-Zeichen verstanden, wobei die Zahlen, die
mehr als 7 Bit (> 127) beanspruchen, nach 7 Bit links abgeschnitten wer¨
den. Die Zahl 233 fuhrt
so zur Ausgabe des Zeichens Nr. 233 - 128 = 105.
Die Zahl - 33 wird als Zeichen Nr. 128 - 33 = 95, dem Unterstrich, ausgegeben. Wie man an der Rechnung erkennt, werden Zeichen vom Prozessor
wie ganze Zahlen behandelt und erst bei der Ausgabe einer Zahl oder einem
ASCII-Zeichen zugeordnet. Es ist zu erwarten, daß auf Systemen mit 8-bit¨
oder 16-bit-Zeichensatzen
die Grenze h¨oher liegt, aber die Arbeitsweise bleibt.
2.3 Bausteine eines Quelltextes
87
Manchmal will man ein Byte wahlweise als Ganzzahl oder als Zeichen auffas¨
sen, aber das geh¨ort zu den beruchtigten
Tricks in C. Meint man den Buchstaben a, sollte man auch ’a’ schreiben, denn der Gebrauch der Nummer 97
anstelle des Zeichens setzt voraus, dass das System, auf dem das Programm
¨
¨
ausgefuhrt
wird, den ASCII-Zeichensatz verwendet, womit die Portabilitat
¨
des Programms eingeschrankt
wird.
¨ empfangt
¨
Das Ausgabegerat
nur die Nummer des auszugebenden Zei¨ seiner Zeichensatz-Tabelle (ASCII, ROMAN8), die Umwandlung
chens gemaß
des Wertes entsprechend seinem Typ ist Aufgabe der Funktion printf(3).
Boolescher Typ Eine Gr¨oße vom Typ boolean oder logical kann nur
die Werte true (wahr, richtig) oder false (falsch) annehmen. In C werden
statt des booleschen Typs die Integerwerte 0 (= false) und nicht-0 (= true)
verwendet. Verwirrend ist, dass viele Funktionen bei Erfolg den Wert 0 und
¨
bei Fehlern Werte ungleich 0 zuruckgeben.
Leerer Typ Der leere Datentyp void wird zum Deklarieren von Funktio¨
nen verwendet, die kein Ergebnis zuruckliefern,
sowie zum Erzeugen generi¨
scher (allgemeiner) Pointer, die auf Variablen eines vorlaufig
beliebigen Typs
zeigen. Der Typ hat keine Gr¨oße. Der Bytebedarf eines Pointers dagegen
liegt fest, auch wenn der zugeh¨orige Variablentyp noch offen ist. Zur PointerArithmetik muss jedoch der Typ (das heißt der Bytebedarf der zugeh¨origen
Variablen) bekannt sein. Variablen vom Typ void lassen sich nicht verarbei¨
ten, weil sie nicht existieren. Man bezeichnet den Typ void als unvollstandig,
¨
¨
da er nicht alle Fahigkeiten
eines vollstandigen
Typs wie int aufweist. Man
¨
¨
¨
braucht diesen schragen
Typ aus ahnlichen
Grunden
wie die leere Menge in
der Mathematik.
¨ generische Pointer der Typ
Vor der Erfindung des Typs void wurde fur
char genommen, der ein Byte umfasst, woraus sich alle anderen Typen zu¨
sammensetzen lassen. Man hatte
den Typ auch byte nennen k¨onnen.
2.3.6.4
Zusammengesetzte Typen (Arrays, Strukturen)
Arrays Die meisten Programmiersprachen kennen Arrays, auch als Vek¨
toren oder unglucklicherweise
als Felder25 bezeichnet; das sind geordnete
Mengen von Gr¨oßen desselben Typs. Jedem Element ist ein fortlaufender Index (Hausnummer) zugeordnet, der in C stets mit 0 beginnt. In einem Array
¨
von zw¨olf Elementen lauft
also der Index von 0 bis 11, aufpassen.
¨
Elemente eines Arrays durfen
Konstanten oder Variable aller einfachen
Typen, andere Arrays, Strukturen, Unions oder Pointer sein, jedoch keine
Funktionen. Files sind formal Strukturen, ein Array von Files ist also erlaubt.
Die Deklaration von Arrays sieht folgendermaßen aus:
int zahlen[100], nr[12];
int matrix[4][3];
25 Felder
¨
in Datensatzen
sind etwas v¨ollig anderes.
88
2 Programmieren in C/C++
double realnumbers[1000];
char names[33];
char zeichen[] = "abcd";
Der Compiler muss die Gr¨oße eines Arrays (Anzahl und Typ der Elemente)
wissen. Sie muss bereits im Programm stehen und kann nicht erst zur Laufzeit errechnet werden. Man kann jedoch die Gr¨oße eines Arrays zur Laufzeit
¨
mittels der Standardfunktion malloc(3) andern,
siehe Abschnitt 2.11.9 Dynamische Speicherverwaltung auf Seite 232.
Es gibt mehrdimensionale Arrays (Matrizen usw.) mit entsprechend vielen
Indexfolgen. Die Elemente werden im Speicher hintereinander in der Weise
¨
abgelegt, dass sich der letzte Index am schnellsten andert.
Der Compiler linearisiert das Array, wie man sagt. Eine Matrix wird zeilenweise gespeichert.
¨
¨
Vorsicht beim Ubertragen
von oder nach FORTRAN: dort lauft
die Indizierung anders als in C/C++, eine Matrix wird spaltenweise gespeichert. PAS¨ sich wie C/C++.
CAL verhalt
Der Name eines Arrays ist eine Adresskonstante und kann daher nicht
auf der linken Seite einer Zuweisung vorkommen. Weiteres dazu im Abschnitt 2.3.6.7 Pointer auf Seite 91.
Strings (Zeichenketten) In C/C++ sind Strings oder Zeichenketten
(chaine de caract`eres) Arrays of characters, abgeschlossen durch das ASCIIZeichen Nr. 0 (nicht zu verwechseln mit der Ziffer 0 entsprechend ASCII¨
Nr. 48). Strings durfen
nicht beliebig lang werden. Wenn nicht Arbeitsspeicher, Editor oder andere Faktoren vorher zuschlagen, muss man ab 32 kByte
auf Probleme gefasst sein, wohlgmerkt beim einzelnen String, nicht bei einem aus vielen Strings bestehenden Text. Man st¨oßt selten an diese Grenze,
¨
¨
deshalb wird sie in vielen Buchern
nicht erwahnt.
Wir bevorzugen das Wort String um hervorzuheben, dass es sich hierbei
um Zeichenfolgen in einem bestimmten, sprachenspezifischen Format handelt. Zum Speichern des Strings Alex ist ein Array of characters mit wenig¨ Elementen zu deklarieren:
stens funf
char myname[5];
¨
In anderen Sprachen werden Strings anders dargestellt. Ein String lasst
sich
¨ verarbeiten oder durch Zugriff auf seine Elemente. Man kann feram Stuck
tige String-Funktionen verwenden oder eigene Funktionen schreiben, muss
¨
sich dann aber auch selbst um die ASCII-Null kummern.
Will man bei der Eingabe von Werten mittels der Tastatur jeden beliebigen Unsinn zulassen, dann muss man die Eingaben als lange (einige Zeilen)
¨
¨
¨
Strings ubernehmen,
die Strings prufen
und dann – sofern sie vernunftig
sind
¨
– in den gewunschten
Typ umwandeln. Ein gutes Programm vertraut Ein¨ sie vor der weiteren Verarbeitung
gaben niemals blindlings, sondern pruft
¨
grundlich.
Ein Programmbeispiel dazu findet sich im Abschnitt 2.11.7.2 Pointer auf Typ void: xread.c auf Seite 220.
2.3 Bausteine eines Quelltextes
89
¨
Merke: Es gibt Arrays of characters, die keine Strings sind, namlich
solche,
¨
die nicht mit dem ASCII-Zeichen Nr. 0 abgeschlossen sind. Sie mussen
als
Array angesprochen werden wie ein Array von Zahlen.
Merke zweitens: Ein einzelnes Zeichen kann als Zeichen (character, ’a’)
¨ ein Prooder als String (array of characters, "a") dargestellt werden. Fur
gramm sind das verschiedene Dinge.
Strukturen Eine Struktur, auch als Verbund und in PASCAL als Record bezeichnet, vereint Komponenten ungleichen Typs im Gegensatz zum
Array. Eine Ordnung der Komponenten liegt nicht vor, ebenfalls anders als
¨
beim Array. Strukturen durfen
geschachtelt werden, aber nicht sich selbst
enthalten (keine Rekursion). M¨oglich ist jedoch, dass eine Struktur einen
¨ – ein Pointer ist ja nicht die Struktur selbst
Pointer auf sich selbst enthalt
¨
– womit Verkettungen hergestellt werden. Das Schlusselwort
lautet struct.
¨ eine Struktur ist eine Personal- oder MitgliederEin typisches Beispiel fur
liste, bestehend aus alphanumerischen und numerischen Komponenten. Mit
den numerischen wird gerechnet, auf die alphanumerischen werden Stringfunktionen angewendet. Telefonnummern oder Postleitzahlen sind alphanumerische Gr¨oßen, da Rechenoperationen mit ihnen sinnlos sind. Wir erzeugen
einen Strukturtyp ohne eigenen Namen und deklarieren zugleich eine Variable namens mitglied:
struct {
char nachname[32];
char vorname[32];
int beitrag;
} Mitglied;
Man kann auch zuerst nur die Struktur definieren und in einem zweiten
Schritt Variablen vom Typ dieser Struktur:
struct mg {
char nachname[32];
char vorname[32];
int beitrag;
};
struct mg Mitglied;
Jedes File ist eine Struktur namens FILE, die in dem include-File
stdio.h deklariert ist:
typedef struct {
int
_cnt;
unsigned char
unsigned char
short
_flag;
char
_file;
} FILE;
*_ptr;
*_base;
90
2 Programmieren in C/C++
Mit dieser typedef-Deklaration wird ein Strukturname FILE vereinbart, der
in weiteren Deklarationen als Typ auftritt. FILE ist keine Variable, sondern
¨ obige Struktur. Anschließend lassen sich Variable vom Typ
ein Synonym fur
FILE oder auch Filepointer deklarieren:
FILE myfile, yourfile;
FILE *fp;
Dies ist ein dritter Weg, den wir im Abschnitt Weitere Namen fur
¨ Typen auf
Seite 97 kennenlernen.
In C/C++ sind alle Files ungegliederte Folgen von Bytes (Bytestreams), so
dass es keinen Unterschied zwischen Textfiles und sonstigen Files gibt. Die
Gliederung erzeugt das lesende oder schreibende Programm. Anders als in
PASCAL ist daher der Typ FILE nicht ein FILE of irgendetwas.
Eine besondere Struktur ist das Bitfeld. Die Strukturkomponenten sind
¨
einzelne Bits oder Gruppen von Bits, die uber
ihren Komponentennamen angesprochen werden. Eine Bitfeld-Struktur darf keine weiteren Komponenten
enthalten und soll m¨oglichst vom Basistyp unsigned sein. Ein einzelnes Bit¨
feld darf maximal die Lange
eines Maschinenwortes haben, es kann also nicht
¨
uber
eine Wortgrenze hinausragen. Bitfelder sind keine Arrays, es gibt keinen
Index. Ebensowenig lassen sich Bitfelder referenzieren (&-Operator). Bitfelder werden verwendet, um mehrere Ja-nein-Angaben in einem Wort unterzubringen.
Der Name einer Strukturvariablen ist ein gew¨ohnlicher Variablenname,
kein Pointer.
2.3.6.5
Union
Eine Variable des Typs union kann Werte unterschiedlichen Typs aufnehmen, zu einem Zeitpunkt jedoch immer nur einen. Es liegt in der Hand des
¨
¨
Programms, uber
den augenblicklichen Typ Buch zu fuhren.
In FORTRAN
dient die equivalence-Anweisung demselben Zweck, in PASCAL der variante
¨
Record. Eine Union belegt so viele Bytes wie der langste
in ihr untergebrachte
Datentyp. Die Deklaration einer Variablen als Union sieht aus wie bei einer
Struktur:
union unioneins {
int i;
double x;
char c;
} ux;
Damit wird ein Unionstyp mit dem Namen unioneins deklariert und zugleich eine Variable ux dieses Typs. Auf die jeweilige Variable wird zugegriffen wie auf die Komponenten einer Struktur:
printf("%d\n", ux.i);
printf("%f\n", ux.x);
printf("%c\n", ux.c);
2.3 Bausteine eines Quelltextes
91
Man darf nur jeweils die Variable herausholen, die als letzte hineingesteckt
¨
worden ist, andernfalls gibt es Uberraschungen.
Die Union habe ich noch nie
¨ sigebraucht, sie soll in der Systemprogrammierung vorkommen und tragt
cher nicht zur Klarheit eines Programmes bei.
2.3.6.6
¨
Aufzahlungstypen
¨
Durch Aufzahlen
lassen sich benutzereigene Typen schaffen. Denkbar ist:
enum wochentag {montag, dienstag, mittwoch, donnerstag,
freitag, samstag, sonntag} tag;
¨
Die Variable tag ist vom Typ wochentag und kann die oben aufgezahl¨ Vergleiten Werte annehmen. Die Reihenfolge der Werte ist maßgebend fur
¨ einen
che: montag ist kleiner als dienstag. Auch Farben bieten sich fur
¨
¨
Aufzahlungstyp
an. In der Maschine werden Aufzahlungstypen
durch Ganzzahlen dargestellt, insofern handelt es sich nicht um einen neuen Typ.
¨
Aufzahlungstypen
verbessern die Lesbarkeit der Programme.
2.3.6.7
Pointer (Zeiger)
Pointer sind vom Geheimnis umwittert. Wer mit Pointern umgehen kann
¨ uber
¨
¨
(oder wenigstens so tut), verfugt
magische Krafte
und steht mit finsteren
¨
Machten
im Bunde. Vermutlich frisst er auch kleine Kinder oder unschuldige
Windows-Benutzer. Dabei ist das Arbeiten mit Pointern einfach, man muss
nur langsam und klar denken und saubere Begriffe verwenden.
¨
Pointer erweitern die M¨oglichkeiten des Programmierers. Ein Beispiel fur
¨
den sinnvollen Einsatz von Pointern: das Sortieren von Datensatzen.
Die Da¨
tensatze
enthalten in Form einer Struktur Namen, Anschrift und weitere An¨
gaben zu Personen. Die Datensatze
sollen nach dem Namen sortiert werden,
¨
¨
um einen schnellen Zugriff zu erm¨oglichen. Wurden
wir die Datensatze
nach
¨
¨
¨ das
Hinzufugen
oder L¨oschen einzelner Satze
jedesmal neu sortieren, so ware
mit viel Kopierarbeit verbunden. Stattdessen legt man ein Hilfsfile, einen In¨
dex an, der nur die Sortierschlussel
(Namen) und die Speicheradressen (Poin¨
¨ Dieser Index wird sortiert, was mit
ter) der zugeh¨origen Datensatze
enthalt.
¨
¨
wesentlich weniger Kopierarbeit verbunden ist, weil die Satze
kurzer
sind.
¨
Suche ich nun nach einem Datensatz mit einem bestimmten Schlussel,
so
gehe ich in den sortierten Index, suche dort m¨oglichst geschickt nach dem
¨
¨
Schlussel
und springe dann zu der bei dem Schlussel
stehenden Speicheradresse des Datensatzes. Ich kann auch zwei Indexfiles mit verschiedenen
¨
¨
¨
SortierschLusseln
(Namen, Geburtstag) anlegen, wahrend
die Datensatze
be¨
stenfalls nach einem einzigen Schlussel
sortiert sein k¨onnen. Meistens ver¨
zichtet man darauf, die Datensatze
zu sortieren. Der dritte Band von D ONALD
E. K NUTH befasst sich nur mit Suchen und Sortieren, ein interessantes Gebiet. Jeder versteht die Aufgaben, die L¨osungen k¨onnen trickreich sein.
¨
Ein weiteres Einsatzgebiet von Pointern ist die Parameterubergabe
von
Funktionen, siehe Abschnitt 2.4.3 Parameterubergabe
¨
auf Seite 124. Und
92
2 Programmieren in C/C++
¨
schließlich k¨onnen C-Funktionen nur einen einzigen Wert zuruckgeben.
Setzt
sich ihr Ergebnis aus mehreren Werten zusammen – wie bei einem String
¨
oder einem Vektor – so geht das nur uber
einen Pointer auf das erste Element
des Ergebnisses.
Auf Variablen kann mittels ihres Namens oder ihrer Speicheradresse
(Hausnummer) zugegriffen werden. Die Speicheradresse braucht nicht absolut oder relativ zu einem Anfangswert bekannt zu sein, sondern ist wiederum
¨
uber
einen Namen ansprechbar, den Namen eines Pointers. Genaugenom¨ den Programmierer
men geh¨oren die Adressen zur Hardware und sind fur
¨
fast immer bedeutungslos, wahrend
die Pointer Operanden der Programmiersprache sind, denen zur Laufzeit als Wert Adressen zugewiesen werden. Deshalb werden sie auch als Adressvariable26 bezeichnet. Pointer haben Namen, Adressen sind hexadezimale Zahlen. Das Arbeiten mit Adressen beziehungsweise Pointern erlaubt gelegentlich eine elegante Programmierung, ist
¨
¨
manchmal unvermeidlich und im ubrigen
alter
als die Verwendung von Va¨
riablennamen. Man muss nur stets sorgfaltig
die Variable von ihrem Pointer
unterscheiden. Wenn man Arrays von Pointern auf Strings verwaltet, wird
¨
das schnell unubersichtlich.
Es ist gute Praxis, aber nicht zwingend, Pointernamen mit einem p beginnen oder aufh¨oren zu lassen.
Ein Pointer ist immer ein Pointer auf einen Variablentyp, unter
¨
Umstanden
auf einen weiteren Pointer. Typlose Pointer gibt es nicht in C27 .
Der Wert eines Pointers ist keine Ganzzahl (int) und darf nicht wie eine Ganzzahl behandelt werden, obwohl letzten Endes die Speicheradressen
¨
(Hausnummern) ganze Zahlen sind. Die zulassigen,
sinnvollen Operationen
sind andere als bei ganzen Zahlen. Hausnummern sind Zahlen, die Multiplikation zweier Hausnummern ist m¨oglich, ergibt jedoch nichts Sinnvolles.
Genauso ist es mit Pointern.
Aus einem Variablennamen x entsteht der Pointer auf die Variable &x
durch Voransetzen des Referenzierungsoperators &. Umgekehrt wird aus
dem Pointer p die zugeh¨orige Variable *p durch Voransetzen des Dereferenzierungsoperators *. Referenziert werden kann nur ein Objekt im Speicher,
also eine Variable, aber nicht ein Ausdruck oder eine Konstante28 . Dereferenziert werden kann nur ein Pointer, der bereits auf ein Objekt im Speicher
¨ Eine Speicheradresse belegt
verweist, der also eine Speicheradresse enthalt.
ein Objekt erst, wenn es definiert ist (einen Wert hat), nicht schon mit der
¨
Deklaration. Folgende Zeilen sind zulassig
beziehungsweise nicht:
int x = 12, *py;
*py = x;
py = &x;
26 Es
/* zu frueh, unzulaessig
*/
¨
¨
gibt naturlich
auch Adresskonstanten, deren Wert wahrend
des Programmablaufs – von der Initialisierung abgesehen – konstant bleibt.
27 Der in ANSI-C eingefuhrte
¨
¨
Pointer auf den Typ void ist ein Pointer, der zunachst
auf keinen bestimmten Typ zeigt.
28 Konstanten sind Teil des Programmcodes.
2.3 Bausteine eines Quelltextes
*py = x;
printf("%d
93
/* erlaubt, aber ueberfluessig */
%d\n", x, *py);
Wir deklarieren eine Variable x als ganzzahlig und weisen ihr zugleich einen
Wert zu. Sie ist damit definiert und belegt einen Speicherplatz. Ferner deklarieren wir py als Pointer auf eine Ganzzahl. Der erste Versuch, py zu derefe¨ und fuhrt
¨
renzieren, ist verfruht
zu einem t¨odlichen Bus Error, da noch kein
Objekt y definiert ist, dessen Adresse der Pointer py enthalten k¨onnte. Der
Pointer ist deklariert, aber nicht definiert. Wohl aber kann ich die deklarierte
und definierte Variable x referenzieren und ihre Adresse dem Pointer py zu¨ auch er einen Wert – und zwar die Adresse von x – und
weisen. Damit enthalt
darf beliebig weiterverwendet werden. Ausgegeben wird zweimal der Wert 12.
¨
¨
Die Zuweisung des Wertes von x an *py ist uberfl
ussig,
da py auf die Adresse zeigt, unter der x abgelegt ist. Das Beispiel verdeutlicht den Unterschied
zwischen Deklaration und Definition und zeigt, dass man eine Variable – genauso einen Pointer – außer auf der linken Seite einer Zuweisung erst dann
verwenden darf, wenn sie einen Wert hat.
Der Name von Arrays ist die Adresskonstante ihres ersten Elementes
(Index 0). Die Bezeichnung des Arraynamens als Pointer ist nicht korrekt,
¨
aber gebrauchlich.
Pointer als (Adress-)Variable k¨onnen auf der linken Seite einer Zuweisung auftauchen, ein Arrayname ist wie jede Konstante als
Linkswert ungeeignet. Der Name von Funktionen ohne das Klammernpaar
ist die Adresskonstante mit der Einsprungadresse der Funktion, auf die erste
¨
ausfuhrbare
Anweisung.
Ein Pointer, der auf die Adresse NULL verweist, wird Nullpointer genannt
¨
und zeigt auf kein gultiges
Datenobjekt. Wie im richtigen Leben gibt es keine
Hausnummer Null. Sein Auftreten kennzeichnet eine Ausnahme oder einen
Fehler. Der Wert NULL ist der einzige, der direkt einem Pointer zugewiesen
werden kann; jede Zuweisung einer Ganzzahl ist ein Fehler, da Pointer keine
¨
Ganzzahlen sind. Ansonsten durfen
nur Werte, die sich aus einer Pointeroperation oder einer entsprechenden Funktion (deren Ergebnis ein Pointer ist)
einem Pointer zugewiesen werden.
¨ Pointer sind die Operationen Inkrementieren, Dekrementieren und
Fur
¨
¨
Vergleichen zulassig.
Die Multiplikation zweier Pointer durfen
Sie versuchen,
es kommt aber nichts Brauchbares heraus, meist ein Laufzeitfehler (memory fault). Inkrementieren bedeutet Erh¨ohung um eine oder mehrere Einheiten des Typs, auf den der Pointer verweist. Dekrementieren entsprechend ei¨
ne Verminderung. Sie brauchen nicht zu berucksichtigen,
um wieviele Bytes
es geht, das weiß der Compiler aufgrund der Deklaration. Diese PointerArithmetik erleichtert das Programmieren erheblich; in typlosen Sprachen
¨
muss man Bytes zahlen.
Wir wollen anhand einiger Beispiele mit Arrays den Gebrauch von Pointern verdeutlichen und deklarieren ein eindimensionales Array von vier
Ganzzahlen:
int a[4];
94
2 Programmieren in C/C++
¨ sich allein ist der Pointer (Pointerkonstante) auf den Anfang
Der Name a fur
des Arrays. Es sei mit den Zahlen 4, 7, 1 und 2 besetzt. Dann hat es folgenden
Aufbau:
Pointer
a
a+1
a+2
a+3
−→
−→
−→
−→
Speicher
4
7
1
2
Variable = Wert
∗a = a[0] = 4
∗(a + 1) = a[1] = 7
∗(a + 2) = a[2] = 1
∗(a + 3) = a[3] = 2
Der Pfeil ist zu lesen als zeigt auf oder ist die Adresse von. Der Wert des
Pointers a – die Adresse also, unter der die Zahl 4 abgelegt ist – ist irgendei¨
ne kaum verstandliche
und v¨ollig belanglose Hexadezimalzahl. Der Wert der
¨
Variablen a[0] hingegen ist 4 und das aus Grunden,
die im wirklichen Le¨
ben zu suchen sind. Ein Zugriff auf das nicht deklarierte Element a[4] fuhrt
¨
spatestens
zur Laufzeit auf einen Fehler. Bei der Deklaration des Arrays muss
¨
¨
seine Lange
bekannt sein. Spater,
wenn es nur um den Typ geht – wie bei der
¨
Parameterubergabe
– reicht die Angabe int *a.
Ein String ist ein Array von Zeichen (characters), abgeschlossen mit dem
unsichtbaren ASCII-Zeichen Nr. 0, hier dargestellt durch ⊗. Infolgedessen
¨
¨
muss das Array immer ein Element langer
sein als der String Zeichen enthalt.
Wir deklarieren einen ausreichend langen String und belegen ihn gleichzeitig
mit dem Wort UNIX:
char s[6] = "UNIX";
¨
Die Langenangabe
6 k¨onnte entfallen, da der Compiler aufgrund der Zuwei¨
sung der Stringkonstanten die Lange
weiß. Der String ist unn¨otig lang, aber
¨
vielleicht wollen wir spater
ein anderes Wort darin unterbringen. Das Array
sieht dann so aus:
Pointer (Adresse)
s
−→
s+1
−→
s+2
−→
s+3
−→
s+4
−→
s+5
−→
Speicher
U
N
I
X
⊗
??
Wert (Variable)
∗s = s[0] = U
∗(s + 1) = s[1] = N
∗(s + 2) = s[2] = I
∗(s + 3) = s[3] = X
∗(s + 4) = s[4] = ⊗
∗(s + 5) = s[5] =??
Die Fragezeichen deuten an, dass diese Speicherstelle nicht mit einem bestimmten Wert belegt ist. Der Zugriff ist erlaubt; was darin steht, ist nicht
abzusehen. Man darf nicht davon ausgehen, dass Strings immer mit Spaces
initialisiert werden oder Zahlen mit Null.
Wir deklarieren nun ein zweidimensionales Array von Ganzzahlen, eine
nichtquadratische Matrix:
2.3 Bausteine eines Quelltextes
95
int a[3][4];
die mit folgenden Werten belegt sei:


1 2 3 4

7 8 
 5 6

9 10 11 12
Im Arbeitsspeicher steht dann folgendes:
Pointer 2.
a
−→
−→
−→
−→
a+1
−→
−→
−→
−→
a+2
−→
−→
−→
−→
Pointer 1.
a[0]
−→
a[0] + 1 −→
a[0] + 2 −→
a[0] + 3 −→
a[1]
−→
a[1] + 1 −→
a[1] + 2 −→
a[1] + 3 −→
a[2]
−→
a[2] + 1 −→
a[2] + 2 −→
a[2] + 3 −→
Speicher
1
2
3
4
5
6
7
8
9
10
11
12
Wert (Variable)
∗ ∗ a = ∗a[0] = a[0][0] = 1
∗(a[0] + 1) = a[0][1] = 2
∗(a[0] + 2) = a[0][2] = 3
∗(a[0] + 3) = a[0][3] = 4
∗a[1] = a[1][0] = 5
∗(a[1] + 1) = a[1][1] = 6
∗(a[1] + 2) = a[1][2] = 7
∗(a[1] + 3) = a[1][3] = 8
∗a[2] = a[2][0] = 9
∗(a[2] + 1) = a[2][1] = 10
∗(a[2] + 2) = a[2][2] = 11
∗(a[2] + 3) = a[2][3] = 12
Der Pointer 2. Ordnung a zeigt auf ein Array aus 3 Pointern 1. Ordnung a[0],
a[1] und a[2]. Die Pointer 1. Ordnung a[0], a[1] und a[2] zeigen ihrerseits
auf 3 Arrays bestehend aus je 4 Ganzzahlen. Gespeichert sind 12 Ganzzahlen, die Pointer 1. Ordnung sind nicht gespeichert. Da die Elemente allesamt
gleich groß sind (gleich viele Bytes lang), hindert uns nichts daran, das Ele¨
ment a[1][2], namlich
die Zahl 7, als Element a[0][6] aufzufassen. Die gespeicherten Werte lassen sich auch als eindimensionales Array b[12] verste¨
¨
hen. Solche Tricks mussen
sorgfaltig
kommentiert werden, sonst blickt man
nach kurzer Zeit nicht mehr durch und Außenstehende nie. Versuchen Sie, an
Hand obigen Schemas folgende Behauptungen nachzuvollziehen:
∗∗(a+1) = 5(a+1) = a[0]+4 = a[1](∗(a+2)−1) = 8(∗(a+1)+1) = ∗(a[1]+1) = 6
Im Programm 2.62 zeit.c auf Seite 162 haben wir ein Array von Strings
kennengelernt, also ein Array von Arrays von Zeichen, abgeschlossen jeweils
¨ die Namen der Wochentage, mit
mit dem ASCII-Zeichen Nr. 0. Es enthalt
¨ auf gleiche Lange:
¨
Spaces aufgefullt
char *ptag[] = {"Sonntag, ", "Montag,
", ...};
¨
Hier wird ein Array von 7 Pointern gespeichert. Dazu kommen naturlich
noch
die Strings, die wegen des Aussehens auf dem Bildschirm gleich lang sind,
¨
aber vom Programm her ungleich lang sein durften.
96
2 Programmieren in C/C++
Pointer 2.
ptag
−→
−→
−→
−→
−→
−→
−→
−→
−→
−→
ptag + 1−→
−→
−→
Pointer 1.
ptag[0]
ptag[0] + 1
ptag[0] + 2
ptag[0] + 3
ptag[0] + 4
ptag[0] + 5
ptag[0] + 6
ptag[0] + 7
ptag[0] + 8
ptag[0] + 9
ptag[1]
ptag[1] + 1
ptag[1] + 2
−→
−→
−→
−→
−→
−→
−→
−→
−→
−→
−→
−→
−→
Sp.
S
o
n
n
t
a
g
,
⊗
M
o
n
Wert (Variable)
∗ ∗ ptag = ∗ptag[0] = ptag[0][0] = S
∗(ptag[0] + 1) = ptag[0][1] = o
∗(ptag[0] + 2) = ptag[0][2] = n
∗(ptag[0] + 3) = ptag[0][3] = n
∗(ptag[0] + 4) = ptag[0][4] = t
∗(ptag[0] + 5) = ptag[0][5] = a
∗(ptag[0] + 6) = ptag[0][6] = g
∗(ptag[0] + 7) = ptag[0][7] =,
∗(ptag[0] + 8) = ptag[0][8] =
∗(ptag[0] + 9) = ptag[0][9] = ⊗
∗ptag[1] = ptag[1][0] = M
∗(ptag[1] + 1) = ptag[1][1] = o
∗(ptag[1] + 2) = ptag[1][2] = n
Wir brechen nach dem n von Montag ab. ptag ist die Adresse des Speicherplatzes, in dem ptag[0] abgelegt ist. ptag[0] ist die Adresse des Speicherplatzes, in
dem das Zeichen S abgelegt ist. Durch zweimaliges Dereferenzieren von ptag
erhalten wir das Zeichen S. Die anderen Zeichen liegen auf h¨oheren Speicher¨
platzen,
deren Adressen wir durch Inkrementieren entweder von ptag oder
von ptag[ ] erhalten, wobei man normalerweise die zweidimensionale Struk¨
tur des Arrays berucksichtigt,
obwohl dem Computer das ziemlich gleich ist.
Es sind noch weitere Schreibweisen m¨oglich, die oben wegen der begrenzten Breite nicht unterzubringen sind. Greifen wir die letzte Zeile heraus, das
n von Montag. Rein mit Indizes geschrieben gilt:
ptag[1][2] = n
So entwerfen wir vermutlich ein Programm, weil wir das Arbeiten mit Indizes
aus der Mathematik gewohnt sind. Unter Ausnutzen der Pointer-Arithmetik
gilt aber auch:
∗(∗(ptag + 1) + 2) = ∗(ptag[1] + 2) = (∗(ptag + 1))[2] = ptag[1][2] = n
¨ den Computer ist Pointer-Schreibweise mit weniger Arbeit verbunden, da
Fur
er Adressen kennt und Indizes erst in Adressen umrechnen muß.
/* array2.c, Indizes und Pointer */
#include <stdio.h>
char a[] = "abcd";
/* Array of chars */
int main()
{
printf("a[2] = %c\n", a[2]);
printf("*(a + 2) = %c\n", *(a + 2));
printf("*(2 + a) = %c\n", *(2 + a));
2.3 Bausteine eines Quelltextes
97
printf("2[a] = %c\n", 2[a]);
return 0;
}
Quelle 2.23 : C-Programm zur Verdeutlichung der Pointerarithmetik
¨
¨
Nun eine leicht verruckte,
aber richtige Uberlegung.
Wir deklarieren und
initialisieren einen String a[]. Mit Hilfe der Standardfunktion printf() geben wir das Element mit der Hausnummer 2 aus, also das Zeichen c. Dann
greifen wir auf dasselbe Element zu, indem wir den Pointer auf den An¨
fang des Arrays um 2 hochzahlen
und anschließend dereferenzieren. Jetzt
¨ uns ein, dass die Addition – auch in der Pointer-Arithmetik – kommutafallt
¨ geht das
tiv ist, wir vertauschen die beiden Summanden. Erwartungsgemaß
¨
gut. Schließlich wandeln wir die Pointer-Schreibweise wieder zuruck
in die
Index-Schreibweise unter Beibehaltung der vertauschten Reihenfolge. Auch
das funktioniert, logisch.
Pointer und Variable geh¨oren verschiedenen Referenzebenen (level) an,
¨
die nicht gemischt werden durfen.
Der gleiche Fall liegt auch in der Linguistik
¨
vor, wenn uber
W¨orter gesprochen wird. Vergleichen Sie die beiden sinnvollen
¨
Satze:
¨
• Kaffee ist ein Getrank.
• Kaffee ist ein Substantiv.
¨
Im ersten Satz ist die Flussigkeit
gemeint, im zweiten das Wort, was gele¨
¨
gentlich durch Kursivschreibung oder Gansef
ußchen
angedeutet wird. Der
erste Satz ist einfaches Deutsch, der zweite geh¨ort einer Metasprache an,
¨
in der Aussagen uber
die deutsche Sprache vorgenommen werden, verwirrenderweise mit denselben W¨ortern und derselben Grammatik. Genauso kann x
eine Variable oder ein Pointer auf ein Variable sein oder ein Pointer auf einen
Pointer auf eine Variable. Erst ein Blick auf die Deklaration schafft Klarheit.
In C-Programmen wird gern von Pointern Gebrauch gemacht. In der CBibel von B RIAN W. K ERNIGHAN und D ENNIS M. R ITCHIE ist ihnen daher
ein ganzes, gut lesbares Kapitel gewidmet.
2.3.6.8
¨ Typen (typedef)
Weitere Namen fur
¨
Mithilfe der typedef-Anweisung kann sich der Benutzer eigene, zusatzliche
¨ C-Datentypen schaffen. Der neue Name muss eindeutig sein, darf
Namen fur
¨
also nicht mit einem bereits anderweitig belegten Namen ubereinstimmen.
typedef erzeugt keinen neuen Datentyp, sondern veranlasst den Compiler,
im Programm den neuen Namen w¨ortlich durch seine Definition zu ersetzen,
¨
was man zur Prufung
auch von Hand machen kann. Der neue Typname ist ein
Synonym. Der Zweck neuer Typnamen ist eine Verbesserung der Lesbarkeit
und Portierbarkeit des Quelltextes.
Einige Beispiele. Wir wollen uns einen Typnamen BOOLEAN schaffen, der
zwar im Grunde nichts anderes ist als der Typ int, aber die Verwendung
98
2 Programmieren in C/C++
¨
deutlicher erkennen lasst.
Zu Beginn der Deklarationen oder vor main()
schreiben wir:
typedef
int
BOOLEAN;
(die Großschreibung ist nicht zwingend) und k¨onnen anschließend eine Variable janein als BOOLEAN deklarieren
BOOLEAN
janein;
Der Compiler ersetzt den String BOOLEAN in Deklarationen durch den String
¨
¨
int, ahnlich
wie es der Praprozessor
bei #define-Anweisungen macht.
In FORTRAN gibt es den Datentyp complex, den wir in C durch eine
Struktur nachbilden:
typedef struct {
double real;
double imag;
} COMPLEX;
¨ den Strukturtyp struct geHiermit ist nur ein neuer, einfacherer Name fur
schaffen worden. Dann deklarieren wir die komplexe Variable:
COMPLEX z, R[20];
z ist eine komplexe Variable, R ein Array von 20 komplexen Variablen. Leider ist damit noch nicht alles erledigt, denn die arithmetischen Operatoren
¨ Ganz- und Gleitkommazahlen, nicht fur
¨ Strukturen.
von C gelten nur fur
¨
¨ die Operationen mit komplexen Variablen
Wir mussen
noch Funktionen fur
schreiben. In FORTRAN hingegen gelten die gewohnten arithmetischen Ope¨ komplexe Daten. In C++ lassen sich die Bedeutungen der
ratoren auch fur
¨
Operatoren erweitern (uberladen),
aber in C nicht.
¨
Bei Strings taucht das Problem der Langenangabe
auf. Folgender Weg ist
¨ aber nicht alle Wunsche:
¨
gangbar, erfullt
typedef
char
*STRING;
Dann k¨onnen wir schreiben
STRING fehler = "Falsche Eingabe";
¨
Der Compiler weiß die Lange
der Strings aufgrund der Zuweisung der Stringkonstanten. Hingegen ist die nachstehende Deklaration fehlerhaft, wie man
durch Einsetzen erkennt:
STRING
abc[16];
Die Typdefinition eingesetzt ergibt:
char
*abc[16];
und das ist kein String, sondern ein Array von Strings. Erst zweimaliges De¨
referenzieren fuhrt
auf den Typ char. Die Schreibweise:
2.3 Bausteine eines Quelltextes
typedef
char
STRING abc;
[16]
99
STRING;
¨
die dieses Problem l¨osen wurde,
haben wir zwar in einem Buch gefunden,
wurde aber nicht von unserem Compiler angenommen.
Ist man darauf angewiesen, dass ein Datentyp eine bestimmte Anzahl von
Bytes umfasst, erleichtert man das Portieren, indem man einen eigenen Typnamen deklariert und im weiteren Verlauf nur diesen verwendet. Bei einer
Portierung ist dann nur die Typdefinition anzupassen. Es werde eine Ganz¨
zahl von vier Byte Lange
verlangt. Dann deklariert man:
typedef
int
INT4;
INT4
i, j, k;
/* Ganzzahl von 4 Bytes */
¨
¨
und andert
bei Bedarf nur die typedef-Zeile. Zweckmaßig
packt man die
¨ mehrere Programme
Typendefinition in ein privates include-File, das man fur
verwenden kann.
2.3.6.9
Speicherklassen
In C gibt es vier Speicherklassen (storage classes):
• auto
• extern
• register
• static
Die Speicherklasse geht dem Typ in der Deklaration voraus:
static int x;
¨ lokale Variable und braucht nicht
Die Klasse auto ist die Defaultklasse fur
eigens angegeben zu werden. Variablen dieser Klasse leben nur innerhalb
des Bereiches, in dem sie deklariert wurden, und sterben beim Verlassen des
Bereiches, der von ihnen belegte Speicher wird freigegeben.
Eine globale Variable darf in einem Programm nur einmal deklariert
¨
werden. Erstreckt sich ein Programm uber
mehrere getrennt zu kompilierende Files, so darf sie nur in einem der Files deklariert werden. Da aber der
¨
Compiler auch in den ubrigen
Files den Typ der Variablen kennen muss, wird
die Variable hier als extern deklariert. Globale Variable sind per Default extern. Funktionen geh¨oren stets der Speicherklasse extern an.
register-Variable werden nach M¨oglichkeit in Registern nahe dem Re¨
chenwerk gehalten und sind damit schnell verfugbar.
Ansonsten verhalten sie
¨
sich wie auto-Variable. Sie mussen
vom Typ int oder char sein. Eine typische
¨
Anwendung sind Schleifenzahler.
Optimierende Compiler ordnen von sich aus
einige Variable dieser Speicherklasse zu. Auf register-Variable kann der
Referenzierungs-Operator & nicht angewendet werden. Es ist auch unsicher,
ob das System der register-Anweisung folgt. Am besten verzichtet man auf
diese Speicherklasse.
100
2 Programmieren in C/C++
Lokale Operanden gelten und leben nur innerhalb des Blockes, in dem
sie deklariert wurden. Durch die Zuordnung zur Speicherklasse static
¨
¨
verlangert
man ihre Lebensdauer – nicht ihren Geltungsbereich – uber
das
Ende des Blockes hinaus. Bei einem erneuten Aufruf des Blockes hat ein
static-Operand den Wert, den er beim vorherigen Verlassen des Blockes hatte.
2.3.6.10
Geltungsbereich
Eine Variable gilt nur innerhalb des Bereiches (Programmabschnittes), zu
dessen Beginn29 sie deklariert worden ist. Ihr Sichtbarkeits- oder Geltungsbereich (scope) ist dieser Bereich. Außerhalb des zugeh¨origen Bereiches ist
die Variable unbekannt (nicht existent) oder unsichtbar (existent, aber nicht
¨
zuganglich).
Der Name der Variablen ist in diesem Zusammenhang bedeutungslos. Ein Bereich ist:
• ein Programm,
• eine Funktion,
• ein logischer Block zwischen { und },
• ein File.
Variable, die vor allen Funktionen – in der Regel vor main() – deklariert
werden, gelten infolgedessen global in allen Funktionen, die im selben File deklariert werden, das heißt im ganzen Programm, wenn dieses nur aus einem
File besteht. Variable, die zu Beginn einer Funktion – vor allen Anweisungen
in der Funktion – deklariert werden, gelten innerhalb dieser Funktion, aber
¨
nicht außerhalb. Sie sind lokal gultig.
Variable, die zu Beginn eines Blockes
– vor allen Anweisungen im Block – deklariert werden, gelten nur in diesem
Block. Das kommt selten vor, ist aber v¨ollig in Ordnung.
¨
Erstreckt sich ein Programm uber
mehrere Files, so gelten zu Beginn eines Files – vor den darin enthaltenen Funktionen – deklarierte Operanden
¨ die Funktionen im File, aber nicht fur
¨ das gesamte Programm. Soll
global fur
ein Operand global im gesamten Programm gelten, so ist er in jedem File erneut zu deklarieren. Dies widerspricht jedoch der Forderung, dass ein- und
derselbe Operand nur einmal deklariert werden darf. Der Ausweg liegt darin,
ihn nur einmal in beschriebener Weise zu deklarieren und in allen anderen
Files vor die Deklaration das Wort extern zu setzen. Damit ist der Forde¨ getan, und der Compiler weiß trotzdem bei
rung nach Eindeutigkeit Genuge
jedem File, mit welchen Typen er es zu tun hat.
Wird ein Operand desselben Namens innerhalb eines Bereiches nochmals
¨ diesen Bereich die lokale Deklaration Vorrang vor der
deklariert, so hat fur
¨
außeren
Deklaration. Es wird ein neuer, lokaler Operand erzeugt. Der Gel¨
¨
¨
tungsbereich des außeren
Operanden hat eine Lucke,
der außere
Operand
wird verschattet.
29 In
¨
C++ durfen
Variable an beliebiger Stelle innerhalb eines Bereiches deklariert
werden, jedoch muss dies vor ihrer ersten Verwendung erfolgen.
2.3 Bausteine eines Quelltextes
101
¨
¨
Das Konzept des Geltungsbereiches lasst
sich uber
ein Programm hinaus erweitern. Die exportierten Umgebungs-Variablen der Sitzungsshell gel¨ alle Prozesse einer Sitzung und k¨onnen von diesen abgefragt oder
ten fur
¨
¨
verandert
werden. Daruber
hinaus sind auch Variable denkbar, die in einem
Verzeichnis, einem File-System oder in einer Netz-Domain gelten. Je gr¨oßer
¨
der Geltungsbereich ist, desto sorgfaltiger
muss man mit der Schreibberechtigung umgehen.
2.3.6.11
Lebensdauer
¨ die in diesem Bereich definierten VaBeim Eintritt in einen Bereich wird fur
riablen Speicher zugewiesen (allokiert). Beim Verlassen des Bereiches wird
¨
der Speicher freigegeben, von den Variablen bleibt keine Spur zuruck.
Ihre Lebensdauer (lifetime) ist die aktive Zeitspanne des Bereiches. Beim
¨
nachsten
Aufruf des Bereiches wird neuer Speicher zugewiesen und initialisiert. Diese Speicherklasse wird als auto bezeichnet und ist die Standard¨ die nichts anderes vereinbart wird.
klasse aller Variablen, fur
M¨ochte man jedoch mit den alten Werten weiterrechnen, so muss man
die Variable der Speicherklasse static zuweisen. Der Geltungsbereich wird
¨
davon nicht beruhrt,
aber der Speicher samt Inhalt bleibt beim Verlassen der
¨
Funktion bestehen. Die Variable besteht, ist aber vorubergehend
unsichtbar
¨
(existent, aber nicht zuganglich).
2.3.7
Operationen
2.3.7.1
¨
Ausdrucke
Wir haben bisher Operanden betrachtet, aber nichts mit ihnen gemacht. Nun
wollen wir uns ansehen, was man mit den Operanden anstellen kann. Der
¨ Operatoren wirOperator bestimmt, was mit dem Operand geschieht. Unare
¨
¨
ken auf genau einen Operanden, binare auf zwei, ternare auf drei. Mehr Operanden sind selten. Operator plus Operanden bezeichnet man als Ausdruck
(expression). Ein Ausdruck hat nach seiner Auswertung einen Wert und kann
¨
uberall
dort stehen, wo ein Wert verlangt wird. Eine Funktion, die einen Wert
¨
zuruckgibt,
kann anstelle eines Ausdrucks oder Wertes stehen.
2.3.7.2
Zuweisung
Eine Zuweisung (assignment) weist einer Variablen einen Wert zu. Der Operator ist das Gleichheitszeichen (ohne Doppelpunkt wie in PASCAL, wegen
Faulheit). Das Gleichheitszeichen darf von Spaces umgeben sein und sollte es
wegen der besseren Lesbarkeit auch. Wert und Variable sollten vom selben
Typ sein. Es gibt zwar in C automatische Typumwandlungen, aber man sollte
¨
¨
wenig Gebrauch davon machen. Sie fuhren
zu den beruchtigten
unlesbaren
¨
¨
C-Programmen und gefahrden
die Portabilitat.
Da ein Ausdruck wie eine Summe oder eine entsprechende Funktion einen
Wert abliefert, kann in einer Zuweisung anstelle des Wertes immer ein Aus-
102
2 Programmieren in C/C++
¨
druck stehen. Die Zuweisung selbst liefert den zugewiesenen Wert zuruck
¨
und kann daher als Wert in einem ubergeordneten
Ausdruck auftreten.
Auf der rechten Seite einer Zuweisung kann alles stehen, was einen Wert
hat, beispielsweise eine Konstante, ein berechenbarer Ausdruck oder eine
Funktion, aber kein Array und damit auch kein String. Solche Glieder werden
als r-Werte (r-value) bezeichnet. Auf der linken Seite einer Zuweisung kann
alles stehen, was einen Wert annehmen kann, beispielsweise eine Variable,
aber keine Konstante und keine Funktion. Diese Glieder heißen l-Werte (lvalue).
Eine Zuweisung ist keine mathematische Gleichung. Die Formel
x=x+1
(2.1)
¨ jeden endlichen Wert von x falsch, als Zuweisung daist als Gleichung fur
¨
gegen ist sie gebrauchlich
und bedeutet: Addiere 1 zu dem Wert von x und
¨ die Variable
schreibe das Ergebnis in die Speicherstelle von x. Damit erhalt
x einen neuen Wert. Bei einer Gleichung gibt es weder alt noch neu, die Zeit
spielt keine Rolle. Bei einer Zuweisung gibt es ein Vorher und Nachher. Die
Formel
x+2=5
(2.2)
hingegen ist als Gleichung in Ordnung, nicht aber als Zuweisung, da auf
der linken Seite ein Ausdruck steht und nicht ein einfacher Variablenname.
Wegen dieser Diskrepanz zwischen Gleichung und Zuweisung ist letztere et¨
was umstritten. Ihre Begrundung
kommt nicht aus der Problemstellung, son¨
dern aus der Hardware, namlich
der Speicherbehandlung. Und gerade diese
m¨ochte man mit den h¨oheren Programmiersprachen verdecken.
2.3.7.3
Arithmetische Operationen
Die arithmetischen Operationen sind:
¨
• Vorzeichenumkehr - (unarer
Operator)
• Addition +
¨
• Subtraktion - (binarer
Operator)
• Multiplikation *
• Division /
¨ ganze Zahlen)
• Modulus % (Divisionsrest, nur fur
• Inkrement ++
• Dekrement -¨
Inkrement und Dekrement sind Abkurzungen.
Der Operator kann vor oder
¨
nach dem Operanden (Prafix,
Postfix) stehen. Der Ausdruck
i++
¨ und erh¨oht ihn dann um eins. Der Ausdruck
gibt den Wert von i zuruck
2.3 Bausteine eines Quelltextes
103
++i
¨
¨
erh¨oht den Wert von i um eins und gibt dann den erh¨ohten Wert zuruck.
Fur
das Dekrement gilt das Entsprechende. Der kompilierte Code ist effektiver
¨
als der des aquivalenten
Ausdrucks
i = i + 1
¨
Spielt es vom Programm her keine Rolle, ob man den Prafix
oder den Post¨
¨
fix verwendet, ist der Prafix
++i unter Umstanden
schneller und daher zu
¨
¨ haufig
¨
bevorzugen. Ferner gibt es noch eine abgekurzte
Schreibweise fur
wiederkehrende Operationen:
+=, -=, *=, /=
Der Ausdruck
y += x
weist die Summe der beiden Operanden dem linken Operanden zu und ist
somit gleichbedeutend mit dem Ausdruck:
y = y + x
¨ die anderen Abkurzungen.
¨
¨
Entsprechendes gilt fur
Die ausfuhrliche
Schreibweise bleibt weiterhin erlaubt.
¨ ganze Zahlen ist eine andere Operation als fur
¨ GleitkomDie Division fur
¨
¨ es da nicht auf). In manmazahlen (die ubrigen
Operationen auch, nur fallt
chen Programmiersprachen werden folgerichtig unterschiedliche Operatoren
verwendet, in C nicht. Der Compiler entnimmt aus dem Zusammenhang, welche Division gemeint ist. Diese Mehrfachverwendung eines Operators wird
¨
Uberladung
genannt und spielt in objektorientierten Sprachen wie C++ eine
Rolle. In FORTRAN, das den komplexen Zahlentyp kennt, gelten die arith¨ diesen. Vorstellbar ist ebenso eine Addition
metischen Operatoren auch fur
(Verkettung) von Strings.
2.3.7.4
Logische Operationen
Die logischen Operationen sind:
• bitweise Negation (not) ˜ (Tilde)
• ausdrucksweise Negation (not) !
• bitweises Und (and) &
• ausdrucksweises Und (and) &&
• bitweises exklusives Oder (xor) ˆ (Circumflex, caret)
• bitweises inklusives Oder (or) |
• ausdrucksweises inklusives Oder (or) ||
¨
Auch hier gibt es abgekurzte
Schreibweisen:
104
2 Programmieren in C/C++
ˆ=, |=, &=
Der Ausdruck
y &= x
bedeutet dasselbe wie
y = y & x
¨
Die Operanden y und x werden bitweise durch Und verknupft,
das Ergebnis
¨ die beiden anderen Abkurzungen.
¨
wird y zugewiesen. Entsprechendes gilt fur
Der Unterschied zwischen einer ausdrucksweisen und einer bitweisen
logischen Operation ist folgender: In C gilt der Zahlenwert 0 als logisch falsch
(false), jeder Wert ungleich 0 als logisch wahr (true). Die Zeilen:
...
int x = 0;
if (x) printf("if-Zweig\n");
else printf("else-Zweig\n");
...
¨
¨
fuhren
zur Ausfuhrung
des else-Zweiges. Die Variable x hat den Wert 0,
¨
bei dem auch alle Bits auf 0 stehen. Sowie ein beliebiges Bit auf 1 stunde,
¨
¨
hatte
die Variable einen Wert ungleich 0 und wurde
als wahr angesehen. Die
ausdrucksweise Negation:
if (!x) printf ...
¨
¨
kehrt die Verhaltnisse
um, der if-Zweig wird ausgefuhrt.
Die bitweise Ne¨
¨ jedoch nicht sinnvoll, da die
gation hatte
hier zwar denselben Erfolg, ware
einzelnen Bits nicht interessieren.
Der Buchstabe G wird in 7-bit-ASCII durch die Bitfolge 1000111 dargestellt. Ihre bitweise Negation ist 0111000, was der Ziffer 8 entspricht. Das
Mini-Programm:
/* Bitweise Negation */
#include <stdio.h>
int main()
{
char x = ’G’;
printf("%c %c\n", x, ˜x);
return 0;
}
Quelle 2.24 : C-Programm zur Veranschaulichung der bitweisen Negation
gibt den Buchstaben G und die Ziffer 8 aus, zumindest auf Maschinen, die den
7-bit-ASCII-Zeichensatz verwenden. Der Zweck der bitweisen Operation ist
der Umgang mit Informationen, die nicht in einem Wert als Ganzem, sondern
2.3 Bausteine eines Quelltextes
105
in einzelnen Bits stecken. Das kommt bei der Systemprogrammierung vor.
¨
¨ ein- oder ausgeschaltet
Beispielsweise lasst
sich die Information, ob ein Gerat
ist, in einem Bit unterbringen. In der Anwendungsprogrammierung ist man
¨
¨
meist großzugiger
und spendiert eine ganze Integer-Variable dafur.
Merke: Ausdrucksweise logische Operationen und die noch folgenden
Vergleichs-Operationen haben ein Ergebnis, das wahr oder falsch lautet
(nicht-0 oder 0). Bitweise logische Operationen k¨onnen jedes beliebige Ergebnis im Bereich der ganzen Zahlen haben.
2.3.7.5
Vergleiche
Die Vergleichs- oder Relations-Operationen sind:
• gleich == (weil = schon die Zuweisung ist)
• ungleich !=
• kleiner <
• kleiner gleich <=
• gr¨oßer >
• gr¨oßer gleich >=
• Bedingte Bewertung ?:
Das Ergebnis eines Vergleichs ist ein boolescher Wert, also true oder false
beziehungsweise in C die entsprechenden Zahlen nicht-0 oder 0.
¨
Ein haufiger
Fehler ist die Verwendung des einfachen Gleichheitszeichens
¨ die Abfrage auf Gleichheit. Dieser Fehler ist schwierig zu erkennen, da der
fur
fehlerhafte Ausdruck syntaktisch korrekt ist, er bedeutet nur eine Zuweisung
an Stelle des beabsichtigten Vergleichs:
if (x = 0) { ...
/* statt (x == 0) */
Der Compiler protestiert nicht. Da in Vergleichen oft auf einer Seite Aus¨
drucke
wie Konstanten vorkommen, die nicht auf der linken Seite einer Zuweisung stehen k¨onnen (r-values), empfiehlt es sich, diese auf die linke Seite
des Vergleichs zu stellen:
if (0 == x) { ..
¨
Bei dem falschen Operator protestiert dann der Compiler oder Syntaxprufer.
Einfach eine kleine Angewohnheit, die die Arbeit erleichtert.
Pfiffig ist die Bedingte Bewertung (conditional operator), auch
Bedingter Ausdruck genannt. Der Ausdruck:
z = (a < 0) ? -a : a
hat dieselbe Wirkung wie:
106
2 Programmieren in C/C++
if (a < 0)
z = -a;
else
z = a;
Er weist der Variablen z den Betrag von a zu. Rechts des Gleichheitszeichens
¨
¨
stehen drei Ausdrucke,
die auch zusammengesetzt sein durfen.
Die ganze Bedingte Bewertung ist selbst wieder ein Ausdruck wie eine Zuweisung und
¨
kann uberall
stehen, wo ein Wert verlangt wird. Die Bedingte Bewertung ist
¨
einer der seltenen ternaren
oder triadischen Operatoren (drei Operanden)
¨
und fuhrt
zu schnellerem Code als if - else. Welchen Wert nimmt z in
folgendem Beispiel an?
z = (a >= b) ? a : b
Eine Anwendung finden Sie im Abschnitt 2.4.7 Rekursiver Aufruf einer Funktion auf Seite 142.
2.3.7.6
Bitoperationen
Die Bit-Operationen sind:
• shift links <<
• shift rechts >>
Bei vorzeichenlosen Ganzzahlen ist ein Shiften nach links gleichbedeutend
mit einer Multiplikation mit 2, ein Shiften nach rechts mit einer Division
durch 2. Auf die links oder rechts wegfallende Stelle ist zu achten, nachgeschoben am anderen Ende wird eine Null. Die Shift-Operation ist schnell.
Weiterhin beziehen sich einige logische Operationen auf Bits (siehe oben).
¨
Auch hier sind Abkurzungen
m¨oglich:
<<=, >>=
Der Ausdruck
y <<= x
ist gleichbedeutend mit
y = y << x
Der linke Operand wird um so viele Bits nach links verschoben, wie der rechte
Operand angibt. Das Ergebnis wird dem linken Operanden zugewiesen. Zur
Veranschaulichung der Bitoperationen ein kleines Programm:
/* Programm mit Bitoperationen,
sinnvolle Argumente z. B. 8 2 */
#include <stdio.h>
void exit();
2.3 Bausteine eines Quelltextes
107
int main(int argc,char *argv[])
{
int i, j, k;
if (argc < 3) {
puts("Zwei Argumente erforderlich.");
exit(-1);
}
sscanf(argv[1], "%d", &i);
sscanf(argv[2], "%d", &j);
k = i << j;
printf("Eingabe
k = i >> j;
printf("Eingabe
k = i & j;
printf("Eingabe
k = i | j;
printf("Eingabe
%d um %d Bits nach links:
%d\n", i, j, k);
%d um %d Bits nach rechts: %d\n", i, j, k);
%d mit %d bitweise und:
%d mit %d bitweise oder:
%d\n", i, j, k);
%d\n", i, j, k);
return 0;
}
Quelle 2.25 : C-Programm mit Bitoperationen
2.3.7.7
st ointeroperationen
Folgende Operationen behandeln Pointer:
• Referenzierung &
• Dereferenzierung * oder bei Arrays [ ]
• Strukturverweis -> (minus gr¨oßer, bei Strukturpointern)
• Strukturverweis . (Punkt, bei Strukturnamen)
¨ Ganzzahlen zulassige
¨
¨ Pointer
Weiterhin sind folgende fur
Operationen fur
definiert:
• Vergleich zweier Pointer auf denselben Typ
• Inkrementierung (Addition einer ganzen Zahl)
• Dekrementierung (Subtraktion einer ganzen Zahl)
• Subtraktion zweier Pointer desselben Typs
¨
Der Vergleich zweier gleichartiger Pointer auf Ubereinstimmung
ist immer m¨oglich, ein Vergleich gr¨oßer-kleiner setzt eine bestimmte Ordnung der
¨
Adressen voraus und ist problematisch, man lasst
besser die Finger davon:
double
if (p1
if (p1
if (p1
if (p1
*p1, *p2;
== p2) {}
!= p2) {}
== NULL) {}
< p2) {}
/*
/*
/*
/*
ok */
ok */
ok */
gefaehrlich */
108
2 Programmieren in C/C++
Bei der Addition oder Subtraktion einer ganzen Zahl bedeutet die ganze Zahl
nicht eine Anzahl von Bytes, sondern eine Anzahl von Objekten des zum Poin¨
ter geh¨origen Datentyps. Man braucht sich also nicht darum zu kummern,
wieviele Bytes der Datentyp belegt:
double x, vektor[10];
x = *vektor;
/* erstes Element, Index 0 */
x = *(vektor + 2);
/* uebernaechstes Element */
Die selten vorkommende Subtraktion zweier gleichartiger Pointer liefert die
Anzahl der zwischen den beiden Pointern liegenden Datenobjekte.
2.3.7.8
Ein- und Ausgabe-Operationen
In C gibt es keine Operatoren zur Ein- oder Ausgabe, vergleichbar mit read
oder write in PASCAL oder FORTRAN. Stattdessen greift man entweder
¨ oder besser auf
auf Systemaufrufe des Betriebssystems (z. B. UNIX) zuruck
Funktionen der C-Standardbibliothek, die letzten Endes auch Systemaufrufe verwenden, nur intelligent verpackt. Die Systemaufrufe haben eine et¨
¨ aber auch Dinge außerhalb des Ubliwas schwierigere Syntax, erlauben dafur
¨ verschiedene Betriebssysteme programmieren m¨ochte,
chen. Wer portabel fur
bevorzugt die Standardfunktionen, da sie die Unterschiede verdecken. Wenn
¨
keine Grunde
dagegen sprechen, nimmt man die Standardfunktionen.
Die UNIX-Systemaufrufe sind in der Sektion 2 des Handbuchs zu finden,
die wichtigsten lauten open(2), close(2), read(2) und write(2). Hier
ein Programmbeispiel:
/* Demo Systemaufruf open(2) */
#include
#include
#include
#include
<stdio.h>
<fcntl.h>
<unistd.h
<string.h
/*
/*
/*
/*
wegen
wegen
wegen
wegen
puts(3) */
open(2) */
write(2) */
strlen(3) */
int main(int argc, char *argv[])
{
int fildes;
size t bufsize;
ssize t n;
char *buffer = "UNIX ist prima.";
if (argc < 2){
puts("Filenamen vergessen");
return(-1);
}
/* File muss bereits existieren */
fildes = open(argv[1], O WRONLY);
bufsize = (size t)strlen(buffer);
/* File-Deskriptor */
2.3 Bausteine eines Quelltextes
109
if (fildes > 2) {
puts("open() erfolgreich");
n = write(fildes, (void *)buffer, bufsize);
if (n == bufsize) {
puts("write() erfolgreich");
}
close(fildes);
}
else {
puts("Fehler bei open()");
return(-1);
}
return 0;
}
Quelle 2.26 : C-Programm Ausgabe per Systemaufruf write(2)
Mittels open(2) o¨ ffnen wir das File, dessen Name als erstes Argument
¨
ubergeben
wird, zum Schreiben. Das File muss bereits vorhanden sein. Der
¨
Systemaufruf gibt einen File-Deskriptor zuruck,
eine fortlaufende Nummer
der vom Programm ge¨offneten Files, beginnend mit 3. Dann schreiben wir
den in einem Puffer abgelegten String zum File-Deskriptor und schließen das
File. Der Rest sind kleine Maßnahmen zur Fehlerbehandlung.
Die C-Standardfunktionen sind in der Sektion 3 des Handbuchs zu finden,
die wichtigsten lauten fopen(3), fclose(3), scanf(3) und printf(3).
Hier ein Programmbeispiel:
/* Demo Standardfunktion fopen(3) */
#include <stdio.h>
/* wegen fopen(3), fputs(3) usw. */
int main(int argc, char *argv[])
{
FILE *fp;
/* File-Pointer */
char *string = "UNIX ist prima.";
int x;
if (argc < 2){
puts("Filenamen vergessen");
return(-1);
}
/* File braucht noch nicht zu existieren */
fp = fopen(argv[1], "w");
if (fp != NULL) {
puts("fopen() erfolgreich");
x = fputs(string, fp);
if (x != EOF) {
puts("fputs() erfolgreich");
}
110
2 Programmieren in C/C++
fclose(fp);
}
else {
puts("Fehler bei fopen()");
return(-1);
}
return 0;
}
Quelle 2.27 : C-Programm Ausgabe per Standardfunktion fputs(3)
Das Programm macht im Grunde das Gleiche wie das vorangegangene, die
¨ das Schreiben von Strings
Schreibfunktion fputs(3) ist jedoch optimiert fur
in ein File. Es gibt auch eine Standardfunktion fwrite(3) zum Schreiben
¨
eines Blocks binarer
Daten aus einem Puffer in ein File. Ein File-Pointer ist
ein Pointer auf eine Struktur des Typs FILE, die im Include-File stdio.h
definiert ist.
2.3.7.9
Sonstige Operationen
¨ verschiedene Aufgaben:
Ferner bietet C noch einige Operatoren fur
• Datentyp-Umwandlung (cast-Operator) ()
• Komma-Operator ,
• sizeof-Operator sizeof()
¨ in den runden
Der cast-Operator oder Umwandlungsoperator enthalt
Klammern eine skalare Typbezeichnung ohne Speicherklasse und geht dem
umzuwandelnden skalaren Operanden unmittelbar voraus:
int n;
double y;
y = sqrt((double) n);
n sei eine Ganzzahl. Die Funktion sqrt() erwartet jedoch als Argument eine Gleitkommazahl doppelter Genauigkeit. Die Typumwandlung von n wird
durch den cast-Operator (double) bewirkt. Bei der Typumwandlung k¨onnen
¨
Bits oder Dezimalstellen verlorengehen, wenn der neue Typ kurzer
ist als der
alte. Die Typumwandlung gilt nur im Zusammenhang mit dem cast-Operator
¨ die weiteren Anwendungen der Variablen keine Bedeutung. Manund hat fur
che Compiler beanstanden einen cast-Operator auf der linken Seite einer Zuweisung (als l-Wert).
¨
Der Komma-Operator trennt in einer Auflistung von Ausdrucken
diese
voneinander. Sie werden von links nach rechts abgearbeitet. Das Ergebnis
der Auflistung hat Typ und Wert des rechts außen stehenden Ausdrucks. Ein
Beispiel:
int i, j = 10;
i = (j++, j += 100, 999);
printf("%d", i);
2.3 Bausteine eines Quelltextes
111
Hier wird zuerst j um 1 erh¨oht, dann dazu 100 addiert und schließlich dem
gesamten Ausdruck der Wert 999 zugewiesen. j hat also nach den Operationen den Wert 111, i den Wert 999, der ausgegeben wird. Der KommaOperator wird oft im Kopf von for-Schleifen verwendet. Das Komma zwischen Variablennamen in Deklarationen oder in einer Argumentliste ist kein
Operator. Die Reihenfolge der Abarbeitung solcher Listen ist unsicher.
¨
Der sizeof-Operator gibt die Gr¨oße des Operanden in Bytes zuruck.
Der
Operand kann eine Variable, ein Ausdruck oder ein Datentyp sein, auch ein
zusammengesetzter. Ein Ausdruck wird dabei nicht ausgewertet. Dagegen
k¨onnen Funktionen oder Bitfelder nicht als Operand von sizeof auftreten.
¨
Mit Hilfe des Operators vermeidet man Annahmen uber
die Gr¨oße von Variablen bei Speicherreservierungen, das Programm wird portabler. Der Ausdruck
sizeof(x)
¨
liefert die Gr¨oße von x in Bytes als vorzeichenlose Ganzzahl zuruck.
sizeof
¨
¨
¨
wird wahrend
der Ubersetzung ausgewertet (nicht jedoch vom Praprozessor)
¨ sich zur Laufzeit wie eine konstante ganze Zahl.
und verhalt
2.3.7.10
Vorrang und Reihenfolge
¨
¨
Es gibt in C/C++ ahnlich
wie in der Mathematik genaue Regeln uber
den
Vorrang (precedence) der Operatoren. Es ist jedoch nicht sicher, dass alle CCompiler sich genau an die Vorgaben des ANSI-Vorschlags halten. Zudem hat
man beim Programmieren meist nicht alle Regeln im Kopf, so dass es besser
¨
ist, die Ausdrucke
durch runde Klammern klar und eindeutig zu kennzeich¨
¨
nen. Uberfl
ussige
Klammerpaare st¨oren den Compiler nicht. Hier die Liste
der Operatoren von C mit nach unten abnehmendem Rang:
( ) [ ] -> .
! ˜ ++ -- - (cast) *
* / %
+ << >>
< <= > >=
== !=
&
ˆ
|
&&
||
? :
= += -= *= /= %= <<=
,
&
>>=
sizeof
&=
ˆ=
|=
Zuerst werden also die runden Klammern ausgewertet; wie in der Mathematik haben sie Vorrang vor allen anderen Operatoren außer den drei weiteren
¨
in derselben Zeile. Am schwachsten
bindet der Komma-Operator.
112
2 Programmieren in C/C++
¨ oder LeserichNeben ihrem Rang haben Operatoren eine Assoziativitat
tung (associativity). Die Auswertung eines Ausdrucks wie:
a + b + c
¨
ist durch Vorrang nicht eindeutig zu klaren,
da die beiden Pluszeichen denselben Rang haben. Dieser Fall tritt immer auf, wenn auf beiden Seiten eines
Operanden Operatoren desselben Ranges stehen. Durch den Compiler – nicht
¨
durch die Syntax der Sprache, die lasst
die Frage offen – ist nun festgelegt,
dass die arithmetischen Operatoren links-assoziativ sind. Der Operand in der
Mitte wird vom linken Operator geschnappt, so dass die Summe wie folgt ausgewertet wird:
(a + b) + c
Man k¨onnte auch sagen, dass der Ausdruck von links nach rechts gelesen
wird. Eine Zuweisung dagegen ist von rechts nach links zu lesen, sie ist
rechts-assoziativ. Zuerst wird die rechte Seite der Zuweisung ausgewertet und
dann das Ergebnis der linken Seite zugewiesen. Im Beispiel:
a = b = c
wird der Wert c der Variablen b zugewiesen und dann das Ergebnis dieser
Zuweisung (der Wert b) der Variablen a. Die Reihenfolge einer Auswertung
¨ der Opewird also zuerst durch den Rang und dann durch die Assoziativitat
ratoren bestimmt. Im Anhang in Abschnitt D.2 Operatoren auf Seite 282 sind
¨ aufgelistet.
alle Operatoren von C/C++ mit Rang und Assoziativitat
Bei Funktionsaufrufen ist ungewiss, in welcher Reihenfolge etwaige Argumente ausgewertet werden. Im Beispiel:
int n = 5;
printf("%d %d\n", ++n, n * n);
ist unsicher, ob n erst inkrementiert und dann quadriert wird oder umgekehrt. Das Ergebnis ist entweder 6, 25 oder 6, 36. Die Argumente von
printf() arbeitet der eine Compiler von rechts ab, der andere von links.
Nur durch eine eindeutige Schreibweise:
int n = 5;
++n;
printf{"%d %d\n", n, n * n);
¨
lasst
sich ein eindeutiges Ergebnis erreichen – hier 6, 36.
¨
In der Mathematik gibt es nur eine Leserichtung, namlich
von links
¨
nach rechts. Uber
die Reihenfolge der Rechenschritte besagt die Leserichtung
¨ als Gleichung unzulassig,
¨
nichts. Die obige mehrfache Zuweisung ware
bei der
¨ das Ergebnis.
Addition spielt die Reihenfolge keine Rolle fur
¨ fuhrt
¨
Mißachtung von Rang und Assoziativitat
zu schwierig aufzudeckenden logischen Fehlern im Programm. Syntaktisch ist das Programm richtig,
2.3 Bausteine eines Quelltextes
113
es tut nur etwas anderes, als sich der Programmierer vorgestellt hat. Deshalb ist dringend anzuraten, die Reihenfolge einer Auswertung durch Klam¨
mern oder Einzelanweisungen zwingend vorzuschreiben und Ausdrucke
zu
¨
vermeiden, deren Wert von Vermutungen uber
die Reihenfolge der Auswer¨
tung abhangt.
2.3.8
Anweisungen
2.3.8.1
Leere Anweisung
Anweisungen (statement) haben eine Wirkung, aber keinen Wert, im Ge¨
gensatz zu Ausdrucken.
Die einfachste Anweisung ist die leere Anweisung,
also die Aufforderung an den Computer, nichts zu tun. Das sieht zwar auf den
¨
ersten Blick schwachsinnig aus, ist aber gelegentlich nutzlich.
Da in C jede
Anweisung mit einem Semikolon abgeschlossen werden muss, ist das nack¨ die
te Semikolon die leere Anweisung. In anderen Sprachen findet sich dafur
Anweisung nop oder noop (no operation). Ein Beispiel:
while ((c = getchar()) != 125);
Die Schleife liest Zeichen ein und verwirft sie, bis sie auf ein Zeichen Nr. 125
(rechte geschweifte Klammer) trifft. Das wird auch noch entsorgt, dann geht
es nach der Schleife weiter.
2.3.8.2
Zuweisung als Anweisung
¨
Aus einer Zuweisung wird durch Anhangen
eines Semikolons eine Anweisung. Kommt eine Zuweisung beispielsweise als Argument einer Funktion
oder in einer Bedingung vor, darf sie nicht durch ein eigenes Semikolon abge¨
schlossen werden. Die Zuweisung wird ausgefuhrt
und ihr Wert an ihre Stelle
gesetzt. Steht die Zuweisung allein, muss sie mit einem Semikolon beendet
werden und wird damit zu einer Anweisung an den Computer, etwas zu tun:
printf("%d %f \n", x = 3, log(4));
x = 5;
y = log(4);
¨
Ahnlich
wie die Return-Taste in der Kommandozeile bewirkt hier erst das
Semikolon, dass etwas geschieht.
2.3.8.3
Kontrollanweisungen
¨
Kontrollanweisungen steuern in Abhangigkeit
von dem Wert eines booleschen Ausdrucks (Bedingung) die Abarbeitung von Programmteilen (einzelnen Anweisungen oder Bl¨ocken), weshalb die Einrichtung auch Ablaufkontrolle genannt wird. Die Kontrollanweisungen von C wie von vielen anderen
Sprachen sind die Bedingung, die Verzweigung, die Auswahl, die Schleife und
der Sprung.
114
2 Programmieren in C/C++
Sequenz Die einfachste Kontrollanweisung ist keine, die Anweisungen im
Programm werden der Reihe nach abgearbeitet. Diese Ablaufform heißt Se¨
¨
quenz oder Folge und wird der Vollstandigkeit
halber erwahnt.
¨
Bedingung Die Ausfuhrung
eines Blocks kann von einer Bedingung (con¨
dition) abhangig
gemacht werden. Die Bedingung ist ein Ausdruck, der nur
die Werte true oder false annimmt. Ist die Bedingung true, wird der Block
abgearbeitet und dann im Programm fortgefahren. Ist die Bedingung false,
¨
wird der Block ubersprungen.
Kann die Bedingung niemals true werden,
hat man toten (unerreichbaren) Code geschrieben. Ist die Bedingung immer
true, sollte man auf sie verzichten.
¨
In C wird die Bedingung mit dem Schlusselwort
if eingeleitet, ohne then
(im Unterschied zu einem Shellscript). Besteht der Block nur aus einer einzigen Anweisung, kann auf die geschweiften Klammern verzichtet werden:
if (Ausdruck) einzelne_Anweisung; /* oder */
if (Ausdruck) {Block von Anweisungen}
Verzweigung (C) Bei einer Verzweigung (branch) entscheidet sich der
¨
Computer, in Abhangigkeit
von einer Bedingung in einem von zwei Programmzweigen weiterzumachen. Im Gegensatz zur Schleife kommt kein
¨
¨
Rucksprung
vor. Verzweigungen durfen
geschachtelt werden. Dem Computer
¨
macht das nichts aus, aber vielleicht verlieren Sie die Ubersicht.
Oft, aber nicht notwendigerweise treffen die beiden Zweige im weiteren
Verlauf wieder zusammen. Die Syntax sieht folgendermaßen aus:
if (Ausdruck) {Block 1}
else {Block 2}
¨
Es wird also stets entweder Block 1 oder Block 2 ausgefuhrt.
Auswahl Stehen am Verzweigungspunkt mehr als zwei Wege offen, so
¨
¨
spricht man von einer Auswahl (selection). Sie lasst
sich grundsatzlich
durch
eine Schachtelung einfacher Verzweigungen mit if - else darstellen, das
¨
ist jedoch unubersichtlich.
¨
Zur Konstruktion einer Auswahl braucht man die Schlusselw¨
orter
switch, case, break und default. Die Syntax ist die folgende:
switch(x) {
case a:
Anweisungsfolge 1
break;
case b:
case c:
Anweisungsfolge 2
break;
2.3 Bausteine eines Quelltextes
115
default:
Anweisungsfolge 3
}
¨
Die Variable x (nur vom Typ int oder char) wird auf Ubereinstimmung
¨
mit der typgleichen Konstanten a gepruft.
Falls ja, wird die Anweisungs¨
folge 1 ausgefuhrt
und infolge der break-Anweisung die Auswahl verlas¨
sen. Stimmt x nicht mit a uberein
oder fehlt nach case a das break, wird
¨
¨ Trifft kein case zu, wird
dann x auf Ubereinstimmung mit b oder c gepruft.
¨
die default-Anweisungsfolge ausgefuhrt.
Fehlt diese, macht das Programm
¨
nach der Auswahl weiter, ohne eine der Anweisungen ausgefuhrt
zu haben.
¨
¨
Wenn keine anderen Grunde
dagegen sprechen, stellt man den haufigsten
Fall an den Anfang.
¨
Die Auswahl ist ubersichtlich,
einfach zu erweitern und effektiv. Wenn aus
einer einfachen Verzweigung eine Auswahl werden k¨onnte, soll man gleich zu
¨
dieser greifen. Auswahlen durfen
geschachtelt werden.
Mit etwas Phantasie kann man sich die Bedingung als eine Auswahl mit
nur einer Wahlm¨oglichkeit vorstellen, die Verzweigung als eine Auswahl mit
zwei Wahlm¨oglichkeiten. Insofern lassen sich diese drei Kontrollstrukturen
zusammenfassen, wobei die switch-Auswahl den allgemeinen Fall darstellt.
Schleifen Einem Computer macht es nichts aus, denselben Vorgang mil¨
lionenmal zu wiederholen. Das ist seine Starke.
Wiederholungen von Anweisungen kommen daher in fast allen Programmen vor, sie werden Schleifen
(loop) genannt.
¨
Eine Schleife hat einen Eingang, sonst kame
man nicht hinein. Die meis¨
ten Schleifen haben auch einen Ausgang, sonst kame
man nicht wieder her¨
aus (außer mit dem Brecheisen in Form der Break-Taste oder Ahnlichem).
¨
Entweder Ein- oder Ausgang sind an eine Bedingung geknupft,
die entscheidet, wie oft die Schleife durchlaufen wird. Folgende Konstruktionen sind
m¨oglich:
• Eingang: Eintrittsbedingung
• Schleifenrumpf (Anweisungen)
¨
• Ausgang: Rucksprung
zum Eingang
¨ ist, unter
Diese Schleife wird nur betreten, falls die Eintrittsbedingung erfullt
¨
Umstanden
also nie. Sie wird deshalb abweisende Schleife genannt, auch
¨
kopfgesteuerte Schleife. Wenn die Eintrittsbedingung nicht mehr erfullt
ist,
macht das Programm nach der Schleife weiter. In C sieht diese Schleife so
aus:
while (Bedingung) einzelne_Anweisung;
/* oder */
while (Bedingung) {Block von Anweisungen}
}
¨
¨
¨
¨
Die zweite M¨oglichkeit lasst
sich grundsatzlich
auf die erste zuruckf
uhren,
wird aber trotzdem verwendet, weil das Programm dadurch einfacher wird:
116
2 Programmieren in C/C++
• Eingang (wird in jedem Fall betreten)
• Schleifenrumpf (Anweisungen)
¨
• Ausgang: Rucksprungbedingung
¨
Diese Schleife wird also mindestens einmal ausgefuhrt
und dann so lange
¨
wiederholt, wie die Rucksprungbedingung
zutrifft. Sie heißt daher nichtab¨
weisende Schleife, auch fußgesteuerte Schleife. Ist die Rucksprungbedin¨
gung nicht mehr erfullt,
macht das Programm nach der Schleife weiter. In
C:
do einzelne_Anweisung while (Bedingung); /* oder */
do {Block von Anweisungen} while (Bedingung);
Eine Variante, die eine #define-Zeile erfordert, sieht folgendemaßen aus:
#define Please
...
Please do {Block} while (Bedingung);
¨
¨
¨
In hartnackigen
Fallen
soll diese Schleife der Standard-Schleife uberlegen
sein.
Rein aus Bequemlichkeit gibt es in C noch eine dritte Schleife mit for, die
aber stets durch eine while-Schleife ersetzt werden kann. Sie sieht so aus:
for (Initialisierung; Bedingung; Inkrementierung) {
Block von Anweisungen;
}
Vor Eintritt in die Schleife wird der Ausdruck initialisierung aus¨ und
gewertet (also immer), dann wird der Ausdruck bedingung gepruft
falls ungleich 0 der Schleifenrumpf betreten. Zuletzt wird der Ausdruck
¨
inkrementierung ausgewertet und zur Bedingung zuruckgesprungen.
Die
for-Schleife in C hat also eine andere Bedeutung als die for-Schleife der
¨
Shell oder der Programmiersprache PASCAL. Jeder der drei Ausdrucke
darf
fehlen:
for (;;);
ist die ewige und zugleich leere Schleife. Die Initialisierung und die In¨
krementierung durfen
mehrere, durch den Komma-Operator getrennte Aus¨
drucke
enthalten, die Bedingung muss einen Wert gleich oder ungleich 0 ergeben. Zwei Beispiele:
/* Beispiel fuer for-Schleife, 04.03.1993 */
#define MAX 10
#include <stdio.h>
int main()
{
2.3 Bausteine eines Quelltextes
117
int i;
for (i = 0; i < MAX; i++)
printf("Der Schleifenzaehler spricht: %d\n", i);
return 0;
}
Quelle 2.28 : C-Programm mit einfacher for-Schleife
¨
¨ MAX ist bereits vom ComDer Schleifenzahler
i wird mit 0 initialisiert. Fur
piler die Zahl 10 eingesetzt worden; die Eintrittsbedingung i < 10 ist an¨
¨
fangs erfullt,
der Schleifenrumpf wird ausgefuhrt.
Dann wird der dritte Teil
¨
¨
¨
der for-Zeile ausgefuhrt,
namlich
der Schleifenzahler
i um 1 erh¨oht, und zur
¨
Bedingung i < 10 zuruckgesprungen.
Das wiederholt sich, bis i den Wert 10
¨
¨
erreicht hat. Die Bedingung ist dann nicht mehr erfullt,
die Ausfuhrung
des
Programms geht nach der Schleife weiter. Nun der syntaktisch einwandfreie
Mißbrauch einer for-Schleife:
/* Testen der for-Schleife, 04.03.1993 */
#define MAX 10
#include <stdio.h>
int sum(int x);
int main()
{
int i, j = 1;
for (i = - 3, puts("Anfang"); i < j * MAX; i++, i = sum(i))
{
printf("Der Schleifenzaehler spricht: %d %d\n", i, j);
j = (i < 0 ? -i : 3);
}
return i;
}
/* Funktion sum(x) */
int sum(int x)
{
if (x < 5) return (x + 1);
else return (x + 2);
}
Quelle 2.29 : C-Programm mit zusammengesetzter for-Schleife
¨
Im Initialisierungsteil wird der Schleifenzahler
i mit −3 belegt und
– getrennt durch den Komma-Operator – mittels der Standard-Funktion
puts(3) ein String ausgegeben. In der Eintrittsbedingung wird gerechnet;
wichtig ist nur, dass schließlich ein Wert 0 oder nicht-0 herauskommt. Dann
¨
wird gegebenenfalls der Schleifenrumpf ausgefuhrt,
wobei im Rumpf auf
die Variablen i und j des Schleifenkopfes zugegriffen wird. Abschließend
118
2 Programmieren in C/C++
¨
wird der Schleifenzahler
i inkrementiert und – wieder durch den Komma¨
Operator getrennt – nochmals mit Hilfe einer Funktion sum(x) verandert.
¨
Wenn die Schleife nach einigen Durchlaufen
verlassen wird, steht der Schlei¨
¨
¨
fenzahler
i weiterhin zur Verfugung.
In dem Kopf der for-Schleife lasst
sich
allerhand unterbringen, auch Anweisungen, die mit der Schleife nichts zu tun
¨ schlechter Stil.
haben. Das ware
¨
¨
Ist die Eintritts- oder Rucksprungbedingung
immer erfullt,
bleibt der
Computer in der Schleife gefangen, man hat eine ewige Schleife programmiert. Das kann gewollt sein, ist aber oft ein Programmierfehler.
Schleifen mit der Bedingung mitten im Schleifenrumpf sind denkbar und
¨
kommen vor, jedoch selten. Mehrere Ausgange
sind erlaubt, verringern aber
¨
die Ubersicht
und sind sparsam zu verwenden. Bei der Behandlung von Ausnahmen (Division durch Null) braucht man sie manchmal. Das Hineinspringen mitten in den Schleifenrumpf ist m¨oglich, gilt aber als schwerer Stilfehler.
¨
¨
Die Anweisung break im Rumpf fuhrt
zum sofortigen und endgultigen
Verlassen einer Schleife. Die Anweisung continue bricht den augenblickli¨
chen Durchlauf ab und springt zuruck
vor die Schleife, bei der for-Schleife
vor die Initialisierung. Der Systemaufruf exit(2) veranlasst den sofortigen
¨ unheilbare Ausnahmezustande
¨
Abbruch des ganzen Programmes, ist also fur
zu gebrauchen (Notschlachtung).
¨
¨
¨
In vielen Schleifen zahlt
man die Anzahl der Durchlaufe
(und verzahlt
30
¨
sich dabei oft um eins ). Die zugeh¨orige Variable ist der Schleifenzahler.
¨
Auf seine Initialisierung ist zu achten. Der Schleifenzahler
steht in und nach
¨ Rechnungen zur Verfugung,
¨
der Schleife fur
anders als in FORTRAN.
¨
Schleifen durfen
geschachtelt werden. Mit mehrfach geschachtelten
Schleifen geht der Spaß erst richtig los. Der Rumpf der innersten Schleife
¨
wird am haufigsten
durchlaufen und hat daher auf das Zeitverhalten des Programmes einen großen Einfluss. Dort sollte man nur die allern¨otigsten Anweisungen hineinschreiben. Auch die Bedingung der innersten Schleife sollte
so einfach und knapp wie m¨oglich gefasst sein.
Sprung Es gibt die Anweisung goto, gefolgt von einem Label (Marke). In
¨
seltenen Fallen
kann ein goto das Programm verbesern, meist ist es vom
¨
¨
Ubel,
weil es erstens sehr gefahrlich,
zweitens auch nicht n¨otig ist31 .
¨ den Mißbrauch von goto. Das ProHier ein grauenvolles Beispiel fur
¨
gramm ist syntaktisch richtig und tut auch das, was es soll, namlich
die ein¨
gegebene Zahl ausgeben, falls sie durch 5 teilbar ist, andernfalls die nachstgr¨oßere durch 5 teilbare Zahl einschließlich der Zwischenergebnisse. Das Pro¨ eine schwere programmiertechnische Sunde,
¨
gramm enthalt
den Sprung mitten in einen Schleifenrumpf:
/* Grauenvolles Beispiel fuer goto, 06.07.1992 */
/* Am besten gar nicht compilieren */
30 Sogenannter
Zaunpfahl-Fehler (fencepost error): Wenn Sie bei einem Zaun von
¨
¨
100 m Lange
alle 10 m einen Pfahl setzen, wieviele Pfahle
brauchen Sie? 9? 10? 11?
31 Real programmers aren’t afraid to use goto’s.
2.3 Bausteine eines Quelltextes
119
#include <stdio.h>
int main()
{
int x;
printf("Bitte Zahl eingeben: ");
scanf("%d", &x);
if (!(x % 5))
goto marke;
else {
while (x % 5) {
x++;
marke:
printf("Ausgabe: %d\n", x);
}
}
return 0;
}
Quelle 2.30 : C-Programm mit goto, grauenvoll
Nun aber ganz schnell eine stilistisch einwandfreie Fassung des Programms:
/* Verbessertes Beispiel, 06.07.1992 */
#include <stdio.h>
int main()
{
int x;
printf("Bitte Zahl eingeben: ");
scanf("%d", &x);
do {
printf("%d\n", x);
} while (x++ % 5);
return 0;
}
Quelle 2.31 : C-Programm, verbessert
¨
Am goto hatte sich um 1970 herum ein Glaubenskrieg entzundet.
In
¨
¨ diese AnweiC-Programmen besteht außerst
selten die Notwendigkeit fur
¨
sung, aber gebrauchliche
Anweisungen wie break, continue und return
¨
¨
sind bei Licht besehen auch nur gotos, die auf bestimmte Falle
beschrankt
¨
sind. Immerhin verhindern die Beschrankungen
ein hemmungsloses Hinund¨
herhupfen
im Programm.
120
2.3.8.4
2 Programmieren in C/C++
¨
Ruckgabewert
¨
Eine Funktion braucht keinen Wert an die aufrufende Einheit zuruckzugeben. Sie ist dann vom Typ void. Ihre Bedeutung liegt allein in dem, was
sie tut, zum Beispiel den Bildschirm putzen. In diesem Fall endet sie ohne
return-Anweisung (schlechter Stil) oder mit einer return-Anweisung ohne
Argument. Was sie tut, wird Nebenwirkung oder Seiteneffekt (side effect)
¨ das eine Subroutine, in PASCAL eine eigentliche
genannt. In FORTRAN ware
Prozedur.
Gibt man der return-Anweisung einen Wert mit, so kann die Funktion
¨
von der aufrufenden Einheit wie ein Ausdruck angesehen werden. Der Ruckgabewert (return value) darf nur ein einfacher Datentyp oder ein Pointer
¨
¨
sein. Will man einen String zuruckgeben,
geht das nur uber
den Pointer auf
¨
den Anfang des Strings. Der zuruckzugebende
Wert braucht nicht eingeklam¨
mert zu werden; bei zusammengesetzten Ausdrucken
sollte man der Lesbarkeit halber Klammern setzen:
return 0;
return (x + y);
return arrayname;
Besteht das Ergebnis aus mehreren Werten, so muss man mit globalen
¨
Variablen oder mit Pointern arbeiten. Der Ruckgabewert
kann immer nur ein
einziger Wert sein.
¨
Es kommt vor, dass eine Funktion zwar einen Wert zuruckgibt,
dieser aber
nicht weiter verwendet wird. In diesem Fall warnt lint(1), aber das Pro¨
¨
gramm ist korrekt. Haufig
bei printf(3) und Verwandtschaft. Den Ruckgabewert der Funktion main() findet man in der Shell-Variablen $? oder
$status. Er kann in einem Shellscript weiterverarbeitet werden. Hier ein
¨ den Gebrauch der return-Anweisung:
Beispiel fur
/* Beispiel fuer return-Anweisungen, 21.02.91 */
#define PI 3.14159
#include <stdio.h>
/* Funktionsdeklarationen (Prototypen) */
void text(); int eingabe(); double area(float rad);
char *maxi();
/* Hauptprogramm */
int main()
{
float r; char w1[63], w2[63];
text();
if (!eingabe())
puts("Eingabe war richtig.");
2.3 Bausteine eines Quelltextes
121
else
puts("Eingabe war falsch.");
printf("Radius eingeben: ");
scanf("%f", &r);
printf("Kreisflaeche: %lf\n", area(r));
printf("Bitte zwei Woerter eingeben: ");
scanf("%s %s", w1, w2);
printf("Das laengere Wort ist: %s\n", maxi(w1, w2));
return 0;
}
/* Funktion ohne Returnwert, Typ void */
void text()
{
puts("\nDiese Funktion gibt nichts zurueck.");
return;
}
/* Funktion mit richtig/falsch-Returnwert, Typ int */
int eingabe()
{
int i;
printf("Bitte die Zahl 37 eingeben: ");
scanf("%d", &i);
if (i == 37) return 0;
else return -1;
}
/* Funktion, die ein Rechenergebnis liefert, Typ double */
double area(float rad)
{
return (rad * rad * PI);
}
/* Funktion, die einen Pointer zurueckgibt, Typ (char *) */
char *maxi(char *w1,char *w2)
{
int i, j;
for (i = 0; w1[i] != ’\0’; i++) ;
for (j = 0; w2[j] != ’\0’; j++) ;
return((j > i) ? w2 : w1);
}
Quelle 2.32 : C-Programm mit return-Anweisungen
Im Hauptprogramm main() haben return(n); und exit(n); diesel¨
¨
be Wirkung. In anderen Funktionen fuhrt
return zur Ruckkehr
in die
122
2 Programmieren in C/C++
¨
nachsth¨
ohere Einheit, exit zum Abbruch des gesamten Programmes. In der
¨
Syntax unterscheiden sich beide Aufrufe: return ist ein Schlusselwort
von C,
exit() ein Systemaufruf von UNIX, also eine Funktion. Weiterhin sind exit
und return auch eingebaute Shell-Kommandos – siehe sh(1) oder ksh(1)
– die aber nicht in C-Programmen vorkommen k¨onnen.
2.3.9
Memo Bausteine
¨ den menschlichen Leser bestimmt, der Compiler
• Kommentar ist fur
¨
ubergeht
ihn oder bekommt ihn gar nicht erst zu Gesicht.
• Namen bezeichnen Funktionen, Konstanten, Variable aller Art, Makros
oder Sprungmarken (Labels). Sie sollen mit einem Buchstaben beginnen.
• Operanden haben Namen, Typ, Geltungsbereich, Lebensdauer und
¨
spatestens
bei ihrer erstmaligen Benutzung einen Wert und belegen damit einen Platz und eine Adresse im Speicher.
• Eine Vereinbarung besteht aus Deklaration und Definition. Die Deklaration weist einem Operanden Name und Typ zu und legt seinen Gel¨ ein
tungsbereich und seine Lebensdauer fest. Mit der Definition erhalt
Operand einen Wert. Beides kann in einer Anweisung vereinigt werden.
¨
• Der Typ entscheidet uber
Wertebereich, Operationen und Speicherbe¨
¨
darf. Der Typ eines Operanden ist in C konstant, er andert
sich wahrend
¨
der Programmausfuhrung
nicht.
• Es gibt einfache und zusammengesetzte Typen sowie Pointer.
• Einfache Typen sind Ganzzahlen, Gleitkommazahlen und Zeichen. Der
¨
¨ beAufzahlungstyp
ist letzten Endes ganzzahlig. Daneben gibt es fur
¨
stimmte Falle
den leeren Typ.
• Zusammengesetzte Typen sind Arrays und Strukturen.
• Ein Array ist eine geordnete Menge von Operanden gleichen Typs.
• Eine Struktur ist eine ungeordnete Menge von Operanden beliebigen
Typs.
• Der Pointer ist ein Typ, dessen Wertebereich Adressen sind. Ein Pointer
¨
zeigt immer auf einen Typ, unter Umstanden
auf einen weiteren Pointer.
• Ein Ausdruck besteht aus Operanden und Operationen. Er hat einen
¨
Wert und kann uberall
dort stehen, wo ein Wert verlangt wird.
• Die einfachste Operation ist die Zuweisung, nicht zu verwechseln mit einer mathematischen Gleichung. Sie hat eine linke und eine rechte Seite.
Rechts steht immer ein Wert, also gegebenenfalls ein Ausdruck. Links
steht eine Variable oder ein Pointer, aber niemals ein Ausdruck.
• Weiterhin gibt es arithmetische, logische, vergleichende Operationen sowie O. auf Bits, Strukturen oder Pointer. Dann haben wir noch den Cast-,
Komma- und Sizeof-Operator.
2.4 Funktionen
123
• Anweisungen enden immer mit einem Semikolon.
¨
• Aus einer Zuweisung wird durch Anfugen
eines Semikolons eine Anweisung.
• Die Kontrollanweisungen Bedingung (if), Verzweigung (if-else), Auswahl (switch), Schleife (while, do-while, for) und Sprung (break, continue, return, goto) steuern den Programmablauf.
2.3.10
¨
Ubung
Bausteine
¨
¨ das Beispiel der
Uberlegen
Sie, welche Operanden mit welchen Typen Sie fur
Weganalyse (oder des Vokabeltrainers) aus dem vorigen Abschnitt brauchen.
Eine gute Datenstruktur ist schon fast das halbe Programm. Um ein richtiges
¨
Programm schreiben zu k¨onnen, fehlt uns noch der nachste
Abschnitt.
2.4
2.4.1
Funktionen
Aufbau und Deklaration
In C ist eine Funktion eine abgeschlossene Programmeinheit, die mit der
¨
¨
Außenwelt uber
einen Eingang und wenige Ausgange
– gegebenenfalls noch
¨
Notausgange
– verbunden ist. Hauptprogramm, Unterprogramme, Subroutinen, Prozeduren usw. sind in C allesamt Funktionen. Eine Funktion ist die
¨
kleinste kompilierbare Einheit (nicht: ausfuhrbare
Einheit, das ist ein Pro¨
gramm), namlich
dann, wenn sie zugleich allein in einem File steht. Mit weniger als einer Funktion kann der Compiler nichts anfangen.
¨
Da die Definitionen von Funktionen nicht geschachtelt werden durfen
¨
(wohl aber ihre Aufrufe), gelten Funktionen grundsatzlich
global. In einem CProgramm stehen alle Funktionen einschließlich main() auf gleicher Stufe.
Das ist ein wesentlicher Unterschied zu PASCAL, wo Funktionen innerhalb
¨
von Unterprogrammen definiert werden durfen.
In C gibt es zu einer Funk¨
tion keine ubergeordnete
Funktion, deren Variable in der untergeordneten
¨
Funktion gultig
sind.
¨
Eine Funktion ubernimmt
von der aufrufenden Anweisung einen festgelegten Satz von Argumenten oder Parametern, tut etwas und gibt keinen oder
¨
genau einen Wert an die aufrufende Anweisung zuruck.
Vor dem ersten Aufruf einer Funktion muß ihr Typ (d. h. der Typ ihres
¨
Ruckgabewertes)
bekannt sein. Andernfalls nimmt der Compiler den Stan¨
dardtyp int an. Entsprechend dem ANSI-Vorschlag burgert
es sich zuneh¨
mend ein, Funktionen durch ausfuhrliche
Prototypen vor Beginn der Funktion main() zu deklarieren:
/* Beispiel fuer Funktionsprototyp */
float multipl(float x, float y);
/* Prototyp */
/* es reicht auch: float multipl(float, float); */
124
2 Programmieren in C/C++
/* frueher nach K+R: float multipl(); */
int main()
{
float a, b, z;
.
.
z = multipl(a, b);
.
.
}
float multipl(float x, float y)
{
return (x * y);
}
/* Funktionsaufruf */
/* F’definition */
Quelle 2.33 : C-Programm mit Funktionsprototyp
Durch die Angabe der Typen der Funktion und ihrer Argumente zu Beginn des Programms herrscht sofort Klarheit. Die Namen der Parameter sind
unerheblich; Anzahl, Typ und Reihenfolge sind wesentlich. Noch nicht alle
¨
Compiler unterstutzen
die Angabe der Argumenttypen. Auch den Standardtyp int sollte man deklarieren, um zu verdeutlichen, daß man ihn nicht ver¨
gessen hat. Anderungen
werden erleichtert.
2.4.2 Pointer auf Funktionen
Der Name einer Funktion ohne die beiden runden Klammern ist der Poin¨
ter auf ihren Eingang (entry point). Damit kann ein Funktionsname uberall
¨
verwendet werden, wo Pointer zulassig
sind. Insbesondere kann er als Argument einer weiteren Funktion dienen. In funktionalen Programmiersprachen
ist die M¨oglichkeit, Funktionen als Argumente h¨oherer Funktionen zu ver¨
wenden, noch weiter entwickelt. Arrays von Funktionen sind nicht zulassig,
wohl aber Arrays von Pointern auf Funktionen, siehe Programm 2.94 auf
Seite 229.
Makros (#define ...) sind keine Funktionen, infolgedessen gibt es auch
keine Pointer auf Makros. Zu Makros siehe Abschnitt 2.9 Praprozessor
¨
auf
Seite 195.
2.4.3
¨
Parameterubergabe
¨
Um einer Funktion die Argumente oder Parameter zu ubermitteln,
gibt es
¨
¨
mehrere Wege. Grundsatzlich
mussen
in der Funktion die entsprechenden
Variablen als Platzhalter oder formale Parameter vorkommen und deklariert sein. Im Aufruf der Funktion kommt der gleiche Satz von Variablen –
gegebenenfalls unter anderem Namen – mit jeweils aktuellen Werten vor; sie
werden als aktuelle Parameter oder Argumente bezeichnet. Die Schnittstelle von Programm und Funktion muß zusammenpassen wie Stecker und
2.4 Funktionen
125
Kupplung einer elektrischen Verbindung, d. h. die Liste der aktuellen Parameter muß mit der Liste der formalen Parameter nach Anzahl, Reihenfolge
¨
und Typ der Parameter ubereinstimmen.
¨
Bei der Wertubergabe
(call by value) wird der Funktion eine Kopie der
¨
aktuellen Parameter des aufrufenden Programmes ubergeben.
Daraus folgt,
daß die Funktion die aktuellen Parameter des aufrufenden Programmes nicht
¨
verandern
kann.
¨
Bei der Adressubergabe
(call by reference) werden der Funktion die
Speicheradressen der aktuellen Parameter des aufrufenden Programmes
¨
ubergeben.
Die Funktion kann daher die Werte der Parameter mit Wirkung
¨ das aufrufende Programm verandern.
¨
fur
Sie arbeitet mit den Originalen der
¨
Parameter. Das kann erwunscht
sein oder auch nicht. Bei beiden Mechanis¨
men werden die Parameter vollstandig
ausgerechnet, ehe die Funktion betreten wird.
¨
Wie die Parameterubergabe
in C, FORTRAN und PASCAL aussieht, entnimmt man am besten den Beispielen. Die Parameter sind vom Typ integer,
um die Beispiele einfach zu halten. Ferner ist noch ein Shellscript angegeben,
¨
das eine C-Funktion aufruft, die in diesem Fall ein selbstandiges
Programm
(Funktion main()) sein muß.
¨
¨
Der von einer Funktion zuruckgegebene
Wert (Ruckgabewert)
kann nur
ein einfacher Typ oder ein Pointer sein. Zusammengesetzte Typen wie Arrays,
¨
Strings oder Strukturen k¨onnen nur durch Pointer zuruckgegeben
werden. Es
¨
¨
ist zulassig,
keinen Wert zuruckzugeben.
Dann ist die Funktion vom Typ void
und macht sich allein durch ihre Nebeneffekte bemerkbar.
¨ die Systemaufrufe von UNIX und die Standardfunktionen von C ist im
Fur
Referenz-Handbuch in den Sektionen (2) und (3) angegeben, von welchem Typ
die Argumente und der Funktionswert sind. Da diese Funktionen allesamt CFunktionen sind, lassen sie sich ohne Probleme in C-Programme einbinden.
Bei anderen Sprachen ist es denkbar, daß kein einem C-Typ entsprechender
¨
Variablentyp verfugbar
ist. Auch bei Strings gibt es wegen der unterschied¨
lichen Speicherung in den einzelnen Sprachen Reibereien. Falls die Uberga¨
bemechanismen unvertraglich
sind, muß man die C-Funktion in eine Funktion oder Prozedur der anderen Sprache so verpacken, daß das aufrufende
Programm eine einheitliche Programmiersprache sieht. Das Vorgehen dabei
kann maschinenbezogen sein, was man eigentlich vermeiden will.
In den folgenden Programmbeispielen wird die Summe aus zwei Summanden berechnet, zuerst im Hauptprogramm direkt und dann durch zwei Funktionen, die ihre Argumente – die Summanden – by value beziehungsweise
¨
¨
by reference ubernehmen.
Die Funktionen verandern
ihre Summanden, was
im ersten Fall keine Auswirkung im Hauptprogramm hat. Hauptprogramme
und Funktionen sind in C, FORTRAN und PASCAL geschrieben, was neun
Kombinationen ergibt. Wir betreten damit zugleich das an Fallgruben reiche
Gebiet der Mischung von Programmiersprachen (mixed language program¨
ming). Zunachst
die beiden Funktionen im geliebten C:
/* C-Funktion (Summe) call by value */
126
2 Programmieren in C/C++
/* Compileraufruf cc -c csv.c, liefert csv.o */
int csv(int x,int y)
{
int z;
puts("Funktion mit Parameteruebernahme by value:");
printf("C-Fkt. hat uebernommen:
%d
%d\n", x, y);
z = x + y;
printf("C-Fkt. gibt folgende Summe zurueck: %d\n", z);
/* Aenderung der Summanden */
x = 77; y = 99;
return(z);
}
¨
Quelle 2.34 : C-Funktion, die Parameter by value ubernimmt
/* C-Funktion (Summe) call by reference */
/* Compileraufruf cc -c csr.c, liefert csr.o */
int csr(int *px,int *py)
{
int z;
puts("Funktion mit Parameteruebenahme by reference:");
printf("C-Fkt. hat uebernommen: %d
%d\n", *px, *py);
z = *px + *py;
printf("C-Fkt. gibt folgende Summe zurueck: %d\n", z);
/* Aenderung der Summanden */
*px = 66; *py = 88;
return(z);
}
¨
Quelle 2.35 : C-Funktion, die Parameter by reference ubernimmt
¨
Im bewahrten
FORTRAN 77 haben wir leider keinen Weg gefunden, der
¨
Funktion beizubringen, ihre Parameter by value zu ubernehmen
(in FORTRAN 90 ist es m¨oglich). Es bleibt daher bei nur einer Funktion, die – wie in
¨
¨
FORTRAN ublich
– ihre Parameter by reference ubernimmt:
C
C
Fortran-Funktion (Summe) call by reference
Compileraufruf f77 -c fsr.f
integer function fsr(x, y)
integer x, y, z
C
write (6,’(’’F-Fkt. mit Uebernahme by reference:’’)’)
write (6,’(’’F-Fkt. hat uebernommen: ’’,2I6)’) x, y
z = x + y
write (6,’(’’F-Fkt. gibt zurueck: ’’,I8)’) z
Aenderung der Summanden
x = 66
y = 88
fsr = z
2.4 Funktionen
127
end
¨
Quelle 2.36 : FORTRAN-Funktion, die Parameter by reference ubernimmt
PASCAL-Funktionen kennen wieder beide M¨oglichkeiten, aber wir wer¨
den auf eine andere Schwierigkeit stoßen. Vorlaufig
sind wir jedoch hoffnungsvoll:
{Pascal-Funktion (Summe) call by value}
{Compileraufruf pc -c psv.p}
module b;
import StdOutput;
export
function psv(x, y: integer): integer;
implement
function psv;
var z: integer;
begin
writeln(’Funktion mit P’uebernahme by value:’);
writeln(’P-Fkt. hat uebernommen: ’, x, y);
z := x + y;
writeln(’P-Fkt. gibt folgenden Wert zurueck: ’, z);
{ Aenderung der Summanden }
x := 77; y := 99;
psv := z;
end;
end.
¨
Quelle 2.37 : PASCAL-Funktion, die Parameter by value ubernimmt
{Pascal-Funktion (Summe) call by reference}
{Compileraufruf pc -c psr.p}
module a;
import StdOutput;
export
function psr(var x, y: integer): integer;
implement
function psr;
var z: integer;
begin
writeln(’Funktion mit P’uebernahme by reference:’);
writeln(’P-Fkt. hat uebernommen: ’, x, y );
z := x + y;
writeln(’P-Fkt. gibt folgenden Wert zurueck: ’, z);
{ Aenderung der Summanden }
x := 66; y := 88;
psr := z;
end;
end.
¨
Quelle 2.38 : PASCAL-Funktion, die Parameter by reference ubernimmt
128
2 Programmieren in C/C++
¨ sich mit der Option -c ihres jeweiligen CompiDie Funktionen werden fur
lers kompiliert, wodurch Objektfiles mit der Kennung .o entstehen, die beim
¨
Kompilieren der Hauptprogramme aufgefuhrt
werden. Nun zu den Hauptprogrammen, zuerst wieder in C:
/* C-Programm csummec, das C-Funktionen aufruft */
/* Compileraufruf cc -o csummec csummec.c csr.o csv.o */
#include <stdio.h>
extern int csv(int x,int y),
csr(int *px,int *py);
int main()
{
int a, b;
puts("Bitte die beiden Summanden eingeben!");
scanf("%d %d", &a, &b);
printf("Die Summanden sind: %d
%d\n", a, b);
printf("Die Summe (direkt) ist:
%d\n", (a + b));
printf("Die Summe ist: %d\n", csv(a, b));
printf("Die Summanden sind: %d
%d\n", a, b);
printf("Die Summe ist: %d\n", csr(&a, &b));
printf("Die Summanden sind: %d
%d\n", a, b);
return 0;
}
Quelle 2.39 : C-Programm, das Parameter by value und by reference an C¨
Funktionen ubergibt
Nun das C-Hauptprogramm, das eine FORTRAN-Funktion aufruft, ein in
¨
der Numerik haufiger
Fall:
/* C-Programm csummef, das eine FORTRAN-Funktion aufruft */
/* Compileraufruf cc -o csummef csummef.c fsr.o -lcl */
#include <stdio.h>
extern int fsr(int *x,int *y);
int main()
{
int a, b;
scanf("%d %d", &a, &b);
printf("Die Summanden sind: %d
%d\n", a, b);
printf("Die Summe (direkt) ist:
%d\n", (a + b));
printf("Die Summe ist: %d\n", fsr(&a, &b));
printf("Die Summanden sind: %d
%d\n", a, b);
return 0;
}
Quelle 2.40 : C-Programm, das Parameter by reference an eine FORTRAN¨
Funktion ubergibt
2.4 Funktionen
129
Die Linker-Option -lcl ist erforderlich, wenn FORTRAN- oder PASCALModule in C-Programme eingebunden werden. Sie bewirkt die Hinzunahme
der FORTRAN- und PASCAL-Laufzeitbibliothek /usr/lib/libcl.a, oh¨
ne die Bezuge
(Referenzen) auf FORTRAN- oder PASCAL-Routinen unter
¨
Umstanden
offen bleiben. Anders gesagt, in den FORTRAN- oder PASCALFunktionen kommen Namen vor – zum Beispiel write – deren Definition in
besagter Laufzeitbibliothek zu finden ist. C und PASCAL sind sich im großen
¨
ganzen ahnlich,
es gibt aber Unterschiede hinsichtlich des Geltungsbereiches
von Variablen, die hier nicht deutlich werden:
/* C-Programm csummep, das PASCAL-Funktionen aufruft. */
/* Compiler: cc -o csummep csummep.c psv.o psr.o -lcl */
#include <stdio.h>
extern int psv(int x,int y),psr(int *x,int *y)
int main()
{
int a, b;
puts("Bitte die beiden Summanden eingeben!");
scanf("%d %d", &a, &b);
printf("Die Summanden sind: %d
%d\n", a, b);
printf("Die Summe (direkt) ist: %d\n", (a + b));
printf("Die Summe ist: %d\n", psv(a, b));
printf("Die Summanden sind: %d
%d\n", a, b);
printf("Die Summe ist: %d\n", psr(&a, &b));
printf("Die Summanden sind: %d
%d\n", a, b);
return 0;
}
Quelle 2.41 : C-Programm, das Parameter by value und by reference an
¨
PASCAL-Funktionen ubergibt
Hiernach sollte klar sein, warum die C-Standardfunktion printf(3) mit
¨
¨
Variablen als Argument arbeitet, wahrend
die ahnliche
C-Standardfunktion
scanf(3) Pointer als Argument verlangt. printf(3) gibt Werte aus, ohne
¨
¨ das Ergebnis belanglos, ob die Funktion Adressen
sie zu andern.
Es ist fur
(Pointer) oder Kopien der Variablen verwendet (die Syntax legt das aller¨ die aufrufendings fest). Hingegen soll scanf(3) Werte mit Wirkung fur
de Funktion einlesen. Falls es sich nur um einen Wert handelte, k¨onnte das
¨
noch uber
den Returnwert bewerkstelligt werden, aber scanf(3) soll meh¨
rere Werte – dazu noch verschiedenen Typs – verarbeiten. Das geht nur uber
von scanf(3) und der aufrufenden Funktion gemeinsam verwendete Pointer.
Nun die drei FORTRAN-Hauptprogramme mit Aufruf der Funktionen in
C, FORTRAN und PASCAL:
C
C
FORTRAN-Programm, das C-Funktionen aufruft
Compileraufruf f77 -o fsummec fummec.f csv.o csr.o
130
2 Programmieren in C/C++
program fsummec
$ALIAS csv (%val, %val)
integer a, b , s, csr, csv
write (6, 100)
read (5, *) a, b
write (6, 102) a, b
s = a + b
write (6, 103) s
call by value
s = csv(a, b)
write (6, 104) s
write (6, 102) a, b
call by reference
s = csr(a, b)
write (6, 105) s
write (6, 102) a, b
C
C
100
102
103
104
105
format
format
format
format
format
(’Bitte die beiden Summanden eingeben!’)
(’Die Summanden sind: ’, 2I6)
(’Die Summe (direkt) ist: ’, I8)
(’Die Summe ist: ’, I8)
(’Die Summe ist: ’, I8)
end
Quelle 2.42 : FORTRAN-Programm, das Parameter by value und by reference
¨
an C-Funktionen ubergibt
C
C
FORTRAN-Programm, das F77-Funktion aufruft
Compileraufruf f77 -o fsummef fsummef.f fsr.o
program fsummef
integer a, b , s, fsr
C
C
write (6, 100)
read (5, *) a, b
write (6, 102) a, b
s = a + b
write (6, 103) s
call by value nicht moeglich
call by reference (default)
s = fsr(a, b)
write (6, 105) s
write (6, 102) a, b
100 format (’Bitte die beiden Summanden eingeben!’)
102 format (’Die Summanden sind: ’, 2I6)
103 format (’Die Summe (direkt) ist: ’, I8)
2.4 Funktionen
131
105 format (’Die Summe ist: ’, I8)
end
Quelle 2.43 : FORTRAN-Programm, das Parameter by reference an eine
¨
FORTRAN-Funktion ubergibt
C
C
FORTRAN-Programm, das PASCAL-Funktionen aufruft
Compileraufruf f77 -o fsummep fsummep.f psv.o psr.o
program fsummep
$ALIAS psv (%val, %val)
integer a, b, s, psv, psr
external psv, psr
write (6, 100)
read (5, *) a, b
write (6, 102) a, b
s = a + b
write (6, 103) s
call by value
s = psv(a, b)
write (6, 104) s
write (6, 102) a, b
call by reference
s = psr(a, b)
write (6, 105) s
write (6, 102) a, b
C
C
100
102
103
104
105
format
format
format
format
format
(’Bitte die beiden Summanden eingeben!’)
(’Die Summanden sind: ’, 2I6)
(’Die Summe (direkt) ist: ’, I8)
(’Die Summe ist: ’, I8)
(’Die Summe ist: ’, I8)
end
Quelle 2.44 : FORTRAN-Programm, das Parameter by value und by reference
¨
an PASCAL-Funktionen ubergibt
Die FORTRAN-Compiler-Anweisung $ALIAS veranlaßt den Compiler, der
jeweiligen Funktion die Parameter entgegen seiner Gewohnheit by value zu
¨
ubergeben.
Zum guten Schluß die PASCAL-Hauptprogramme:
{PASCAL-Programm, das C-Funktionen aufruft}
{Compiler: pc -o psummec psummec.p csv.o csr.o}
program psummec (input, output);
var a, b, s: integer;
132
2 Programmieren in C/C++
function csv(x, y: integer): integer;
external C;
{call by value}
function csr(var x, y: integer): integer;
external C;
{call by ref.}
begin
writeln(’Bitte die beiden Summanden eingeben!’);
readln(a); readln(b);
write(’Die Summanden sind: ’); write(a); writeln(b);
s := a + b;
write(’Die Summe (direkt) ist: ’); writeln(s);
s := csv(a, b);
write(’Die Summe ist: ’); writeln(s);
write(’Die Summanden sind: ’); write(a); writeln(b);
s := csr(a, b);
write(’Die Summe ist: ’); writeln(s);
write(’Die Summanden sind: ’); write(a); writeln(b);
end.
Quelle 2.45 : PASCAL-Programm, das Parameter by value und by reference
¨
an C-Funktionen ubergibt
{PASCAL-Programm, das FORTRAN-Funktion aufruft}
{Compiler: pc -o psummef psummef.p fsr.o}
program psummef (input, output);
var a, b, s: integer;
function fsr(var x, y: integer): integer;
external ftn77;
{call by ref.}
begin
writeln(’Bitte die beiden Summanden eingeben!’);
readln(a); readln(b);
write(’Die Summanden sind: ’); write(a); writeln(b);
s := a + b;
write(’Die Summe (direkt) ist: ’); writeln(s);
s := fsr(a, b);
write(’Die Summe ist: ’); writeln(s);
write(’Die Summanden sind: ’); write(a); writeln(b);
end.
Quelle 2.46 : PASCAL-Programm, das Parameter by reference an eine
¨
FORTRAN-Funktion ubergibt
{PASCAL-Programm, das PASCAL-Funktionen aufruft}
{Compileraufruf pc -o psummep psummep.p psv.o psr.o}
program psummep (input, output);
2.4 Funktionen
133
var a, b, s: integer;
function psv(x, y: integer): integer;
external;
{call by value}
function psr(var x, y: integer): integer;
external;
{call by ref.}
begin
writeln(’Bitte die beiden Summanden eingeben!’);
readln(a); readln(b);
write(’Die Summanden sind: ’); write(a); writeln(b);
s := a + b;
write(’Die Summe (direkt) ist: ’); writeln(s);
s := psv(a, b);
write(’Die Summe ist: ’); writeln(s);
write(’Die Summanden sind: ’); write(a); writeln(b);
s := psr(a, b);
write(’Die Summe ist: ’); writeln(s);
write(’Die Summanden sind: ’); write(a); writeln(b);
end.
Quelle 2.47 : PASCAL-Programm, das Parameter by value und by reference
¨
an PASCAL-Funktionen ubergibt
¨
Sollten Sie die Beispiele nachvollzogen haben, mußte
Ihr Linker in zwei
¨
Fallen
mit einer Fehlermeldung unsatisfied symbol: output (data)
die Arbeit verweigert haben. Die PASCAL-Funktionen psv() und psr() geben etwas auf das Terminal aus. Bei getrennt kompilierten Modulen erfordert
dies die Zeile:
import StdOutput;
Das importierte, vorgefertigte PASCAL-Modul StdOutput macht von einem
Textfile output Gebrauch, das letzten Endes der Bildschirm ist. Im PASCALProgramm o¨ ffnet die Zeile
program psummep (input, output);
dieses Textfile. In C-Programmen wird das File mit dem Filepointer stdout
ebenso wie in FORTRAN-Programmen die Unit 6 automatisch ge¨offnet. Hinter dem Filepointer bzw. der Unit steckt der Bildschirm. Leider sehen wir –
¨
¨
in Ubereinstimmung
mit unseren Handbuchern
– keinen Weg, das PASCALFile output mit stdout von C oder der Unit 6 von FORTRAN zu verbinden.
Wollen wir PASCAL-Funktionen in ein C- oder FORTRAN-Programm einbin¨
den, mussen
die Funktionen auf Terminalausgabe verzichten (eine Ausgabe
¨ m¨oglich):
in ein File ware
{Pascal-Funktion (Summe) call by value, ohne Output}
{Compileraufruf pc -c xpsv.p}
134
2 Programmieren in C/C++
module b;
export
function psv(x, y: integer): integer;
implement
function psv;
var z: integer;
begin
z := x + y;
{ Aenderung der Summanden }
x := 77; y := 99;
psv := z;
end;
end.
¨
Quelle 2.48 : PASCAL-Funktion, die Parameter by value ubernimmt,
ohne
Ausgabe
{Pascal-Funktion (Summe) call by reference}
{ohne Output}
{Compileraufruf pc -c xpsr.p}
module a;
export
function psr(var x, y: integer): integer;
implement
function psr;
var z: integer;
begin
z := x + y;
{ Aenderung der Summanden }
x := 66; y := 88;
psr := z;
end;
end.
¨
Quelle 2.49 : PASCAL-Funktion, die Parameter by reference ubernimmt,
ohne
Ausgabe
Damit geht es. Der Compilerbauer weiß, wie die einzelnen Programmier¨
¨
sprachen ihre Ausgabe bewerkstelligen und kann Uberg
ange
in Form von
Compiler-Anweisungen oder Zwischenfunktionen einrichten. So macht es Microsoft bei seinem großen C-Compiler. Aber wenn nichts vorgesehen ist, muß
¨
der gew¨ohnliche Programmierer solche Unvertraglichkeiten
hinnehmen.
¨
¨
Auch Shellscripts k¨onnen Funktionen aufrufen. Diese mussen
selbstandige Programme wie externe Kommandos sein, der Mechanismus sieht etwas
anders aus. Hier das Shellscript:
# Shellscript, das eine C-Funktion aufruft. 28.01.1988
# Filename shsumme
print Bitte die beiden Summanden eingeben!
read a; read b
2.4 Funktionen
print
print
print
print
exit
Die
Die
Die
Die
135
Summanden sind $a $b
Shell-Summe ist ‘expr $a + $b‘
Funktions-Summe ist ‘cssh $a $b‘
Summanden sind $a $b
¨
Quelle 2.50 : Shellscript mit Parameterubergabe
Die zugeh¨orige C-Funktion ist ein Hauptprogramm:
/* C-Programm zum Aufruf durch Shellskript, 29.01.1988 */
/* Compileraufruf: cc -o cssh cssh.c */
int main(int argc, char *argv[])
{
int x, y;
sscanf(argv[1], "%d", &x);
sscanf(argv[2], "%d", &y);
printf("%d", (x + y));
return 0;
}
¨
Quelle 2.51 : C-Programm, das Parameter von einem Shellscript ubernimmt
Ferner k¨onnen Shellscripts Shellfunktionen aufrufen, siehe das Shellscript ?? Turme
¨
von Hanoi auf Seite ??.
Entschuldigen Sie bitte, daß dieser Abschnitt etwas breit geraten ist.
¨
Die Parameterubergabe
muß sitzen, wenn man mehr als Trivialprogramme
¨
schreibt, und man ist nicht immer in der glucklichen
Lage, rein in C programmieren zu k¨onnen. Verwendet man vorgegebene Bibliotheken, so sind diese
manchmal in einer anderen Programmiersprache verfaßt. Dann hat man sich
¨
mit einer fremden Syntax und den kleinen, aber bedeutsamen Unvertraglichkeiten herumzuschlagen.
2.4.4
Kommandozeilenargumente, main()
Auch das Hauptprogramm main() ist eine Funktion, die Parameter oder Ar¨
gumente ubernehmen
kann, und zwar aus der Kommandozeile beim Aufruf
des Programms. Sie kennen das von vielen UNIX-Kommandos, die nichts anderes als C-Programme sind.
Der Mechanismus ist stets derselbe. Die Argumente, getrennt durch
¨
Spaces oder Ahnliches,
werden in ein Array of Strings mit dem Namen argv
¨
¨
(Argumentvektor) gestellt. Gleichzeitig zahlt
ein Argumentzahler
argc
¨
die Anzahl der ubergebenen
Argumente, wobei der Funktionsname selbst das
erste Argument (Index 0) ist. Bei einem Programmaufruf ohne Argumente
¨
steht also der Programmname in argv[0], der Argumentzahler
argc hat
¨
den Wert 1. Das erste nichtbelegte Element des Argumentvektors enthalt
einen leeren String. Die Umwandlung der Argumente vom Typ String in den
¨
gewunschten
Typ besorgt die Funktion sscanf(3).
136
2 Programmieren in C/C++
Der Anfang eines Hauptprogrammes mit Kommandozeilenargumenten
sieht folgendermaßen aus:
int main(int argc, char *argv[])
{
char a; int x;
if (argc < 3) {
puts("Zuwenige Parameter");
exit(-1);
}
sscanf(argv[1], "%c", &a);
sscanf(argv[2], "%d", &x);
....
¨
Quelle 2.52 : C-Programm, das Argumente aus der Kommandozeile ubernimmt
Das erste Kommandozeilenargument (nach dem Kommando selbst) wird
als Zeichen verarbeitet, das zweite als ganze Zahl. Etwaige weitere Argumente fallen unter den Tisch.
Die Funktion main() ist immer vom Typ extern int. Da dies der
¨ Funktionen ist, k¨onnte die Typdeklaration weggelassen werDefaulttyp fur
¨
den. Sie kann Argumente ubernehmen,
braucht es aber nicht. Infolgedessen
¨
sind folgende Deklarationen gultig:
main()
int main()
extern int main()
main(void)
int main(void)
extern int main(void)
main(int argc, char *argv[])
int main(int argc, char *argv[])
extern int main(int argc, char *argv[])
main(int argc, char **argv)
int main(int argc, char **argv)
extern int main(int argc, char **argv)
und alle anderen falsch. Die ersten sechs sind in ihrer Bedeutung gleich, die
weiteren gelten bei Argumenten in der Kommandozeile. Die Norm ISO/IEC
¨ C-Programme, die unter einem Betriebssystem laufen
9899:1999 sieht fur
(hosted environment), nur die beiden folgenden Formen vor:
int main(void)
int main(int argc, char *argv[])
und das reicht auch. Unter POSIX-konformen Betriebssystemen kann ein
drittes Argument hinzukommen, das die Umgebung (environment pointer)
¨
enthalt:
2.4 Funktionen
137
int main(int argc, char *argv[], char *envp[])
¨
¨
Den Ruckgabewert
von main() sollte man nicht dem Zufall uberlassen,
son¨
dern mit einer return-Anweisung ausdrucklich
festlegen (0 bei Erfolg). Er
¨
wird von der Shell ubernommen.
2.4.5
Funktionen mit wechselnder Argumentanzahl
Mit main() haben wir eine Funktion kennengelernt, die eine wechseln¨
¨ andere Funktionen als
de Anzahl von Argumenten ubernimmt.
Auch fur
main() gibt es einen Mechanismus zu diesem Zweck, schauen Sie bitte unter
¨
¨
varargs(5) nach. Der Mechanismus ist nicht uberm
aßig
intelligent, sondern an einige Voraussetzungen gebunden:
• Es muß mindestens ein Argument vorhanden sein,
• der Typ des ersten Arguments muß bekannt sein,
¨ das Ende der Argumentliste bekannt sein.
• es muß ein Kriterium fur
¨
Die erforderlichen Makros stehen in den include-Files <varargs.h> fur
¨ ANSI-C. Wir erklaren
¨
UNIX System V oder <stdarg.h> fur
die Vorgehensweise an einem Beispiel, das der Funktion printf(3) nachempfunden ist (es
¨
ist damit nicht gesagt, daß printf(3) tatsachlich
so aussieht):
/* Funktion printi(), Ersatz fuer printf(), nur fuer
dezimale Ganzzahlen, Zeichen und Strings. Siehe
Referenz-Handbuch unter varargs(5), 22.02.91 */
/* Returnwert 0 = ok, -1 = Fehler, sonst wie printf() */
/* Compileraufruf cc -c printi.c */
#include <stdio.h>
#include <varargs.h>
int fputc();
void int print();
/* Funktion printi(), variable Anzahl von Argumenten */
int printi(va alist)
va dcl
{
va list pvar;
unsigned long arg;
int field, sig;
char *format, *string;
long ivar;
/* Uebernahme und Auswertung des Formatstrings */
va start(pvar);
format = va arg(pvar, char *);
while (1) {
138
2 Programmieren in C/C++
/* Ausgabe von Literalen */
while ((*format != ’%’) && (*format != ’\0’))
fputc(*format++, stdout);
/* Ende des Formatstrings */
if (*format == ’\0’) {
va end(pvar);
return 0;
}
/* Prozentzeichen, Platzhalter */
format++;
field = 0;
/* Auswertung Laengenangabe */
while (*format >= ’0’ && *format <=’9’) {
field = field * 10 + *format - ’0’;
format++;
}
/* Auswertung Typangabe und Ausgabe des Arguments */
switch(*format) {
case ’d’:
sig = ((ivar = (long)va arg(pvar, int)) < 0 ? 1 : 0);
arg = (unsigned long)(ivar < 0 ? -ivar : ivar);
int print(arg, sig, field);
break;
case ’u’:
arg = (unsigned long)va arg(pvar, unsigned);
int print(arg, 0, field);
break;
case ’l’:
switch(*(format + 1)) {
case ’d’:
sig = ((ivar = va arg(pvar, long)) < 0 ? 1 : 0);
arg = (unsigned long)(ivar < 0 ? -ivar : ivar);
int print(arg, sig, field);
break;
case ’u’:
arg = va arg(pvar, unsigned long);
int print(arg, 0, field);
break;
default:
va end(pvar);
return -1;
/* unbekannter Typ */
}
format++;
break;
2.4 Funktionen
139
case ’%’:
fputc(*format, stdout);
break;
case ’c’:
fputc(va arg(pvar, char), stdout);
break;
case ’s’:
string = va arg(pvar, char *);
while ((fputc(*(string++), stdout)) != ’\0’) ;
break;
default:
va end(pvar);
return -1;
/* unbekannter Typ */
}
format++;
}
}
/* Funktion zur Ausgabe der dezimalen Ganzzahl */
void int print(unsigned long number,int signum,int field)
{
int i;
char table[21];
long radix = 10;
for (i = 0; i < 21; i++)
*(table + i) = ’ ’;
/* Umwandlung Zahl nach ASCII-Zeichen */
for (i = 0; i < 20; i++) {
*(table + i) = *("0123456789" + (number % radix));
number /= radix;
if (number == 0) break;
}
/* Vorzeichen */
if (signum)
*(table + ++i) = ’-’;
/* Ausgabe */
if ((field != 0) && (field < 20))
i = field -1;
while (i >= 0)
fputc(*(table + i--), stdout);
}
/* Ende */
140
2 Programmieren in C/C++
Quelle 2.53 : C-Funktion mit wechselnder Anzahl von Argumenten
Nach dem include-File varargs.h folgt in gewohnter Weise die Funktion, hier printi(). Ihre Argumentenliste heißt va_alist und ist vom Typ
va_dcl, ohne Semikolon! Innerhalb der Funktion brauchen wir einen Pointer
pvar auf die Argumente, dieser ist vom Typ va_list, nicht zu verwechseln
mit der Argumentenliste va_alist. Die weiteren Variablen sind unverbindlich.
Zu Beginn der Arbeit muß das Makro va_start(pvar) aufgerufen werden. Es initialisiert den Pointer pvar mit dem Anfang der Argumentenliste.
Am Ende der Arbeit muß entsprechend mit dem Makro va_end(pvar) auf¨
geraumt
werden.
¨
Das Makro va_arg(pvar, type) gibt das Argument zuruck,
auf das der
Pointer pvar zeigt, und zwar in der Form des angegebenen Typs, den man
also kennen muß. Gleichzeitig wird der Pointer pvar eins weiter geschoben.
Die Zeile
format = va_arg(pvar, char *);
weist dem Pointer auf char format die Adresse des Formatstrings in der Argumentenliste von printi() zu. Damit ist der Formatstring wie jeder andere
¨
¨
String zuganglich.
Zugleich wird der Pointer pvar auf das nachste
Argument
¨
gestellt, ublicherweise
eine Konstante oder Variable. Aus der Auswertung des
Formatstrings ergeben sich Anzahl und Typen der weiteren Argumente.
Damit wird auch klar, was geschieht, wenn die Platzhalter (%d, %6u usw.)
¨
im Formatstring nicht mit der Argumentenliste ubereinstimmen.
Gibt es
mehr Argumente als Platzhalter, werden sie nicht beachtet. Gibt es mehr
Platzhalter als Argumente, wird irgendein undefinierter Speicherinhalt gele¨
sen, unter Umstanden
auch der dem Programm zugewiesene Speicherbereich
¨
verlassen. Stimmen Platzhalter und Argumente im Typ nicht uberein,
wird
der Pointer pvar falsch inkrementiert, und die Typumwandlung geht vermutlich auch daneben.
Es gibt eine Fallgrube bei der Typangabe. Je nach Compiler werden die
Typen char und short intern als int und float als double verarbeitet.
¨
In solchen Fallen
muß dem Makro va_arg(pvar, type) der interne Typ
mitgeteilt werden. Nachlesen oder ausprobieren, am besten beides.
2.4.6
Iterativer Aufruf einer Funktion
Unter einer Iteration versteht man die Wiederholung bestimmter Pro¨ die
grammschritte, wobei das Ergebnis eines Schrittes als Eingabe fur
¨
¨
nachste
Wiederholung dient. Viele mathematische Naherungsverfahren
ma¨
chen von Iterationen Gebrauch. Programmtechnisch fuhren
Iterationen auf
Schleifen. Entsprechend muß eine Bedingung angegeben werden, die die
Iteration beendet. Da auch bei einem richtigen Programm eine Iteration
¨
manchmal aus mathematischen Grunden
nie zu einem Ende kommt, ist es
2.4 Funktionen
141
¨
¨ solche Falle
¨
zweckmaßig,
einen Test fur
einzubauen wie in folgendem Beispiel:
/* Quadratwurzel, Halbierungsverfahren, 14.08.92 */
/* Compileraufruf cc -o wurzel wurzel.c */
#define
#define
EPS 0.00001
MAX 100
#include <stdio.h>
void exit();
int main(int argc,char *argv[])
{
int i;
double a, b, c, m;
if (argc < 2) {
puts("Radikand fehlt.");
exit(-1);
}
/* Initialisierung */
i = 0;
sscanf(argv[1], "%lf", &c);
sscanf(argv[1], "%lf", &c);
a = 0;
b = c + 1;
/* Iteration */
while (b - a > EPS) {
m = (a + b) / 2;
if (m * m - c <= 0)
a = m;
else
b = m;
/* Begrenzung der Anzahl der Iterationen */
i++;
if (i > MAX) {
puts("Zuviele Iterationen! Ungenau!");
break;
}
}
/* Ausgabe und Ende */
printf("Die Wurzel aus %lf ist %lf\n", c, m);
printf("Anzahl der Iterationen: %d\n", i);
142
2 Programmieren in C/C++
exit(0);
}
Quelle 2.54 : C-Programm zur iterativen Berechnung der Quadratwurzel
Die Funktion, die iterativ aufgerufen wird, ist die Mittelwertbildung von a
¨
und b; es lohnt sich nicht, sie auch programmtechnisch als selbstandige
Funktion zu definieren, aber das kann in anderen Aufgaben anders sein.
2.4.7
Rekursiver Aufruf einer Funktion
Bei einer Rekursion ruft eine Funktion sich selbst auf. Das ist etwas schwie¨
rig vorzustellen und nicht in allen Programmiersprachen erlaubt. Die Nahe
¨
zum Zirkelschluß ist nicht geheuer. Es gibt aber Probleme, die ursprunglich
rekursiv sind und sich durch eine Rekursion elegant programmieren lassen.
Eine Zirkeldefinition ist eine Definition eines Begriffes, die diesen selbst in
¨ damit es nicht sofort auffallt,
¨
der Definition enthalt,
gegebenenfalls um einige
Ecken herum. Ein Zirkelschluß ist eine Folgerung, die Teile der zu beweisenden Aussage bereits zur Voraussetzung hat. Bei einer Rekursion hingegen
• wiederholt sich die Ausgangslage nie,
¨
• wird eine Abbruchbedingung nach endlich vielen Schritten erfullt,
d. h.
die Rekursionstiefe ist begrenzt.
¨
In dem Buch von R OBERT S EDGEWICK findet sich Naheres
zu diesem Thema,
mit Programmbeispielen. Im ersten Band der Informatik von F RIEDRICH L.
B AUER und G ERHARD G OOS wird die Rekursion allgemeiner abgehandelt.
Zwei Beispiele sollen die Rekursion veranschaulichen. Das erste Programm berechnet den gr¨oßten gemeinsamen Teiler (ggT) zweier ganzer Zahlen nach dem Algorithmus von E UKLID. Das zweite ermittelt rekursiv die
¨ einer Zahl, was man anders vielleicht einfacher erledigen k¨onnte.
Fakultat
/* Groesster gemeinsamer Teiler, Euklid, rekursiv */
/* Compileraufruf cc -o ggtr ggtr.c */
#include <stdio.h>
int ggt();
int main(int argc,char *argv[])
{
int x, y;
sscanf(argv[1], "%d", &x); sscanf(argv[2], "%d", &y);
printf("Der GGT von %d und %d ist %d.\n", x, y, ggt(x, y));
return 0;
}
/* Funktion ggt() */
2.4 Funktionen
143
int ggt(int a,int b)
{
if (a == b) return a;
else if (a > b) return(ggt(a - b, b));
else return(ggt(a, b - a));
}
Quelle 2.55 : C-Programm Gr¨oßter gemeinsamer Teiler (ggT) nach Euklid,
rekursiv
¨ die Verwendung der
Im folgenden Programm ist außer der Rekursivitat
¨
Bedingten Bewertung interessant, die den Code verkurzt.
/* Rekursive Berechnung von Fakultaeten */
#include <stdio.h>
int main()
{
int n;
puts("\nWert eingeben, Ende mit CTRL-D");
while (scanf("%d", &n) != EOF)
printf("\n%d Fakultaet ist %d.\n\n", n, fak(n));
return 0;
}
/* funktion fak() */
int fak(int n)
{
return(n <= 1 ? 1 : n * fak(n - 1));
}
¨
Quelle 2.56 : C-Programm zur rekursiven Berechnung der Fakultat
¨
Weitere rekursiv l¨osbare Aufgaben sind die Turme
von Hanoi und Quicksort. Rekursive Probleme lassen sich auch iterativ l¨osen. Das kann sogar
schneller gehen, aber die Eleganz bleibt auf der Strecke.
Da in C auch das Hauptprogramm main() eine Funktion ist, die auf gleicher Stufe mit allen anderen Funktionen steht, kann es sich selbst aufrufen:
/* Experimentelles Programm mit Selbstaufruf von main() */
#include <stdio.h>
int main()
{
puts("Selbstaufruf von main()");
main();
return(13);
}
Quelle 2.57 : C-Programm, in dem main() sich selbst aufruft
144
2 Programmieren in C/C++
Das Programm wird von lint(1) nicht beanstandet, einwandfrei kompi¨
liert und lauft,
bis der Speicher platzt, da die Rekursionstiefe nicht begrenzt
ist (Abbruch mit break). Allerdings ist ein Selbstaufruf von main() unge¨
brauchlich.
2.4.8
Assemblerroutinen
Auf die Assemblerprogrammierung wurde in Abschnitt 2.1.4 Programmiersprachen auf Seite 26 bereits eingegangen. Da das Schreiben von Program¨
¨
men in Assembler muhsam
ist und die Programme nicht portierbar sind, laßt
¨
man nach M¨oglichkeit die Finger davon. Es kann jedoch zweckmaßig
sein,
einfache, kurze Funktionen auf Assembler umzustellen. Einmal kann man
so unmittelbar auf die Hardware zugreifen, beispielsweise in Anwendungen
zum Messen und Regeln, zum anderen zur Beschleunigung oft wiederholter
Funktionen.
/* fakul.c Berechnung von Fakultaeten */
/* Die Grenze fuer END liegt in der Segmentgroesse */
/* bis 260 werden alle Werte in einem Array gespeichert,
darueber wird Wert fuer Wert berechnet und ausgegeben */
/* Ziffern in Neunergruppen, nutzt long aus */
#define
#define
#define
#define
#define
END 260
MAX 1023
DEF
16
GRP
58
GMX 245
/* GRP muss in aadd.asm eingetragen werden */
/* GMX muss in laadd.asm eingetragen werden */
#include <stdio.h>
unsigned long f[END + 1][GRP];
/* global */
void add(unsigned long *, unsigned long *);
void exit(int);
long time(long *);
/* Assemblerfunktionen zur Beschleunigung &/
extern void aadd(unsigned long *, unsigned long *);
extern void lshift(unsigned long *);
/* Hauptprogramm */
int main(int argc, char *argv[])
{
int e, i, j, k, r, s, flag, ende, max = DEF;
unsigned long x[GRP];
2.4 Funktionen
145
unsigned long *z;
long z1, z2, z3;
/* Auswertung der Kommandozeile */
if (argc > 1) {
sscanf(*(argv + 1), "%d", &max);
max = (max < 0) ? -max : max;
if (max > MAX) {
printf("\nZahl zu gross! Maximal %d\n", MAX);
exit(1);
}
}
ende = (max > END) ? END : max;
time(&z1);
/* Zeit holen */
/* Rechnung */
**f = (unsigned long)1;
for (i = 1; i <= ende; i++) {
for (j = 0; j < GRP; j++)
/*
*(x + j) = 0;
k = i/4;
for (j = 1; j <= k; j++) {
/*
aadd(x, *(f + i - 1));
}
lshift(x);
lshift(x);
for (k = 0; k < (i % 4); k++)
aadd(x, *(f + i - 1));
for (j = 0; j < GRP; j++) { /*
*(*(f + i) + j) = *(x +
x nullsetzen */
addieren */
zurueckschreiben */
j);
/* *(*(f + i) + j) ist dasselbe wie f[i][j] */
}
}
time(&z2);
/* Zeit holen */
/* Ausgabe, fuehrende Nullen unterdrueckt */
printf("\n\tFakultaeten von 0 bis %4d\n", max);
for (i = 0; i <= ende; i++) {
flag = 0;
printf("\n\t%4d ! =
", i);
for (j = GRP - 1; j >= 0; j--) {
if (!(*(*(f + i) + j)) && !flag);
else
if (!flag) {
146
2 Programmieren in C/C++
printf("%9lu ", *(*(f + i) + j));
flag = 1;
}
else
printf("%09lu ", *(*(f + i) + j));
}
}
/* falls wir weitermachen wollen, muessen wir das Array
f[261][58] umfunktionieren in f[2][*].
In f[0] steht vorige Fakultaet, in f[1] wird addiert. */
if (max > END) {
/* f[0] einrichten */
e = GMX;
/* kleiner 7296 */
for (j = 0; j < e; j++)
*(*f + j) = 0; /* f[0] nullsetzen */
aadd(f[0], f[END]);
/* vorige Fak. addieren */
/* Rechnung wie gehabt */
r = 0; s = e;
for (i = END + 1; i <= max; i++) {
for (j = 0; j < e; j++)
/* f[1] nullen */
*(*(f + s) + j) = 0;
k = i/4;
for (j = 1; j <= k; j++) { /* addieren */
laadd(*(f + s), *(f + r));
}
lshift(*(f + s));
lshift(*(f + s));
for (k = 0; k < (i % 4); k++)
laadd(*(f + s), *(f + r));
flag = 0;
/* f[1] anzeigen */
printf("\n\n\t%4d ! =
", i);
for (j = e - 1; j >= 0; j--) {
if (!(*(*(f + s) + j)) && !flag);
else
if (!flag) {
printf("%9lu ", *(*(f + s) + j));
flag = 1;
}
else
printf("%09lu ", *(*(f + s) + j));
}
r = (r > 0) ? 0 : e; /* f[1] wird das naechste f[0] */
s = (s > 0) ? 0 : e;
2.4 Funktionen
147
}
}
/* Ende Weitermachen */
/* Anzahl der Stellen von max! */
if (max > END) {
ende = r; j = GMX - 1;
}
else {
j = GRP - 1;
}
flag = 0;
for (; j >= 0; j--) {
if (!(*(*(f + ende) +
;
else
if (!flag) {
unsigned long
flag = 1;
for (i = 1; i
if (*(*(f
j)) && !flag)
z = 10;
< 9; i++) {
+ ende) + j) / z) {
flag++;
z *= 10;
}
else
break;
}
}
else
flag += 9;
}
time(&z3);
/* Zeit holen */
printf("\n\n\tZahl %4d ! hat %4d Stellen.\n", max, flag);
if (max > END)
printf("\tRechnung+Ausgabe brauchten %4ld s.\n", z3 - z1);
else {
printf("\tDie Rechnung brauchte
%4ld s.\n", z2 - z1);
printf("\tDie Ausgabe brauchte
%4ld s.\n", z3 - z2);
}
return 0;
}
¨
Quelle 2.58 : C-Programm zur Berechnung von Fakultaten
¨
Das vorstehende Beispiel mit Microsoft Quick C und Quick Assembler fur
den IBM-PC bietet einen einfachen Einstieg in die Assemblerprogrammierung, da das große Programm nach wie vor in einer h¨oheren Sprache abgefaßt
148
2 Programmieren in C/C++
ist. Das Beispiel ist in einer zweiten Hinsicht interessant. Auf einer 32-Bit¨
Maschine liegt die gr¨oßte vorzeichenlose Ganzzahl etwas uber
4 Milliarden.
Damit kommen wir nicht weit, denn es ist bereits:
(2.3)
13! = 6227020800
Wir stellen unsere Ergebnisse dar durch ein Array von langen Ganzzahlen,
und zwar packen wir immer neun Dezimalstellen in ein Array-Element:
unsigned long f[END + 1][GRP]
¨
Bei asymmetrischen Verschlusselungsverfahren
braucht man große Zahlen.
¨
Die Arithmetik zu diesem Datentyp mussen
wir selbst schreiben. Dazu erset¨
zen wir die eigentlich bei der Berechnung von Fakultaten
erforderliche Multiplikation durch die Addition. Diese beschleunigen wir durch Einsatz einer
Assemblerfunktion aadd():
COMMENT +
C-Funktion aadd() in MS-Assembler, die ein
Array of unsigned long in ein zweites Array
addiert, Parameter Pointer auf die Arrays.
+
grp
milliarde
.MODEL
.CODE
EQU
DD
small,c
4 * 58
1000000000
; fuer laadd() obige Zeile austauschen
; grp
EQU
4 * 245
aadd
PROC
; siehe C-Programm
; siehe C-Programm
USES SI, y:PTR DWORD, g:PTR DWORD
sub
cx,cx
sub
si,si
clc
; for-Schleife nachbilden
for1:
; aktuelles Element in den Akku holen, long = 4 Bytes!
mov
bx,y
mov
ax,WORD PTR [bx+si][0]
mov
dx,WORD PTR [bx+si][2]
; Uebertrag zu Akku addieren
add
ax,cx
adc
dx,0
; vorige Fakultaet zu Akku addieren, Uebertrag beachten
mov
bx,g
add
ax,WORD PTR [bx+si][0]
adc
dx,WORD PTR [bx+si][2]
; Summe durch 10 hoch 9 dividieren, Quotient ergibt
; Uebertrag ins naechste Element des Arrays, Rest
: ergibt aktuelles Element.
2.4 Funktionen
; zweite for-Schleife:
sub
for2:
cmp
jl
sub
sbb
inc
jmp
fertig:
; Rest zurueckschreiben
mov
mov
mov
; Schleifenzaehler um 4
add
; Ruecksprungbedingung
cmp
je
jmp
; Ende der Funktion
done:
ret
aadd
ENDP
END
149
cx,cx
dx,WORD PTR milliarde[2]
SHORT fertig
ax,WORD PTR milliarde[0]
dx,WORD PTR milliarde[2]
cx
SHORT for2
in aktuelles Array
bx,y
WORD PTR [bx+si][0],ax
WORD PTR [bx+si][2],dx
(long!) erhoehen
si,4
si,grp
SHORT done
SHORT for1
Quelle 2.59 : Assemblerfunktion 1 zur Addition von Feldern
¨
Die Fakultaten
werden berechnet, gespeichert und zum Schluß zusammen
ausgegeben. So k¨onnen wir die Rechenzeit von der Ausgabezeit trennen. Es
¨
zeigt sich, daß die Rechenzeit bei Ganzzahl-Arithmetik gegenuber
der Bildschirmausgabe keine Rolle spielt.
Auf diesem Weg kommen wir bis in die Gegend von 260!, dann ist ein Speichersegement (64 KByte) unter PC-DOS voll. Wir k¨onnen nicht mehr alle
Ergebnisse speichern, sondern nur die vorangegangene und die laufende Fa¨ Sowie ein Ergebnis vorliegt, wird es ausgegeben. Die Assemblerfunkkultat.
tion laadd() zur Addition unterscheidet sich in einer Zeile am Anfang. Die
im Programm vorgesehene Grenze M AX = 1023 ist noch nicht die durch das
¨
Speichersegment bestimmte Grenze, sondern willkurlich.
Irgendwann erheben sich Zweifel am Sinn großer Zahlen. Selbst als Tapetenmuster wirken sie
etwas eint¨onig.
2.4.9
Memo Funktionen
• C-Programme sind aus gleichberechtigten Funktionen aufgebaut. Zu
diesen geh¨ort auch main().
¨
• Eine Funktion ubernimmt
bei ihrem Aufruf einen festgelegten Satz von
Parametern oder Argumenten. Der Satz beim Aufruf muß mit dem Satz
¨
bei der Definition nach Anzahl, Typ und Reihenfolge ubereinstimmen
wie Stecker und Kupplung einer elektrischen Steckverbindung.
150
2 Programmieren in C/C++
¨
• Bei der Parameterubergabe
by value arbeitet die Funktion mit Ko¨
pien der ubergebenen
Parameter, kann also die Originalwerte nicht
¨
verandern.
¨
¨
• Bei der Parameterubergabe
by reference erfahrt
die Funktion die Adres¨
sen (Pointer) der Originalwerte und kann diese verandern.
Das ist
¨
gefahrlicher,
aber manchmal gewollt. Beispiel: scanf().
¨
• Auch die Funktion main() kann Argumente ubernehmen,
und zwar aus
der Kommandozeile. Die Argumente stehen in einem Array of Strings
(Argumentvektor).
• Es gibt auch Funktionen wie printf(), die eine von Aufruf zu Aufruf
¨
wechselnde Anzahl von Argumenten ubernehmen.
Der Mechanismus ist
an einige Voraussetzungen gebunden.
• Eine Funktion gibt keinen oder genau einen Wert als Ergebnis an die
¨
aufrufende Funktion zuruck.
Dieser Wert kann ein ein Pointer sein.
• In C darf eine Funktion sich selbst aufrufen (rekursiver Aufruf).
• Assemblerfunktionen innerhalb eines C-Programms k¨onnen den Ablauf
beschleunigen. Einfacher wird das Programm dadurch nicht.
2.4.10
¨
Ubung
Funktionen
¨
¨
Jetzt verfugen
Sie uber
die Kenntnisse, die zum Schreiben einfacher CProgramme notwendig sind. Schreiben das Programm zur Weganalyse, aufbauend auf der Aufgabenanalyse und der Datenstruktur, die Sie bereits erarbeitet haben. Falls Sie sich an den Vokabeltrainer wagen wollen, reduzieren
¨
Sie die Aufgabe zunachst
auf ein Minimum, sonst werden Sie nicht fertig damit.
2.5
Funktions-Bibliotheken
2.5.1 Zweck und Aufbau
Eine Funktion kann auf drei Wegen mit einem C-Hauptprogramm main()
verbunden werden:
• Die Funktion steht im selben File wie main() und wird daher gemeinsam kompiliert. Sie muß wie main() in C geschrieben sein, mehrsprachige Compiler gibt es nicht.
¨
• Die Funktion steht – unter Umstanden
mit weiteren Funktionen – in einem eigenen File, das getrennt kompiliert und beim Linken zu main()
gebunden wird. Dabei werden alle Funktionen dieses Files zu main()
gebunden, ob sie gebraucht werden oder nicht. Wegen der getrennten
Compilierung darf das File in einer anderen Programmiersprache ge¨ dieselbe Maschine kompiliert sein.
schrieben, muß aber fur
2.5 Funktions-Bibliotheken
151
• Die getrennt kompilierte Funktion steht zusammen mit weiteren in ei¨
ner Bibliothek und wird beim Linken zu main() gebunden. Dabei wahlt
der Linker nur die Funktionen aus der Bibliothek aus, die in main() gebraucht werden. Man kann also viele Funktionen in einer Bibliothek zu¨
¨
sammenfassen, ohne befurchten
zu mussen,
seine Programme mit Ballast zu befrachten. Die Bibliothek kann auf Quellfiles unterschiedlicher
¨
¨
¨ dasselbe SysProgrammiersprachen zuruckgehen.
Sie mussen
nur fur
tem kompiliert worden sein; es macht keinen Sinn und ist auch nicht
¨ UNIX und PC-DOS in einer Bibliothek zu verm¨oglich, Funktionen fur
einigen.
Das Erzeugen einer Bibliothek auf UNIX-Systemen wurde bereits im Abschnitt 2.2.6 Bibliotheken, Archive auf Seite 51 im Rahmen der Programmer’s
¨
Workbench erlautert.
Im folgenden geht es um die Verwendung von Bibliotheken.
2.5.2
Standardbibliothek
2.5.2.1
¨
Ubersicht
Standardfunktionen sind die Funktionen, die als Standardbibliothek zusammen mit dem Compiler geliefert werden. Sie sind im strengen Sinn nicht
Bestandteil der Programmiersprache – das bedeutet, daß sie ersetzbar sind
¨
– aber der ANSI-Standard fuhrt
eine minimale Standardbibliothek auf. Ohne sie k¨onnte man kaum ein Programm in C schreiben. Der Reichtum der
¨
Standardbibliothek ist eine Starke
von C; in ihr steckt viel Arbeit, die andere
¨ uns erledigt haben. Die Systemaufrufe (Sektion 2)
Programmierer vor und fur
geh¨oren dagegen nicht zur Standardbibliothek (Sektion 3), sondern zum Betriebssystem. Und Shell-Kommandos sind eine Sache der Shell (Sektion 1).
Diese Unterscheidung spielt eine Rolle, wenn Programme portiert werden.
Soweit m¨oglich sind Standardfunktionen zu verwenden, da sie Eigenheiten
des Systems verdecken.
Die mit dem C-Compiler eines UNIX-Systems mitgelieferte Standardbibliothek wird im Referenz-Handbuch unter intro(3) vorgestellt und umfaßt
mehrere Teile:
• die Standard-C-Bibliothek, meist gekoppelt mit der Standard-InputOutput-Bibliothek, den Netzfunktionen und den Systemaufrufen (weil
sie zusammen gebraucht werden),
• die mathematische Bibliothek,
• gegebenenfalls eine grafische Bibliothek,
• gegebenenfalls eine Bibliothek mit Funktionen zum Messen und Regeln,
¨
• gegebenenfalls Datenbankfunktionen und weitere Spezialitaten.
¨ sie Include-Files mit Definitionen und Makros, die
Außer Funktionen enthalt
von den Funktionen ben¨otigt werden, im UNIX-File-System aber in einem
anderen Verzeichnis (/usr/include) liegen als die Funktions-Bibliotheken
(/lib und /usr/lib).
152
2.5.2.2
2 Programmieren in C/C++
Standard-C-Bibliothek
Die Standard-C-Bibliothek /lib/libc.a wird vom C-Compilertreiber cc(1)
eines UNIX-Systems aufgerufen und braucht daher nicht als Option mitgege¨ einen getrennten Linker-Aufruf lautet die Option -lc.
ben zu werden. Fur
Mit dem Kommando:
ar -t /lib/libc.a
schauen Sie sich das Inhaltsverzeichnis der Bibliothek an. Außer bekannten Funktionen wie printf() und Systemaufrufen wie stat(2) werden Sie
¨
viele Unbekannte treffen. Auskunft uber
diese erhalten Sie mittels der manSeiten, beispielsweise:
man ruserok
man insque
sofern die Funktionen zum Gebrauch durch Programmierer und nicht etwa
¨ interne Zwecke bestimmt sind.
nur fur
¨ die Ein- und Ausgabe stehen in C keine Operatoren zur
Input/Output Fur
¨
Verfugung,
sondern nur die Systemaufrufe des Betriebssystems (unter UNIX open(2), write(2), read(2) usw.) und die Standardfunktionen aus
der zum Compiler geh¨orenden Bibliothek. In der Regel sind die Funktionen
¨
vorzuziehen, da die Programme dann leichter auf andere Systeme ubertragen
werden k¨onnen. Die Eigenheiten der Systeme werden durch die Bibliothek
verdeckt. In diesem Fall ist im Programmkopf stets das Include-File stdio.h
einzubinden:
#include <stdio.h>
Diese Zeile ist fast in jedem C-Programm zu finden. In der Standardbibliothek stehen rund 40 Funktionen zur Ein- und Ausgabe bereit, von denen
die bekanntesten printf(3) zur formatierten Ausgabe nach stdout und
scanf(3) zur formatierten Eingabe von stdin sind.
Stringfunktionen Strings sind in C Arrays of Characters, abgeschlossen
mit dem ASCII-Zeichen Nr. 0, also nichts Besonderes. Trotzdem machen sie –
wie in vielen Programmiersprachen – Schwierigkeiten, wenn man ihre Syntax nicht beachtet. In der Standard-C-Bibliothek steht eine reiche Auswahl
von Stringfunktionen bereit. Gewarnt wird vor der Funktion gets(3), die
¨
einen String von stdin in ein Array einliest und dabei einen Uberlauf
ver¨
ursachen kann. Grundsatzlich
soll man beim Arbeiten mit Strings den Fall
¨
¨
berucksichtigen,
dass ein String gelegentlich langer
ist als der Puffer, in den
er geschrieben werden soll.
Da ein String – wie jedes Array – keinen Wert hat, kann er nicht per
Zuweisung einer Stringvariablen zugewiesen werden. Man muß vielmehr mit
den Standard-Stringfunktionen arbeiten oder sich selbst um die einzelnen
2.5 Funktions-Bibliotheken
153
¨
Elemente des Arrays kummern.
Die Stringfunktionen erwarten das includeFile string.h. Hier ein kurzes C-Programm zur Stringmanipulation mittels
Systemaufrufen und Standardfunktionen:
/* Programm fuer Stringmanipulation */
#define TEXT "textfile"
#include
#include
#include
#include
#include
<stdio.h>
<string.h>
<io.h>
<fcntl.h>
<string.h>
char buffer[80] = "Dies ist ein langer Teststring. Hallo!";
int main()
{
char
x, zeile[80];
int i;
int fildes;
FILE * fp;
/* Systemaufrufe und Filedeskriptoren */
fildes = open(TEXT, O RDWR);
if (fildes == -1)
puts("open schiefgegangen.");
write(fildes, buffer, 20);
lseek(fildes, (long)0, SEEK SET);
read(fildes, zeile, 12);
write(1, zeile, 12);
close(fildes);
/* Standardfunktionen und Filepointer */
fp = fopen(TEXT, "w");
for (i = 0; i < 30; i++)
fputc(buffer[i], fp);
fclose(fp);
fp = fopen(TEXT, "r");
for (i = 0; i < 30; i++)
zeile[i] = fgetc(fp);
putchar(’\n’);
for (i = 0; i < 30; i++)
putchar(zeile[i]);
/* Stringfunktionen */
strcpy(zeile, buffer);
printf("\n%s", zeile);
putstf("\n\nBitte eine Zeile eingeben:");
gets(zeile);
puts(zeile);
154
2 Programmieren in C/C++
strcat(zeile, " Prima!");
puts(zeile);
printf(zeile);
}
Quelle 2.60 : C-Programm zur Stringverarbeitung
¨
¨
Internet-Funktionen Eine Ubersicht
uber
diese Funktionen findet sich
in intro(3N). Beispiele sind Funktionen zur Verarbeitung von Netzadres¨
sen, Protokolleintragen,
Remote Procedure Calls, zum Mounten ferner FileSysteme, zur Verwaltung von Benutzern und Passw¨ortern im Netz. Geht
¨
uber
den Rahmen dieses Textes hinaus. Falls Sie sich ein eigenes Programm
¨
telnet oder ftp schreiben wollten, mußten
Sie hier tiefer einsteigen.
2.5.2.3
Standard-Mathematik-Bibliothek
Die Standard-Mathematik-Bibliothek wird vom C-Compilertreiber nicht
¨ C ist die Option -lm
automatisch aufgerufen – anders als in FORTRAN. Fur
¨
hinzuzufugen:
cc -o myprogram myprogram.c -lm
Ferner muß im Programmkopf die Zeile
#include <math.h>
¨ man uber
¨
stehen. Dann verfugt
Logarithmus, Wurzel, Potenz, trigonometrische und hyperbolische Funktionen. Weiteres siehe math(5).
Eigentlich sollte man bei diesen Funktionen den zugrunde liegenden Algorithmus und seine Programmierung kennen, da jedes numerische Verfahren und erst recht seine Umsetzung in ein Programm Grenzen haben, aber
¨
das Referenz-Handbuch beschrankt
sich unter trig(3) usw. auf die Syntax
¨ die Verwendung der mathematischen Biblioder Funktionen. Ein Beispiel fur
thek:
/* Potenz x hoch y; mathematische Funktionen; 22.12.92 */
/* zu compilieren mit cc -o potenz potenz.c -lm */
/* Aufruf: potenz x y */
#define EPSILON 0.00001
#include <stdio.h>
#include <math.h>
double pow(), floor();
int main(int argc,char *argv[])
{
double x, y, z;
if (argc < 3) {
2.5 Funktions-Bibliotheken
155
puts("Zuwenig Argumente");
return(-1);
}
/* Umwandlung Kommandozeilenargumente */
sscanf(argv[1], "%lf", &x);
sscanf(argv[2], "%lf", &y);
/* Aufruf Funktionen pow(), floor(), Sektion 3M */
/* wegen Fallunterscheidungen nachlesen! */
if ((x < 0 ? -x : x) < EPSILON) {
if (y > 0) x = 0;
else {
puts("Bei x = 0 muss y positiv sein.");
return(-1);
}
}
else {
if (x < 0) y = floor(y);
}
z = pow(x, y);
/* Ausgabe */
printf("%lf hoch %lf = %lf\n", x, y, z);
return 0;
}
Quelle 2.61 : C-Programm mit mathematischen Funktionen
¨
Der lint(1) gibt bei diesem Programm eine langere
Liste von Warnun¨
gen aus, die daher ruhren,
daß in <math.h> viele Funktionen deklariert werden, die im Programm nicht auftauchen. Das geht aber in Ordnung.
2.5.2.4
Standard-Grafik-Bibliothek
Zu manchen Compilern geh¨ort auch eine Sammlung von Grafikfunktionen.
¨ noch keinen Standard gibt und Grafik eng an die Hardware
Da es hierfur
gebunden ist, verzichten wir auf eine Darstellung. Auf einer UNIX-Anlage
¨ Funktionen zum
findet man sie in /usr/lib/plot. Die Bibliothek enthalt
Setzen von Punkten, Ziehen von Linien, zur Umwandlung von Koordinaten
¨
¨ es nicht Starbase,
und ahnliche
Dinge. Leider nicht standardisiert, sonst gabe
GKS, OpenGL, PHIGS, Uniras ...
2.5.2.5
Weitere Teile der Standardbibliothek
Die nicht zur Standard-C-Bibliothek geh¨orenden curses(3)-Funktionen aus
/usr/lib/libcurses.a erm¨oglichen die weitergehende Gestaltung eines
156
2 Programmieren in C/C++
alphanumerischen Bildschirms. In diesem Fall ist die curses(3)-Bibliothek
beim Compileraufruf zu nennen:
cc .... -lcurses
Vergißt man die Nennung, weiß der Compiler mit den Namen der
curses(3)-Funktionen nichts anzufangen und meldet sich mit der Fehleranzeige unsatisfied symbols.
Bei Verwendung von curses(3)-Funktionen ist das Include-File
curses.h in das Programm aufzunehmen, das stdio.h einschließt.
2.5.3
Xlib, Xt und Xm (X Window System)
Programme, die von dem X Window System Gebrauch machen wollen, greifen
¨
auf unterster Ebene auf Funktionen der Xlib-Bibliothek zuruck.
Die Xlib
¨ jede M¨oglichkeit des X-Protokolls eine C-Funktion bereit; sie ist die
stellt fur
Schnittstelle zwischen C-Programmen und dem X-Protokoll.
¨
Auf nachsth¨
oherer Ebene werden Funktionen einer Toolbox wie der XtBibliothek definiert, die ihrerseits auf der Xlib aufsetzt. Die Xt-Funktionen
werden auch als Intrinsics bezeichnet. Sie kennen z. B. Widgets, das sind Window Gadgets32 oder Objekte (im Sinne von C++) des Client-Programms. Zu einem Widget geh¨oren sein Fenster, sein Aussehen (look), sein Verhalten (feel)
und ein Satz von Methoden, die sein Verhalten realisieren. Ein Menu¨ oder ein
anklickbarer Druckknopf ist ein Widget.
Die dritte Schicht bilden Bibliotheken wie der Motif Toolkit Xm, der ei¨
ne Menge nach einheitlichen Regeln gebauter Widgets zur Verfugung
stellt.
¨
Wahrend
Xt nur abstrakte Fenster und Menus kennt, legt Xm fest, wie ein
¨ Wahrend
¨
(Motif-)Fenster oder -Menu¨ aussieht und wie es sich verhalt.
der
Quellcode von Xlib und Xt ver¨offentlicht ist, kostet die Xm eine Kleinigkeit.
Ein Programmierer versucht immer, mit der h¨ochsten Bibliothek zu arbeiten,
¨
weil er sich dabei am wenigsten um Einzelheiten zu kummern
braucht.
2.5.4
NAG-Bibliothek
Die NAG-Bibliothek der Numerical Algorithms Group, Oxford soll hier
¨ eine umfangreiche kommerzielle Bibliothek stehen, die
als ein Beispiel fur
bei vielen numerischen Aufgaben die Arbeit erleichtert. Die FORTRANBibliothek umfaßt etwa 1200 Subroutinen, die C-Bibliothek etwa 250 Funktionen. Sie stammen aus folgenden Gebieten:
• Nullstellen, Extremwerte,
• Differential- und Integralgleichungen,
• Fourier-Transformation,
• Lineare Algebra,
32 Ein
Gadget ist laut W¨orterbuch ein geniales Dingsbums.
2.5 Funktions-Bibliotheken
157
• nichtlineare Gleichungen,
• Statistik,
¨
• Naherungen,
Interpolation, Ausgleichsrechnung,
• Zufallszahlen usw.
¨
Naheres
unter http://www.nag.co.uk:80/numeric.html.
2.5.5
Eigene Bibliotheken
Wir haben bereits in Abschnitt 2.2.6 Bibliotheken, Archive auf Seite 51 gelernt, eine eigene Programmbibliothek mittels des UNIX-Kommandos ar(1)
¨
herzustellen. Zunachst
macht es Arbeit, seine Programmierergebnisse in eine
Bibliothek einzuordnen, aber wenn man einmal einen Grundstock hat, zahlt
es sich aus.
2.5.6
Speichermodelle (PC-DOS)
Unter UNIX gibt es keine Speichermodelle, infolgedessen auch nur eine Standardbibliothek. Unter PC-DOS hingegen ist die Speichersegmentierung zu
beachten, d. h. die Unterteilung des Arbeitsspeichers in Segmente zu je 64
¨
¨
kByte, ein lastiges
Uberbleibsel
aus uralten Zeiten. Die Adressierung der
¨
Speicherplatze
ist unterschiedlich, je nachdem ob man sich nur innerhalb ei¨ jedes Speichernes Segmentes oder im ganzen Arbeitsspeicher bewegt. Fur
modell ist eine eigene Standardbibliothek vorhanden. Das Speichermodell
¨
wird gewahlt
durch:
• die Angabe einer Compiler-Option oder
¨
• die Schlusselw¨
orter near, far oder huge im C-Programm (was unter
¨
UNIX-C zu einem Fehler fuhrt)
Wird keine der beiden M¨oglichkeiten genutzt, nimmt der Compiler einen
Default an, MS-Quick-C (qcl) beispielsweise das Modell small.
¨
Das Modell tiny (nicht von allen Compilern unterstutzt)
packt Code, Da¨ die Adressen (Pointer) reichen 2 Bytes.
ten und Stack in ein Segment; fur
Das gibt die schnellsten Programme, aber hinsichtlich des Umfangs von Pro¨
gramm und Daten ist man beschrankt.
Das Modell small packt Code und Daten in je ein Segment von 64 kByte.
¨
Damit lassen sich viele Aufgaben aus der PC-DOS-Welt bewaltigen.
¨ Daten und mehrere Segmente
Das Modell medium stellt ein Segment fur
¨ Programmcode zur Verfugung,
¨
fur
bis zur Grenze des freien Arbeitsspeichers.
¨
Typische Anwendungen sind langere
Programme mit wenigen Daten.
¨ sich umgekehrt wie medium: ein Segment fur
¨
Das Modell compact verhalt
¨ die Daten. Geeignet fur
¨ kurze Programme
den Code, mehrere Segmente fur
mit vielen Daten. Ein einzelnes Datenelement – ein Array beispielsweise –
darf nicht gr¨oßer als ein Segment sein.
158
2 Programmieren in C/C++
¨ jeweils mehrere Segmente fur
¨ Code und Daten zu,
Das Modell large laßt
wobei wieder ein einzelnes Datenelement nicht gr¨oßer als ein Segment sein
darf.
¨
Das Modell huge schließlich hebt auch diese letzte Beschrankung
auf, aber
¨
die Beschrankung
auf die Gr¨oße des freien Arbeitsspeichers bleibt, PC-DOS
schwoppt nicht.
¨
Die Schlusselw¨
orter near, far und huge in Verbindung mit Pointern oder
Funktionen haben Vorrang vor dem vom Compiler benutzten Speichermodell.
Bei near sind alle Adressen 16 Bits lang, bei far sind die Adressen 32 Bits
lang, die Pointerarithmetik geht jedoch von 16 Bits aus, und bei huge schlieߨ
lich lauft
alles mit 32 Bits und entsprechend langsam ab. Falls Ihnen das zu
kompliziert erscheint, steigen Sie einfach um auf UNIX.
2.5.7 Memo Bibliotheken
• Eine Bibliothek vereint eine Menge von Funktionen in einem einzigen
File.
¨
• Eine Bibliothek hat nichts mit Verschlusseln
oder Komprimieren zu tun.
• Beim Einbinden einer Bibliothek in den Kompiliervorgang werden ge¨
nau die ben¨otigten Funktionen ausgewahlt
und ins Programm eingebunden.
• Es gibt Standardbibliotheken, die zum Compiler geh¨oren und von diesem automatisch herangezogen werden.
• Weiter gibt es Standardbibliotheken, die zum Compiler geh¨oren, aber
¨
¨
¨
eigens uber
eine Option herangezogen werden mussen.
Hierzu zahlt
die
C-Standard-Mathematik-Bibliothek, die die Option -lm beim CompilerAufruf erfordert.
• Auf dem Markt oder im Netz findet sich eine Vielzahl von Bibliotheken,
¨ numerische Aufgaben oder das X Window System.
beispielsweise fur
• Man kann auch eigene Funktionen in Privatbibliotheken zusammenfas¨
¨ ein bestimmtes Thema
sen. Das lohnt sich, wenn man langere
Zeit fur
programmiert.
2.5.8
¨
Ubung
Bibliotheken
Fassen Sie die Funktionen des Weganalyse-Projektes außer main() in einer
Privatbibliothek zusammen und binden sie diese beim Kompiliervorgang dazu.
2.5 Funktions-Bibliotheken
2.5.9
Systemaufrufe
2.5.9.1
Was sind Systemaufrufe?
159
¨
Dem Programmierer stehen zwei Hilfsmittel33 zur Verfugung,
um seine
¨
¨
Wunsche
auszudrucken:
¨
• die Schlusselw¨
orter (Wortsymbole) der Programmiersprache,
• die Systemaufrufe des Betriebssystems.
¨
¨
Die Schlusselw
orter
(keyword, mot-cl´e) der Programmiersprache (C/C++,
FORTRAN oder PASCAL) sind auch unter verschiedenen Betriebssystemen
(PC-DOS, OS/2 oder UNIX) dieselben. Sie geh¨oren zur Programmiersprache,
das heißt zum Compiler. Die Systemaufrufe (system call, system primitive,
¨ alle Programmierfonction syst`eme) eines Betriebssystems (UNIX) sind fur
sprachen (C, FORTRAN, PASCAL, COBOL) dieselben. Sie geh¨oren zum Betriebssystem. Man findet auch die Bezeichnung Kernschnittstellenfunktion,
die besagt, daß ein solcher Aufruf sich unmittelbar an den Kern des Betriebssystems richtet. Der Kreis der Systemaufrufe liegt fest und kann nicht oh¨
ne Eingriffe in den Kern des Betriebssystems verandert
werden. Da UNIX zum großen Teil in C geschrieben ist, sind die Systemaufrufe von UNIX
C-Funktionen, die sich in ihrer Syntax nicht von eigenen oder fremden C¨
Funktionen unterscheiden. Deshalb mussen
auch FORTRAN- oder PASCALProgrammierer etwas von der Programmiersprache C verstehen. Im Handbuch werden die Systemaufrufe in Sektion (2) beschrieben.
Bei POSIX-konformen Betriebssystemen spricht man statt von System¨
aufrufen besser von POSIX-Funktionen, da der POSIX-Standard offen lasst,
¨
ob diese vom Betriebssystem zur Verfugung
gestellten Funktionen als Systemaufrufe oder als Bibliothek verwirklicht sind. Auf jeden Fall geh¨oren sie
zum Betriebssystem, nicht zum Compiler. Die Unterscheidung spielt eine Rol¨ verschiedene Betriebssysteme und/oder Compiler programle, wenn man fur
miert. Der Programmierer muss wissen, woher seine Funktionen stammen.
In Sektion (3) finden sich vorgefertigte Unterprogramme, Subroutinen oder Standardfunktionen (standard function, fonction e´ l´ementaire)
¨ haufig
¨
¨ den Anwender besteht kein Unterfur
vorkommende Aufgaben. Fur
schied zu den Systemaufrufen. Streng genommen geh¨oren diese Standardfunktionen jedoch zu den jeweiligen Programmiersprachen (zum Compiler)
und nicht zum Betriebssystem. Der Kreis der Standardfunktionen ist belie¨
big erganzbar.
Um den Benutzer zu verwirren, sind die Systemaufrufe und
die Standardfunktionen in einer Funktionsbibliothek (/lib/libc.a und andere) vereinigt.
¨
Die Aufgabenverteilung zwischen Schlusselw¨
ortern, Systemaufrufen und
¨
Standardfunktionen ist in gewissem Umfang willkurlich.
Systemaufrufe erledigen Aufgaben, die aus dem Aufbau und den kennzeichnenden Eigenschaf¨
ten des Betriebssystems herruhren,
bei UNIX also in erster Linie
33 Standardfunktionen
schrieben haben.
¨
sind erst verfugbar,
nachdem andere Programmierer sie ge-
160
2 Programmieren in C/C++
• Ein- und Ausgabe auf unterster Stufe,
• Umgang mit Prozessen,
• Umgang mit dem File-System,
• Sicherheitsvorkehrungen.
¨
Das Offnen
eines Files zum Lesen oder Schreiben ist Sache eines Systemaufrufs (open(2)), Sortieren hingegen Sache einer Standardfunktion
¨
(qsort(3)). Es gibt aber zusatzlich
auch Standardfunktionen zum Umgang mit Files, die den jeweiligen Systemaufruf komfortabel verpacken
(fopen(3)). Nach außen definiert die Menge der Systemaufrufe das Betriebs¨
¨ den
system. Zwei Systeme, die in ihren Aufrufen ubereinstimmen,
sind fur
¨
Benutzer identisch. Neue Funktionalitaten
des Betriebssystems stellen sich
dem Programmierer als neue Systemaufrufe dar, siehe zum Beispiel unter
stream(2).
¨
Einige UNIX-Systemaufrufe haben gleiche oder ahnliche
Aufgaben wie
Shell-Kommandos. Wenn man die Zeit wissen m¨ochte, verwendet man im
Dialog das Shell-Kommando date(1). Will man diese Information aus einem eigenen Programm heraus abfragen, greift man auf den Systemaufruf
¨
time(2)34 zuruck.
Das Shell-Kommando ist ein in ein C-Programm verpackter Systemaufruf.
In UNIX sind Systemaufrufe Funktionen der Programmiersprache C. Ei¨
ne Funktion ubernimmt
beim Aufruf Argumente oder Parameter und gibt ein
¨
¨
Ergebnis zuruck. Dieser Mechanismus wird Parameterubergabe
genannt.
Man muß ihn verstanden haben, um Funktionen in eigenen Programmen ver¨
wenden zu k¨onnen. Eine Erklarung
findet sich in Abschnitt 2.4.3 Parameterubergabe
¨
auf Seite 124.
2.5.9.2
Beispiel Systemzeit (time)
Im folgenden Beispiel wird der Systemaufruf time(2) verwendet. time(2)
liefert die Zeit in Sekunden seit 00:00:00 Greenwich Mean Time, 1. Januar
¨
1970. Computeruhren laufen ubrigens
erstaunlich ungenau, falls sie nicht
¨
durch eine Funkuhr oder uber
das Netz synchronisiert werden. Ferner brauchen wir die Standardfunktion gmtime(3), Beschreibung unter ctime(3),
die aus den obigen Sekunden eine Struktur erzeugt, die Datum und Uhrzeit
¨ Die Umrechnung von Greenwich auf Karlsruhe nehmen wir selbst
enthalt.
¨ ein Ruckgriff
¨
vor. Eleganter ware
auf die Zeitzonen-Variable der Umgebung.
Laut Referenz-Handbuch hat time(2) die Syntax
long time ((long *) 0)
Die Funktion verlangt ein Argument vom Typ Pointer auf long integer, und
zwar im einfachsten Fall den Nullpointer. Der Returnwert ist vom Typ long
¨
integer. Der gr¨oßte Wert dieses Typs liegt etwas uber
2 Milliarden. Damit
¨
lauft
diese Uhr etwa 70 Jahre. Die Subroutine gmtime(3) hat die Syntax
34 In
HP-UX. In ANSI-C ist eine Standardfunktion time(3) enthalten.
2.5 Funktions-Bibliotheken
161
#include <time.h>
struct tm *gmtime(clock)
long *clock
Die Funktion gmtime(3) verlangt ein Argument clock vom Typ Pointer auf
¨
long integer. Wir mussen
also den Returnwert von time(2) in einen Pointer
¨
umwandeln (referenzieren). Der Ruckgabewert
der Funktion gmtime(3) ist
ein Pointer auf eine Struktur namens tm. Diese Struktur ist im include-File
time.h definiert. Die include-Files sind lesbarer Text; es ist ratsam hineinzuschauen. In der weiteren Beschreibung zu ctime(3) wird die Struktur tm
¨
erlautert:
struct tm {
int tm_sec;
int tm_min;
int tm_hour;
int tm_mday;
int tm_mon;
int tm_year;
int tm_wday;
int tm_yday;
int tm_isdst;
}
/*
/*
/*
/*
/*
/*
/*
/*
/*
seconds (0 - 59) */
minutes (0 - 59) */
hours (0 - 23) */
day of month (1 - 31) */
month of year (0 - 11) */
year - 1900 */
day of week (sunday = 0) */
day of year (0 - 365) */
daylight saving time */
Von den beiden letzten Komponenten der Struktur machen wir keinen Gebrauch. Da die Komponenten alle vom selben Typ sind, ist statt der Struktur
auch ein Array denkbar. Vermutlich wollte sich der Programmierer den Weg
¨
offenhalten, kunftig
auch andere Typen aufzunehmen (Zeitzone). Das Pro¨
gramm, das die Quelle zu dem Kommando zeit aus der ersten Ubung
ist,
sieht folgendermaßen aus:
/* Ausgabe der Zeit auf Bildschirm */
/* Compileraufruf cc -o zeit zeit.c */
#include <stdio.h>
#include <time.h>
char *ptag[] = {"Sonntag,
", "Montag,
",
"Dienstag, ", "Mittwoch, ",
"Donnerstag,", "Freitag,
",
"Samstag,
"};
char *pmon[] = {"Januar", "Februar", "Maerz", "April",
"Mai", "Juni", "Juli", "August",
"September", "Oktober", "November",
"Dezember"};
main()
{
long sec, time();
struct tm *gmtime(), *p;
162
2 Programmieren in C/C++
sec = time((long *) 0) + 3600;
/* MEZ = GMT + 3600 */
p = gmtime(&sec);
printf("%s %d. ", ptag[p->tm wday], p->tm mday);
printf("%s %d
", pmon[p->tm mon], p->tm year +1900);
printf("%d:%02d MEZ\n", p->tm hour, p->tm min);
}
Quelle 2.62 : C-Programm zur Anzeige der Systemzeit
Nun wollen wir dieselbe Aufgabe mit einem FORTRAN-Programm
¨
¨ die C-Standardbewaltigen.
Der UNIX-Systemaufruf time(2) bleibt, fur
funktion gmtime(3) suchen wir die entsprechende FORTRAN-Routine. Da
¨
wir keine finden, mussen
wir sie entweder selbst schreiben (was der erfahrene Programmierer scheut) oder nach einem Weg suchen, eine beliebige CStandardfunktion in ein FORTRAN-Programm hineinzuquetschen.
Der Systemaufruf time(2) macht keinen Kummer. Er ben¨otigt ein Argument vom Typ Pointer auf long integer, was es in FORTRAN gibt.
¨
Der Ruckgabewert
ist vom Typ long integer, auch kein Problem. Die CStandardfunktion gmtime(3) erwartet ein Argument vom Typ Pointer auf
¨
long integer, was machbar ware,
aber ihr Ergebnis ist ein Pointer auf eine
Struktur. Das hat FORTRAN noch nie gesehen35 . Deshalb weichen wir auf
¨
die C-Standardfunktion ctime(3) aus, deren Ruckgabewert
vom Typ Poin¨
ter auf character ist, was es in FORTRAN naherungsweise
gibt. In FORTRAN
¨
¨
ist ein Zeichen ein String der Lange
eins. Strings werden per Deskriptor ubergeben. Ein String-Deskriptor ist der Pointer auf das erste Zeichen und die
Anzahl der Zeichen im String als Integerwert. Das Programm sieht dann so
aus:
program zeit
$ALIAS foratime = ’sprintf’ c
integer*4 time, tloc, sec, ctime
character atime*26
sec = time(tloc)
call foratime(atime, ’%s’//char(0), ctime(sec))
write(6, ’(a)’) atime
end
Quelle 2.63 : FORTRAN-Programm zur Anzeige der Systemzeit
Die ALIAS-Anweisung ist als Erweiterung zu FORTRAN 77 in vielen
Compilern enthalten und dient dazu, den Aufruf von Unterprogrammen anderer Sprachen zu erm¨oglichen. Der Compiler weiß damit, daß das Unterprogramm außerhalb des Programms – zum Beispiel in einer Bibliothek –
35 FORTRAN
90 kennt Strukturen.
2.5 Funktions-Bibliotheken
163
einen anderen Namen hat als innerhalb des Programms. Wird eine Sprache
¨
¨ der Syntax dieangegeben (hier C), so erfolgt die Parameterubergabe
gemaß
ser Sprache. Einzelheiten siehe im Falle unserer Anlage im HP FORTRAN
77/HP-UX Reference Manual im Abschnitt Compiler Directives.
Die Anweisung teilt dem Compiler mit, daß hinter der FORTRANSubroutine foratime die C-Standard-Funktion sprintf(3) steckt und daß
¨
diese nach den Regeln von C behandelt werden soll. Der Ruckgabewert
von
sprintf(3) (die Anzahl der ausgegebenen Zeichen) wird nicht verwertet,
deshalb ist foratime eine FORTRAN-Subroutine (keine Funktion), die im
Programm mit call aufgerufen werden muß.
Der Systemaufruf time(2) verlangt als Argument einen Pointer auf
long integer, daher ist tloc als vier Bytes lange Integerzahl deklariert.
¨
tloc spielt weiter keine Rolle. Die Ubergabe
als Pointer (by reference) ist in
¨ Zahlenvariable und braucht nicht eigens vereinbart
FORTRAN Standard fur
¨
zu werden. Der Ruckgabewert
von time geht in die Variable sec vom Typ
long integer = integer*4.
Die call-Zeile ruft die Subroutine foratime alias C-Funktion
sprintf(3) auf. Diese C-Funktion erwartet drei Argumente: den Ausgabestring als Pointer auf char, einen Formatstring als Pointer auf char und
die auszugebende Variable von einem Typ, wie er durch den Formatstring
¨
bezeichnet wird. Der Ruckgabewert
der Funktion ctime(3) ist ein Pointer
¨
auf char. Da dies kein in FORTRAN zulassiger
Typ ist, deklarieren wir die
¨ sich auf
Funktion ersatzweise als vom Typ 4-Byte-integer. Der Pointer laßt
jeden Fall in den vier Bytes unterbringen. Nach unserer Erfahrung reichen
auch zwei Bytes, ebenso funktioniert der Typ logical, nicht jedoch real.
Der Formatstring besteht aus der Stringkonstanten %s, gefolgt von dem
¨ sprintf(3)
ASCII-Zeichen Nr. 0, wie es bei Strings in C Brauch ist. Fur
¨
besagt dieser Formatstring, das dritte Argument – den Ruckgabewert
von
ctime(3) – als einen String aufzufassen, das heißt als Pointer auf das erste
Element eines Arrays of characters.
atime ist ein FORTRAN-String-Deskriptor, dessen erste Komponente ein
Pointer auf character ist. Damit weiß sprintf(3), wohin mit der Ausgabe.
Die write-Zeile ist wieder pures FORTRAN.
An diesem Beispiel erkennen Sie, daß Sie auch als FORTRAN- oder
¨
PASCAL-Programmierer etwas von C verstehen mussen,
um die Systemaufrufe und C-Standardfunktionen syntaktisch richtig zu gebrauchen.
Bei manchen FORTRAN-Compilern (Hewlett-Packard, Microsoft) lassen
sich durch einen einfachen Interface-Aufruf Routinen fremder Sprachen
¨
so verpacken, daß man sie ubernehmen
kann, ohne sich um Einzelheiten
¨
¨
kummern
zu mussen.
2.5.9.3
Beispiel Datei-Informationen (access, stat, open, close)
In einem weiteren Beispiel wollen wir mithilfe von Systemaufrufen In¨
formationen uber
eine Fatei gewinnen, dazu noch eine Angabe aus der
Sitzungsumgebung. Die Teile des Programms lassen sich einfach in andere
164
2 Programmieren in C/C++
¨
C-Programme ubernehmen.
Dieses Programm soll beim Aufruf (zur Laufzeit, in der Kommandozei¨
le) den Namen der Datei als Argument ubernehmen,
wie wir es von UNIXKommandos her kennen. Dazu ist ein bestimmter Formalismus vorgesehen:
int main(int argc, char *argv[], char *envp[])
¨
Die Funktion main() ubernimmt
die Argumente argc, argv und gegebenenfalls envp. Das Argument argc ist der Argument Counter, eine Ganzzahl.
Sie ist gleich der Anzahl der Argumente in der Kommandozeile beim Aufruf
des Programms. Das Kommando selbst ist das erste Argument, also hat argc
mindestens den Wert 1. Das Argument argv ist der Argument Vector, ein
Array of Strings, also ein Array of Arrays of Characters. Der erste String, Index 0, ist das Kommando; die weiteren Strings sind die mit dem Kommando
¨
ubergebenen
Argumente, hier der Name des gefragten Files. Der Environment Pointer envp wird nur ben¨otigt, falls man Werte aus der Umgebung
abfragt. Es ist wie argv ein Array of Strings. Die Namen argc, argv und
¨
¨
envp sind willkurlich,
aber ublich.
Typ und Reihenfolge sind vorgegeben.
Die Umgebung besteht aus Strings (mit Kommando set (Shell) anschauen). In der for-Schleife werden die Strings nacheinander mittels der
Funktion strncmp(3) (siehe string(3)) mit dem String LOGNAME verglichen. Das Ergebnis ist der Index i des gesuchten Strings im Array envp[].
Den Systemaufruf access(2) finden wir in der Sektion (2) des ReferenzHandbuches. Er untersucht die Zugriffsm¨oglichkeiten auf ein File und hat die
Syntax
int access(char *path, int mode)
¨
Der Systemaufruf erwartet als erstes Argument einen String, namlich
den
¨ argv[1] einsetzen. Als zweites steht
Namen des Files. Wir werden hierfur
eine Ganzzahl, die die Art des gefragten Zugriffs kennzeichnet. Falls der ge¨
fragte Zugriff m¨oglich ist, liefert access(2) den Wert null zuruck,
der in
einem C-Programm zugleich die Bedeutung von logisch falsch (FALSE) hat
und deshalb in den if-Zeilen negiert wird.
Den Systemaufruf stat(2) finden wir ebenfalls in Sektion 2. Er ermittelt
Fileinformationen aus der Inode und hat die Syntax
#include <sys/types.h>
#include <sys/stat.h>
int stat(path, buf)
char *path;
struct stat *buf;
Sein erstes Argument ist wieder der Filename, das zweite der Name eines Puffers zur Aufnahme einer Struktur, die die Informatio¨
nen enthalt.
Diese Struktur vom Typ stat ist in dem include-File
/usr/include/sys/stat.h deklariert, das seinerseits Bezug nimmt auf
2.5 Funktions-Bibliotheken
165
Deklarationen in /usr/include/types.h. Auch einige Informationen wie
S_IFREG sind in sys/stat.h definiert. Die Zeitangaben werden wie im vorigen Abschnitt umgerechnet.
¨ jedes File am Anfang eine Magic NumIn UNIX-File-Systemen enthalt
¨
ber, die uber
die Art des Files Auskunft gibt (man magic). Mittels des Systemaufrufs open(2) wird das fragliche File zum Lesen ge¨offnet, mittels
lseek(2) der Lesezeiger auf die Magic Number gesetzt und mittels read(2)
die Zahl gelesen. Der Systemaufruf close(2) schließt das File wieder. Die
¨
Systemaufrufe findet man unter ihren Namen in Sektion (2), eine Erlauterung der Magic Numbers unter magic(4). Nun das Programm:
/* Informationen ueber eine Datei */
#define
MEZ 3600
#include
#include
#include
#include
#include
#include
<stdio.h>
<sys/types.h>
<sys/stat.h>
<time.h>
<fcntl.h>
<magic.h>
void exit(); long lseek();
int main(argc, argv, envp)
int argc; char *argv[], *envp[];
{
int i, fildes;
struct stat buffer;
long asec, msec, csec;
struct tm *pa, *pm, *pc;
if (argc < 2) {
puts("Dateiname fehlt"); return (-1);
}
/* Informationen aus dem Environment */
for (i = 0; envp[i] != NULL; i++)
if (!(strncmp(envp[i], "LOGNAME", 4)))
printf("\n%s\n", envp[i]);
/* Informationen mittels Systemaufruf access(2) */
printf("\nFile heisst: %8s\n", argv[1]);
if (!access(argv[1], 0))
puts("File existiert");
else
puts("File existiert nicht");
166
2 Programmieren in C/C++
if (!access(argv[1], 1))
puts("File darf ausgefuehrt werden");
else
puts("File darf nicht ausgefuehrt werden");
if (!access(argv[1], 2))
puts("File darf beschrieben werden");
else
puts("File darf nicht beschrieben werden");
if (!access(argv[1], 4))
puts("File darf gelesen werden");
else
puts("File darf nicht gelesen werden");
/* Informationen aus der Inode, Systemaufruf stat(2) */
if (!(stat(argv[1], &buffer))) {
printf("\nDevice:
%ld\n", buffer.st dev);
printf("Inode-Nr.:
%lu\n", buffer.st ino);
printf("File Mode:
%hu\n\n", buffer.st mode);
switch(buffer.st mode & S IFMT) {
case S IFREG:
{
puts("File ist regulaer");
break;
}
case S IFDIR:
{
puts("File ist ein Verzeichnis");
break;
}
case S IFCHR:
case S IFBLK:
case S IFNWK:
{
puts("File ist ein Special File");
break;
}
case S IFIFO:
{
puts("File ist eine Pipe");
break;
}
default:
{
puts("Filetyp unbekannt (Inode)");
}
}
printf("\nLinks:
%hd\n", buffer.st nlink);
printf("Owner-ID:
%hu\n", buffer.st uid);
printf("Group-Id:
%hu\n", buffer.st gid);
2.5 Funktions-Bibliotheken
printf("Device-ID:
printf("Filegroesse:
167
%ld\n", buffer.st rdev);
%ld\n", buffer.st size);
asec = buffer.st atime + MEZ; pa = gmtime(&asec);
msec = buffer.st mtime + MEZ; pm = gmtime(&msec);
csec = buffer.st ctime + MEZ; pc = gmtime(&csec);
printf("Letzter Zugriff: %d. %d. %d\n",
pa->tm mday, pa->tm mon + 1, pa->tm year);
printf("Letzte Modifik.: %d. %d. %d\n",
pm->tm mday, pm->tm mon + 1, pm->tm year);
printf("Letzte Stat.Ae.: %d. %d. %d\n",
pc->tm mday, pc->tm mon + 1, pc->tm year);
}
else
puts("Kein Zugriff auf Inode");
/* Pruefung auf Text oder Code (magic number) */
/* Systemaufrufe open(2), lseek(2), read(2), close(2) */
/* Magic Numbers siehe magic(4) */
{
MAGIC
magbuf;
fildes = open(argv[1], O RDONLY);
if (lseek(fildes, MAGIC OFFSET, 0) >= (long)0) {
read(fildes, &magbuf, sizeof magbuf);
switch(magbuf.file type) {
case RELOC MAGIC:
{
puts("File ist relocatable");
break;
}
case EXEC MAGIC:
case SHARE MAGIC:
case DEMAND MAGIC:
{
puts("File ist executable");
break;
}
case DL MAGIC:
case SHL MAGIC:
{
puts("File ist Library");
break;
}
default:
puts("Filetyp unbekannt (Magic Number)");
lseek(fildes, 0L, 0);
}
}
else {
puts("Probleme mit dem Filepointer");
168
2 Programmieren in C/C++
}
}
close(fildes);
}
¨
Quelle 2.64 : C-Programm zum Abfragen von Informationen uber
ein File
Die Verwendung von Systemaufrufen oder Standardfunktionen in CProgrammen ist nicht schwieriger als der Gebrauch anderer Funktionen.
Man muß sich nur an die im Referenz-Handbuch Sektionen (2) und (3) nachzulesende Syntax halten. Es empfiehlt sich, die genannten Sektionen einmal
¨
¨ es Systemdurchzublattern,
um eine Vorstellung davon zu gewinnen, wofur
aufrufe und Standardfunktionen gibt. Die Ausgabe des Programms sieht folgendermaßen aus:
LOGNAME=wualex1
File
File
File
File
File
heisst:
a.out
existiert
darf ausgefuehrt werden.
darf nicht beschrieben werden.
darf gelesen werden.
Device:
Inode-Nr.:
File Mode:
13
43787
33216
File ist regulaer
Links:
Owner-ID:
Group-ID:
Device-ID:
Filegroesse:
Letzter Zugriff:
Letzte Modifik.:
Letzte Stat.Ae.:
File ist executable
1
101
20
102536
53248
24. 1. 91
24. 1. 91
24. 1. 91
Die Bedeutung von File Mode finden Sie bei mknod(2). Es handelt sich um
¨
¨
¨
¨
ausfuhrliche
Informationen uber
die Zugriffsrechte usw. Ahnliche
Auskunfte
¨
uber
ein File liefert das Kommando chatr(1).
2.5.9.4
Beispiel Prozesserzeugung (exec, fork)
¨
Zunachst
ein kleines, aber fieses Programm namens forkbomb, mit dem man
die Robustheit seines Systems auf die Probe stellen kann.
2.6 Klassen
169
(kommt demnaechst)
Quelle 2.65 : C-Programm zum Erzeugen vieler Prozesse (Fork-Bombe)
Der Systemaufruf fork(2) erzeugt eine Kopie des aufrufenden Prozesses
mit einer neuen Prozess-ID. Im Beispiel wird fork(2) in einer ewigen forSchleife aufgerufen.
2.6
2.6.1
Klassen
Warum C mit Klassen?
Objektorientiert oder prozedural ist nicht die Programmiersprache, sondern
¨
die Aufgabenanalyse. Sie fuhrt
auf Programmbausteine (Module), die entweder Objekte oder Prozeduren (Funktionen, Prozeduren, Subroutinen) sind.
Erst an zweiter Stelle kommen dann die Programmiersprachen, die die ei¨
ne oder andere Denkweise unterstutzen.
Man kann mit objektorientierten
Sprachen prozedural aufgebaute Programme schreiben und mit prozeduralen
Sprachen objektorientierte Programme. Da der Ausgangspunkt die Aufgabenanalyse ist, macht sich die Objektorientierung bei kleinen Programmen (wo
es nichts zu analysieren gibt) nicht bemerkbar. C++ und Objective-C wurden
entwickelt, um
• ein besseres C zu sein (dasselbe Ziel wie ANSI-C),
¨
• die Datenabstraktion zu unterstutzen,
¨
• das objektorientierte Programmieren zu unterstutzen.
Als erstes ein Hallo-Programm in C++ (mit Objektorientierung und Klassen ist da noch nichts zu machen):
/* Hallo, Welt; in C++ */
#include <iostream.h>
// anstelle stdio.h
int main()
{
char v[20];
cout << "Bitte Vornamen eingeben: ";
cin >> v;
cout << "Hallo, " << v << ’\n’;
return 0;
}
Quelle 2.66 : C++-Programm Hallo, Welt
Eine zweite Art des Kommentars (Zeilenkommentar) ist hinzugekommen. Der Operator << schreibt sein zweites Argument auf das erste, hier
der Standard Output Stream cout. Der Operator >> schreibt sein erstes
170
2 Programmieren in C/C++
Argument, den Standard Input Stream, auf das zweite, den String v. Das
Stream-Konzept zur Ein- und Ausgabe ist flexibler als das herk¨ommliche File¨ den Programmierer ist die andere Syntax wichtig (beachte: kein
Konzept; fur
Formatstring! Der Operator weiß aufgrund der Typen, was er vor sich hat).
In C++ gibt es eine Vielzahl solcher Verbesserungen oder Erweiterungen von
¨
C, aber sie sind nichts grundsatzlich
Neues; sie erfordern kein Umdenken,
sondern nur das Lesen des Referenzmaterials.
Obiges Programm hallo.cpp ist mit dem GNU gcc kompiliert 96 kB
groß. Ein Assemblerprogramm, das dasselbe tut, belegt 120 Bytes. Die Speicherhersteller profitieren mit Sicherheit von der Objektorientierung.
2.6.2
Datenabstraktion, Klassenbegriff
In C ebenso wie in FORTRAN oder PASCAL beschreibt ein Datentyp eine
Menge von Werten samt den zugeh¨origen Operationen. Die Datentypen sind
durch den Compiler festgelegt, der Benutzer kann keine neuen Datentypen
definieren.
Ein abstrakter Datentyp ist ein vom Benutzer definierter Typ, dessen
¨
Schnittstelle (Interface, Außenseite, Verbindung zum ubrigen
Programm) von
seiner Implementierung (Implementation, interne Programmierung, Innenleben) getrennt ist, eine Black Box mit bestimmten nach außen sichtbaren
Eigenschaften. Klassen sind in einer Programmiersprache formulierte Beschreibungen abstrakter Datentypen. Objekte sind Vertreter (Exemplare,
Instanzen, Verwirklichungen) von Klassen. C-Typen und C++-Klassen sowie
C-Variable und C++-Objekte entsprechen sich. Aus Klassen lassen sich unter¨ Daten (dageordnete Klassen ableiten. Eine Klasse oder ein Objekt enthalt
ta member) und Operationen auf diesen Daten. Die Operationen, die in den
Klassen oder Objekten verwirklicht sind, heißen Methoden (member function, method). Objekte verkehren untereinander mittels Botschaften. Eine Botschaft (message, member function call) ist die Aufforderung an ein Objekt,
¨
eine seiner Methoden auszufuhren,
vergleichbar einem Funktionsaufruf in C.
Beispielsweise k¨onnen wir eine Klasse Komplexe Zahl definieren, die als
Daten zwei reelle Zahlenwerte (Realteil und Imaginrteil) sowie als Methoden
¨ komplexe Zahlen enthalt:
¨
die Grundrechenarten fur
Klasse KOMPLEX
{
Daten: double realteil, imaginaerteil;
Methoden:
KOMPLEX Addiere(a: KOMPLEX, b: KOMPLEX);
KOMPLEX Subtrahiere(a: KOMPLEX, b:KOMPLEX);
KOMPLEX Multipliziere(a: KOMPLEX, b: KOMPLEX);
KOMPLEX Dividiere(a: KOMPLEX, b: KOMPLEX);
}
Mitglieder (Daten, Methoden) sind o¨ ffentlich (public) oder privat. Public
¨
¨
Members sind vom ubrigen
Programm her zuganglich,
sie bilden die Schnitt-
2.6 Klassen
171
stelle der Klasse und ihrer Objekte zur Umwelt. Private Members sind nur
¨
den Methoden der Klasse zuganglich.
Public und private werden als Member Access Specifier bezeichnet. Meist sind die Daten privat, die Methoden teils privat, teils o¨ ffentlich. Mindestens eine Methode muß o¨ ffentlich sein
(warum?). Eine besondere Methode - mit demselben Namen wie die Klasse ist der Constructor, der zur Initialisierung dient. Diese Methode wird automatisch aufgerufen, wenn ein Objekt der Klasse erzeugt wird. Ein Construc¨
tor kann public, protected oder private sein; er hat niemals einen Ruckgabewert eines bestimmten Typs, auch nicht des Typs void.
¨
Nun ein funktionsfahiges
(wenn auch simples) Beispiel. Es rechnet die
Zeiten von UTC nach MEZ um:
/* mez.cpp, Beispiel fuer den Gebrauch einer Klasse
in Anlehnung an Deitel + Deitel, S. 601 */
#include <iostream.h>
// fuer Ein- und Ausgabe
class TIME {
// Definition einer Klasse
public:
//
//
//
//
//
//
//
nach aussen sichtbar,
Methoden
Default Constructor,
Initialisierung
h, m in UTC setzen
UTC einlesen von stdin
MEZ ausgeben
//
//
//
//
//
nicht nach aussen sichtbar,
Daten
0 - 23
0 - 59
Eingabe von stdin
TIME();
void Settime(int, int);
void Gettime();
void Printmez();
private:
int hour;
int minute;
int hin, min;
};
// Definition der Methoden
// Initialisierung mittels Constructor
TIME::TIME() { hour = minute = 0; }
// Zeit in UTC eingeben, pruefen
void TIME::Settime(int h, int m)
{
hour = (h >= 0 && h < 23) ? h + 1 : 0;
// UTC nach MEZ
minute = (m >= 0 && m < 60) ? m : 0;
}
// Zeit in UTC von stdin einlesen
void TIME::Gettime()
172
2 Programmieren in C/C++
{
cout
cin
cout
cin
cout
<<
>>
<<
>>
>>
"Stunde eingeben: ";
hin;
"Minuten eingeben: ";
min;
"Vielen Dank" >> endl;
TIME::Settime(hin, min);
// Umrechnung
}
// MEZ ausgeben
void TIME::Printmez()
{
cout << (hour < 10 ? "0" : "") << hour
<< ’:’
<< (minute < 10 ? "0" : "") << minute
<< endl;
}
// Hauptprogramm (Rahmen- oder Treiberprogramm)
int main()
{
TIME t;
// Erzeugung des Objektes t
cout << "\nDie Anfangszeit ist ";
t.Printmez();
// Aufruf einer oeff. Methode
t.Settime(13, 27);
cout << "Neue Zeit ist ";
t.Printmez();
t.Gettime();
cout << "Ihre Zeit ist: ";
t.Printmez();
t.Settime(99, 99);
// ungueltige Werte
cout << "Fehlerhafte Eingabe fuehrt zu ";
t.Printmez();
cout << endl;
return 0;
// endline stream manipulator
}
Quelle 2.67 : C++-Programm zur Umrechnung von UTC nach MEZ
2.6.3 Klassenhierarchie, abstrakte Klassen, Vererbung
Objektorientiertes Programmieren besteht im Programmieren einer Menge
von Klassen, deren zugh¨orige Objekte den Programmablauf verwirklichen.
Das folgende Programm zeigt, wie aus einer Basisklasse weitere Klassen abgeleitet werden, die die public und protected members erben. Von einer ab-
2.6 Klassen
173
strakten Klasse k¨onnen nur weitere Klassen abgeleitet, jedoch keine Objekte gebildet werden. Eine abstrakte Klasse muß mindestens eine rein virtuelle Funktion enthalten, die nirgends definiert wird. Sie ist ein Platzhalter,
der erst in einer abgeleiteten Klasse einen Inhalt bekommt.
/* geof.C, Beispiel fuer Klassen und Vererbung
- geometrische Formen Compileraufruf (HP): CC -o geof geof.C
*/
#define PI 3.14159
// symbolische Konstante
#include <iostream.h>
#include <string.h>
#include <stdlib.h>
// fuer Ein- und Ausgabe
// wegen strcmp()
// wegen exit()
void exit(int);
// Prototyp Systemaufruf
class Form {
// abstrakte Basisklasse
public:
// nach aussen sichtbar
virtual void lesen() = 0;
// reine virt. Funktionen
virtual void schreiben() = 0;
protected:
private:
};
class Flaeche : public Form {
// public fuer abg. Klasse,
// ansonsten private
// nach aussen unsichtbar
// abgel. abstr. Klasse
public:
Flaeche() {u = i = 0;}
// Constructor
void schreiben()
{cout << "Umfang = " << u << endl;
cout << "Inhalt = " << i << endl;}
protected:
double u, i;
virtual double umfang(double, double) = 0;
// rein virtuelle Fkt.
virtual double inhalt(double, double) = 0;
private:
};
class Koerper : public Form {
// abgel. abstr. Klasse
public:
Koerper() {f = v = 0;}
// Constructor
void schreiben()
{cout << "Oberflaeche = " << f << endl;
cout << "Volumen = " << v << endl;}
174
2 Programmieren in C/C++
protected:
double f, v;
virtual double flaeche(double, double, double) = 0;
// rein virtuelle Fkt.
virtual double volumen(double, double, double) = 0;
private:
};
class Kreis : public Flaeche {
// abgel. konkr. Klasse
public:
Kreis() {a = x = y = 0;}
// Constructor
void lesen()
{cout << "Radius: "; cin >> a;
u = umfang(a, a);
i = inhalt(a, a);}
protected:
private:
double a, x, y;
double umfang(double x, double y) {return(PI * (x + y));}
double inhalt(double x, double y) {return(PI * x * y);}
};
class Rechteck : public Flaeche { // abgel. konkr. Klasse
public:
Rechteck() {a = b = x = y = 0;}
void lesen() {cout << "Laenge: "; cin >> a;
cout << "Breite: "; cin >> b;
u = umfang(a, b);
i = inhalt(a, b);}
protected:
double umfang(double x, double y) {return(2 * (x + y));}
double inhalt(double x, double y) {return(x * y);}
private:
double a, b, x, y;
};
class Quadrat : public Rechteck { // abgel. konkr. Klasse
public:
Quadrat() {a = 0;}
// Constructor
void lesen() {cout << "Laenge: "; cin >> a;
u = umfang(a, a);
i = inhalt(a, a);}
protected:
2.6 Klassen
175
private:
double a;
};
class Kugel : public Koerper {
// abgel. konkr. Klasse
public:
Kugel() {a = x = y = z = 0;} // Constructor
void lesen()
{cout << "Radius: "; cin >> a;
f = flaeche(a, a, a);
v = volumen(a, a, a);}
protected:
private:
double a, x, y, z;
double flaeche(double x,
{return(2 * PI * x *
double volumen(double x,
{return(4 * PI * x *
};
double y, double z)
(y + z));}
double y, double z)
y * z / 3);}
class Quader : public Koerper {
// abgel. konkr. Klasse
public:
Quader() {a = b = c = x = y = z
void lesen()
{cout << "Laenge: "; cin >>
cout << "Breite: "; cin >>
cout << "Hoehe: "; cin >>
f = flaeche(a, b, c);
v = volumen(a, b, c);}
= 0;} // Constructor
a;
b;
c;
protected:
double flaeche(double x, double y, double z)
{return(2 * (x * y + x * z + y * z));}
double volumen(double x, double y, double z)
{return(x * y * z);}
private:
double a, b, c, x, y, z;
};
class Wuerfel : public Quader {
// abgel. konkr. Klasse
public:
Wuerfel() {a = 0;}
// Constructor
void lesen()
{cout << "Laenge: "; cin >> a;
f = flaeche(a, a, a);
v = volumen(a, a, a);}
protected:
176
2 Programmieren in C/C++
private:
double a;
};
// Hauptprogramm
int main()
{
int x = 0;
char figur[32];
cout << "\nFlaechen- und Koerperberechnung\n\n";
cout << "Welche Figur? ";
cin >> figur;
cout << "\nFigur: " << figur << endl;
// Stringvergleiche, erforderlich, weil in der
// switch-Anweisung nur eine int-Variable stehen kann.
if (!(strcmp(figur, "Kreis"))) x = 21;
if (!(strcmp(figur, "Rechteck"))) x = 22;
if (!(strcmp(figur, "Quadrat"))) x = 23;
if (!(strcmp(figur, "Kugel"))) x = 31;
if (!(strcmp(figur, "Quader"))) x = 32;
if (!(strcmp(figur, "Wuerfel"))) x = 33;
//
//
//
//
Erzeugen des passenden Objektes f. Gilt wie
jede Deklaration nur innerhalb des Blockes {},
weshalb die Methoden lesen() und schreiben()
in jedem Block vorkommen muessen.
switch (x)
{
case 21: {
Kreis f;
f.lesen();
f.schreiben();
break;
}
case 22: {
Rechteck f;
f.lesen();
f.schreiben();
break;
}
case 23: {
Quadrat f;
f.lesen();
f.schreiben();
break;
}
// Erzeugen des Objektes f
2.6 Klassen
177
case 31: {
Kugel f;
f.lesen();
f.schreiben();
break;
}
case 32: {
Quader f;
f.lesen();
f.schreiben();
break;
}
case 33: {
Wuerfel f;
f.lesen();
f.schreiben();
break;
}
default:
cout << "Keine gueltige Figur." << endl;
exit(-1);
}
return 0;
}
Quelle 2.68 : C++-Programm zur Berechnung geometrischer Formen
Geometrische Formen legen eine objektorientierte Programmierung nahe,
¨
da sie eine Hierarchie bilden, ahnlich
wie Pflanzen oder Tiere. Im Beispiel
¨
wird als erstes eine abstrakte Basisklasse Form definiert, die das enthalt,
was allen Formen gemeinsam ist. Das ist nicht viel und steht in den beiden
rein virtuellen Funktionen lesen() und schreiben.
Aus der Klasse Form werden die beiden immer noch abstrakten Klassen
¨
¨ sich sagen, dass sie einen
Flaeche und Koerper abgeleitet. Von Flachen
laßt
¨
Umfang und einen Inhalt haben, ausgedruckt
durch die beiden rein virtuellen
¨ K¨orper haben wir entsprechend
Funktionen umfang() und inhalt(). Fur
die abstrakte Klasse Koerper mit den rein virtuellen Funktionen flaeche()
¨
(Oberflache)
und volumen().
¨
Im nachsten
Schritt gelangen wir endlich zu konkreten Klassen. Aus der
Klasse flaeche werden die Klassen Kreis und Rechteck abgeleitet, aus der
¨
Klasse Rechteck noch die Klasse Quadrat. Wahrend
aus abstrakten Klassen nur weitere, abstrakte oder konkrete Klassen abgeleitet werden k¨onnen,
lassen sich aus konkreten Klassen weitere konkrete Klassen ableiten oder
Objekte bilden.
Bei den K¨orpern leiten wir analog aus der abstrakten Klasse Koerper die
konkreten Klassen Kugel und Quader ab, aus Quader nochmals Wuerfel.
In den konkreten Klassen erhalten die virtuellen Funktionen auch einen
¨ den
konkreten Inhalt, das heißt, die Platzhalter werden mit den Formeln fur
¨
Flacheninhalt
eines Kreises oder Rechtecks besetzt usw. Diese Formeln sehen
¨ jede konkrete geometrische Form anders aus.
fur
178
2 Programmieren in C/C++
Bei einer Klassenableitung wie:
class Kreis : public Flaeche { }
¨
bedeutet das Schlusselwort
public, dass von der zugrunde liegenden Klasse
(Basisklasse) die public members als public und die protected members als
protected geerbt werden. Die private members werden in keinem Fall vererbt.
¨
¨
Hatten
wir dagegen das Wort private gebraucht, so waren
die vererbten
members in der abgeleiteten Klasse privat geworden.
Das Erbrecht zwischen Klassen ist noch differenzierter, auch Freunde
k¨onnen erben, und eine Klasse kann aus zwei Basisklassen abgeleitet wer¨ werden. Die ausgefeilte
den, aber erstmal muß Obiges verstanden und geubt
Klassenhierarchie hat den Vorteil, dass man auf jeder Stufe genau das fest¨
legt, was sich dort festlegen laßt,
nicht mehr und nicht weniger. Kontrollen
¨
und Anderungen
werden stets in einer bestimmten Stufe vorgenommen.
Das Hauptprogramm main() ist vergleichsweise trivial. Nach ein bißchen
¨
Benutzerdialog werden in einer switch-Anweisung die ausgewahlten
Objek¨
¨
te erzeugt und deren Methoden aufgerufen, namlich
die ursprunglich
virtuellenund in den konkreten Klassen definierten Funktionen lesen() und
schreiben(). Die wesentliche Arbeit steckt in den Klassen.
2.6.4
Memo Klassen
• Bei einem abstrakten Datentyp ist das Innenleben von der Außenseite
streng getrennt (Black Box).
• Klassen sind in einer Programmiersprache formulierte Beschreibungen
abstrakter Datentypen.
• Objekte sind Verwirklichungen von Klassen, so wie Variable Verwirklichungen von Typen sind.
¨ Daten (data members) und Metho• Eine Klasse oder ein Objekt enthalt
den (member functions).
¨
• Daten und Methoden sind o¨ ffentlich (public), geschutzt
(protected) oder
privat. Die Daten sind meist privat. Mindestens eine Methode muß
¨
o¨ ffentlich sein, sonst nutzt
die Klasse nicht viel.
• Aus Klassen k¨onnen Unterklassen abgeleitet werden, die die o¨ ffentli¨
chen und geschutzten
(protected) Daten und Methoden erben. Die Klassen bilden Hierarchien.
• Von einer abstrakten Klasse k¨onnen nur Unterklassen, aber keine Objekte abgeleitet werden. Meist in den oberen Etagen der Hierarchie anzutreffen.
2.6.5
¨
Ubung
Klassen
Es gibt Aufgaben, deren Struktur eine Modellierung durch eine Klassenhierarchie nahelegt. Bei anderen hinwiederum wirkt die Objektorientierung verkrampft. Mit C/C++ sind alle Wege offen.
2.7 Klassen-Bibliotheken
179
¨
Uberlegen
Sie, welche Klassen und Objekte man bei der Aufgabe zur
¨
Weganalyse zweckmaßig
einrichtet. Sind die Wegstrecken oder die Fahrzeuge/Personen als Objekte anzusehen? Skizzieren Sie – ohne genau auf die Syntax zu achten – eine Klassenhierarchie samt Daten und Methoden.
In dem Beispielprogramm zur Befeuerung von Binnenschiffen kann man
sich gut eine Hierarchie von Fahrzeugen und entsprechenden Klassen vorstellen, wobei an der Spitze die Klasse der Hohlk¨orper von nicht ganz unbedeutender Gr¨oße steht.
Auch bei dem Beispiel des Vokabeltrainers ist eine Hierarchie denkbar.
Wie k¨onnten die Klassen, Daten und Methoden aussehen? Welche Vorteile
¨
hatte
hier die Objektorientierung vor der prozeduralen Denkweise?
2.7
Klassen-Bibliotheken
2.7.1
C++-Standardbibliothek
¨
Standardbibliotheken sind eine Erganzung
der Compiler, ohne die man nicht
weit kommt. Die Benutzer betrachten sie als festen Bestandteil der Compiler, obwohl sie im strengen Sinn nicht Bestandteil der Sprache sind. Zu C++
geh¨ort ebenso wie zu C eine Standardbibliothek, deren Umfang und Funk¨ durch eine ISO/ANSI-Norm festgelegt ist. Im wesentlichen geh¨oren
tionalitat
dazu:
• die C-Standardbibliothek (damit man sie nicht extra zu nennen
braucht),
• Input/Output-Klassen wie basic ios,
• String-Klassen wie basic string,
• numerisches Klassen wie complex,
• Klassen zur Ausnahmebehandlung wie exception,
• sonstige Klassen wie pair und Klassen zur Lokalisation (Anpassung an
o¨ rtliche Gegebenheiten),
• die Standard Template Library (STL)
Die C++-Standardbibliothek ist wesentlich umfangreicher als die CStandardbibliothek, sie erfordert mehr Zeit zum Einarbeiten, aber sie spart
¨
viel Muhe.
Es ist Zeitverschwendung, die Klasse Rad neu zu erfinden. Die
Standard Template Library spielt eine besondere Rolle, weil sie einige neue
Begriffe in C++ einbringt.
2.7.2
Standard Template Library (STL)
¨
Ein wichtiger Schritt vorwarts
in der Standardisierung von C++ war die Annahme der Standard Template Library (STL) als Erweiterung der C++¨
Standard-Bibliothek durch das ANSI-Komitee im Jahr 1993. Die STL enthalt
¨ Gruppen von Komponenten:
funf
180
2 Programmieren in C/C++
• Allgemeine Algorithmen,
• Iteratoren,
• Container,
• Funktionen,
• Adaptoren.
Wenn man in einem C-Programm ein Array linear (sequentiell) nach ei¨ Ganzzahlen
nem bestimmten Wert durchsuchen will, sieht die Funktion fur
¨
anders aus als fur Strings, obwohl der Suchalgorithmus derselbe ist. Die Al¨
gorithmen der STL sind dagegen allgemein gultig,
indem sie mit Hilfe von
Templates den Algorithmus vom Datentyp trennen. Ein Template (Vorlage,
Muster, Schablone) ist eine allgemeine Vorstufe zu einer Funktion oder einer Klasse, der die Typen der verwendeten Daten als Parameter mitgegeben
¨
werden – ahnlich
wie bei einem Funktionsaufruf die Typen der Argumente.
¨
Der Compiler erzeugt dann aus dem Template die gewunschte
Klasse oder
Funktion und nimmt so dem Programmierer Arbeit ab.
Iteratoren sind eine Verallgemeinerung der Pointer. Sie werden eingesetzt, um auf Elemente von Containern zuzgreifen, so wie man mittels Pointerarithmetik auf die Elemente eines Arrays zugreift. Im Gegensatz zu Pointern bringen sie jedoch eine gewisse eigene Intelligenz mit, so daß der Programmierer – wenn er erst einmal ihre Funktionsweise begriffen hat – weniger Arbeit aufzuwenden braucht.
Unter Containern, auch Collection genannt, werden Datenstrukturen
(Klassen) verstanden, die andere Datenstrukturen oder Objekte enthalten.
¨
Damit lasst
sich eine Gruppe von Objekten unter einem Namen gemeinsam
handhaben. Sequentielle Container speichern ihre Objekte in einer Reihe
(linear), auf sie kann entweder der Reihe nach oder wahlfrei zugegriffen wer¨
den. Daneben gibt es die assoziativen Container, deren Objekte uber
einen
¨
¨
Schlussel
oder Index zuganglich
sind. Der einfachste sequentielle Container
ist der Vektor, ein Array variabler Gr¨oße. Der einfachste assoziative Contai¨
ner ist die Menge (Set), in der jeder Schlussel
nur einmal vorkommen darf. Zu
jeder Art von Containern geh¨ort ein Satz von Methoden. Auch hier braucht
sich der Programmierer nicht um die Einzelheiten der Speicherung und der
¨
Zugriffe zu kummern,
das hat die Bibliothek bereits erledigt.
Ein Adaptor schließlich macht das, was auch andere Adapter machen: er
paßt das Aussehen einer Schnittstelle an neue Erfordernisse an, er verpackt
¨
einen Iterator oder einen Container in eine neue Umhullung.
Damit wird
¨
nicht ein neues Objekt geschaffen, sondern nur seine Außenseite verandert.
Das ist oftmals effektiver, als ein neues Objekt zu schreiben.
Um die STL ganz zu verstehen, muß man sie benutzen. Da sie auf einer
hohen Abstraktionsebene zu Hause ist, machen sich ihre Vorteile erst bei um¨ Hallo-Welt-Programme ist sie einige
fangreicheren Aufgaben bemerkbar. Fur
Nummern zu groß. Wir verweisen daher auf das Buch von R OBERT R OBSON
und auf unsere Technik-Seite im WWW.
2.7 Klassen-Bibliotheken
2.7.3
C-XSC
2.7.3.1
Was ist C-XSC?
181
¨ numerische Aufgaben wurde im Institut fur
¨ Angewandte Mathematik
Fur
¨ Karlsruhe eine Klassenbibliothek C-XSC als Erganzung
¨
der Universitat
36
¨
eines C++-Compilers entwickelt . Das Kurzel
XSC ist als Extended Scientific
Computing zu deuten. Die wichtigsten Bestandteile von C-XSC sind:
• Arithmetik reeller und komplexer Zahlen sowie Intervallarithmetik mit
mathematisch bestimmten Eigenschaften,
¨
• dynamische Vektoren und Matrizen mit zur Laufzeit veranderbarer
Gr¨oße,
• Teilfelder (Subarrays) aus Vektoren und Matrizen,
• arithmetische Operatoren und mathematische Standardfunktionen von
hoher, bekannter Genauigkeit,
• dynamische Langzahlarithmetik mit zugh¨origen Standardfunktionen,
• Rundungskontrolle bei der Ein- und Ausgabe,
¨
• Behandlung bestimmter Fehler (z. B. Uberschreiten
der Indexgrenzen),
• Bibliothek mit Routinen zur L¨osung von Standardproblemen der numerischen Analysis.
Zusammen mit der Klassenbibliothek C-XSC geht C++ in der Behandlung nu¨
merischer Aufgaben uber
FORTRAN und andere Programmiersprachen hinaus.
2.7.3.2
Datentypen, Operatoren und Funktionen
¨
C-XSC stellt folgende einfache numerische Datentypen zur Verfugung:
real, interval, complex, cinterval (=complex interval)
samt den zugeh¨origen arithmetischen und relationalen Operatoren und
den mathematischen Standardfunktionen. Alle vordefinierten arithmetischen
Operatoren liefern Ergebnisse mit einer Genauigkeit von wenigstens einer
Einheit der letzten Stelle. Auf diese Weise sind sie maximal genau im Sinne des wissenschaftlichen Rechnens. Die von den arithmetischen Operatoren
vorgenommenen Rundungen lassen sich durch den Gebrauch der Datentypen
interval und cinterval steuern. Funktionen zur Typumwandlung sind
¨ alle mathematisch sinnvollen Kombinationen verfugbar.
¨
fur
Alle mathemati¨ einfache numerische Datentypen k¨onnen mit
schen Standardfunktionen fur
¨
¨
Abschnitt ist die gekurzte
Ubersetzung
eines Aufsatzes (1992) von
Dipl.-Math. A NDREAS W IETHOFF, Mitarbeiter des genannten Institutes, siehe
www.uni-karlsruhe.de/˜iam/html/language/cxsc/cxsc.html.
36 Dieser
182
2 Programmieren in C/C++
ihrem gewohnten Namen aufgerufen werden und liefern Ergebnisse von ga¨ beliebige Argumente aus dem Definitosnberantierter hoher Genauigkeit fur
¨ die Datentypen interval und cinterval
reich. Die Standardfunktionen fur
¨
liefern scharfe Einschlusse
der Wertebereiche.
Zu den oben genannten einfachen Datentypen kommen die entsprechenden Felddatentypen (Vektoren und Matrizen):
rvector, ivector, cvector, civector,
rmatrix, imatrix, cmatrix, cimatrix
¨ diese Arrays zur Laufzeit zuordnen
Der Anwender kann Speicherplatz fur
¨ Arrays unterund freigeben. Auf diese Weise kann dasselbe Programm fur
schiedlicher Gr¨oße benutzt werden, begrenzt nur durch den Arbeitsspeicher.
Es wird nicht mehr Speicher von den Daten belegt, als wirklich ben¨otigt wird.
¨ um ProBeim Zugriff auf Arrays wird der Indexbereich zur Laufzeit gepruft,
¨
¨
grammabsturze
durch unzulassige
Speicherzugriffe (memory faults) zu verhindern.
¨ die dynamische Gr¨oßenanderung
¨
Hier ein Beispiel fur
einer Matrix:
...
int n, m;
cout << "Dimensionen n, m eingeben: ";
cin >> n >> m;
imatrix B, C, A(n,m);
Resize(B,m,n);
...
C = A * B;
/* A[1][1] ... A[n][m] */
/* B[1][1] ... B[m][n] */
/* C[1][1] ... C[n][n] */
Mit Hilfe des C++-ostream-Objektes cout wird ein String nach stdout geschrieben, dann werden mit cin die beiden Indexgrenzen n und m von stdin
eingelesen. Die Vereinbarung eines Vektors oder einer Matrix ohne Angabe
der Indexgrenzen liefert einen Vektor mit einer Komponente oder eine Ma¨ diese Objekte wird erst an eitrix mit je einer Zeile und Spalte. Speicher fur
¨
ner spateren
Stelle im Programm zur Laufzeit zugewiesen. Die Matrix A wird
gleich in der richtigen Gr¨oße angelegt. Die Resize-Anweisung bringt die Matrix B zur Laufzeit an dieser Programmstelle auf die erforderliche Gr¨oße.
¨ einen Vektor oder eine Matrix kann
Die Belegung von Speicherplatz fur
¨
auch implizit – ohne eine ausdruckliche
Anweisung wie Resize – durch eine
Zuweisung erfolgen. Falls die Indexgrenzen des Objektes auf der rechten Seite einer Zuweisung nicht mit den Indexgrenzen des Objektes auf der linken
¨
Seite ubereinstimmen,
wird das linke Objekt angepaßt, wie es hier mit der
Matrix C geschieht.
Der dynamisch zugewiesene Speicherplatz eines lokal vereinbarten Ar¨
rays wird automatisch beim Verlassen des Gultigkeitsbereiches
freigegeben.
¨
Hinsichtlich Lebensdauer und Gultigkeitsbereich
besteht kein Unterschied
zu den aus C gewohnten Arrays.
2.7 Klassen-Bibliotheken
183
Die Gr¨oße eines Vektors oder einer Matrix kann jederzeit durch Aufrufen
¨ die untere bzw. obere Indexgrenze ermitder Funktionen Lb() und Ub() fur
telt werden.
2.7.3.3
Teilfelder von Vektoren und Matrizen
¨ die Handhabung von Teilfeldern
C-XSC stellt eine eigene Schreibweise fur
¨
(Subarrays) von Vektoren und Matrizen zur Verfugung.
Subarrays sind beliebige rechteckige Ausschnitte aus Arrays. Alle vordefinierten Operatoren nehmen auch Subarrays als Operanden an. Ein Subarray einer Matrix oder eines
¨
¨
Vektors wird uber
den ()-Operator oder uber
den []-Operator angesprochen.
Der ()-Operator bezeichnet ein Subarray eines Objektes vom selben Typ wie
¨
das ursprungliche
Objekt. Ist beispielsweise A eine reelle n x n-Matrix, dann
ist A(i,i) die linke obere i x i-Submatrix. Man beachte, daß die Klammern in
der Deklaration eines dynamischen Vektors oder einer ebensolchen Matrix
kein Subarray bezeichnen, sondern den Indexbereich des anzulegenden Objektes einschließen. Der []-Operator erzeugt ein Subarray eines niedrigeren
Typs. Wenn A eine Matrix vom Typ n x n-rmatrix ist, dann ist A[i] die i-te
Zeile von A mit dem Typ rvector, und A[i][j] ist das (i,j)-te Element von A
mit dem Typ real.
Beide Arten des Zugriffs auf Subarrays k¨onnen auch verbunden werden,
beispielsweise ist A[k](i,j) ein Subvektor von Index i bis Index j des k-ten
Zeilenvektors der Matrix A.
Den Gebrauch von Subarrays zeigt das folgenden Beispiel, das die LUFaktorisierung einer n * n-Matrix A beschreibt:
for (j = 1; j <= n - 1; j++) {
for (k = j + 1; k <= n; k++) {
A[k][j]
= A[k][j] / a[j][j];
A[k](j + 1, n) = A[k](j + 1, n) - A[k][j] * A[j](j + 1, n);
}
}
Dieses Beispiel nutzt zwei wichtige M¨oglichkeiten von C-XSC. Erstens sparen
wir uns eine Schleife durch die Verwendung von Subarrays. Das vereinfacht
¨
das Programm. Zweitens ist der obige Programmausschnitt unabhangig
vom
Typ der Matrix A (rmatrix, imatrix, cmatrix oder cimatrix), da alle
arithmetischen Operatoren so vordefiniert sind wie man es in der Mathematik erwartet.
2.7.3.4
¨
Genaue Auswertung von Ausdrucken
¨
Beim Auswerten arithmetischer Ausdrucke
spielt die Genauigkeit eine entscheidende Rolle in vielen Algorithmen. Auch wenn alle arithmetischen Ope¨ sich allein maximaler genau sind, so lieratoren und Standardfunktionen fur
¨
fern zusammengesetzte Ausdrucke
doch nicht notwendigerweise Ergebnisse
184
2 Programmieren in C/C++
maximaler Genauigkeit. Deshalb sind Verfahren entwickelt worden, die nu¨
merische Ausdrucke
mit hoher und auf mathematischem Wege garantierter
Genauigkeit auswerten.
¨
Eine besondere Art solcher Ausdrucke
sind die sogenannten Skalarpro¨
¨
duktausdrucke.
Sie sind als eine Summe einfacher Ausdrucke
definiert. Ein
einfacher Ausdruck ist entweder eine Variable, eine Konstante oder ein ein¨
zelnes Produkt von zweien solcher Objekte. Die Variablen durfen
vom Typ
Skalar, Vektor oder Matrix sein. Nur die mathematisch sinnvollen Operatio¨ die Addition und die Multiplikation zugelassen. Das Ergebnis
nen sind fur
der Auswertung eines solchen Ausdrucks ist entweder ein Skalar, ein Vektor oder eine Matrix. In der numerischen Analysis sind Skalarprodukte von
¨
entscheidender Bedeutung. Beispielsweise grunden
sich Verfahren zur Fehlerkorrektur oder zur iterativen Verbesserung bei linearen oder nichtlinearen
¨
Aufgaben auf Skalarprodukte. Eine Auswertung dieser Ausdrucke
mit maxi¨ eine Auswermaler Genauigkeit vermeidet Fehler durch Ausl¨oschung. Fur
tung mit einer Genauigkeit von einer Einheit der letzten Stelle stellt C-XSC
¨
die folgenden Dotprecision-Datentypen zur Verfugung:
dotprecision, cdotprecision, idotprecision, cidotprecision
Zwischenergebnisse eines Skalarproduktes k¨onnen ohne jeden Rundungsfehler in einer Dotprecision-Variablen errechnet und gespeichert werden. Die folgende Funktion berechnet eine maximal genaue Einschließung des Defektes
b - Ax eines linearen Gleichungssystems Ax = b :
ivector defect (rvector b, rmatrix A, rvector x)
{
idotprecision accu;
ivector INCL (Lb(x), Ub(x));
for (int i = Lb(x); i <= Ub(x); i++) {
accu = b[i];
accumulate(accu, -A[i], x);
INCL[i] = rnd(accu);
}
return INCL;
}
Quelle 2.69 : C-XSC-Funktion defect() zur Defekteinschließung
In obigem Beispiel berechnet die Funktion accumulate() die Summe:
n
X
−Aij · xj
j=1
und addiert das Ergebnis zu dem Dotprecision-Akkumulator accu ohne Rundungsfehler. Die idotprecision-Variable accu wird mit b[i] initialisiert.
2.7 Klassen-Bibliotheken
185
Schließlich wird der Wert im Akkumulator maximal genau auf das StandardIntervall INCL[i] gerundet. Auf diese Weise sind die Grenzen von INCL[i]
entweder gleich oder zwei beanchbarte Gleitkommazahlen.
¨ alle Dotprecision-Datentypen steht ein verringerter Satz vordefinierFur
¨
ter Operatoren zur Verfugung,
um fehlerfreie Ergebnisse zu berechnen. Die
¨
uberladene
Skalarprodukt-Funktion accumulate() und die Rundungsfunk¨ alle sinnvollen Typkombinationen verfugbar.
¨
tion rnd() sind fur
2.7.3.5
Dynamische Langzahl-Arithmetik
Neben den Klassen real und interval gibt es die dynamischen Klassen
l_real (long real) und l_interval (long interval) ebenso wie die entsprechenden dynamischen Vektoren und Matrizen samt allen arithmetischen und
relationalen Operatoren und allen Standardfunktionen mit mehrfacher Ge¨ sich vom Benutzer wahrend
¨
nauigkeit. Die Rechengenauigkeit laßt
der Laufzeit kontrollieren. Mittels Ersetzen der Typen real und interval durch
l_real und l_interval in den Deklarationen wird ein Anwendungsprogramm zu einem Programm mit mehrfacher Genauigkeit. Dieses Konzept
¨
gibt dem Benutzer ein machtiges
und einfach zu handhabendes Werkzeug zur
Fehleranalyse in die Hand. Weiterhin ist es m¨oglich Programme zu schreiben, die numerische Ergebnisse mit einer vom Benutzer vorgegebenen Genauigkeit liefern, indem man intern die Rechengenauigkeit zur Laufzeit in
¨
Abhangigkeit
von den Fehlerschranken der Zwischenergebnisse anpaßt.
¨ die Typen real und interval sind
Alle vordefinierten Operatoren fur
¨ die Typen l_real und l_interval verfugbar.
¨
¨
auch fur
Zusatzlich
sind auch
¨ Typen einfacher und mehralle m¨oglichen Kombinationen von Operatoren fur
facher Genauigkeit vorhanden. Im folgenden wird ein Programm mit einfacher Genauigkeit und sie entsprechende Version mit mehrfacher Genauigkeit
gezeigt:
main()
{
interval a, b;
a = 1.0;
b = 3.0;
cout << "a/b = " << a/b;
/*
/*
/*
/*
Standard-Intervall */
a = [1.0, 1.0] */
b = [3.0, 3.0] */
a/b = [0.333333333333,
0.333333333334] */
}
Quelle 2.70 : C-XSC-Programm einfacher Genauigkeit
main()
{
l_interval a, b;
a = 1.0;
/* Langzahl-Intervall */
186
2 Programmieren in C/C++
b = 3.0;
stagprec = 2;
cout << "a/b = " << a/b;
/* Globale int-Variable */
/* a/b =
[0.333333333333333333333333,
0.333333333333333333333334] */
}
Quelle 2.71 : C-XSC-Programm mehrfacher Genauigkeit
Zur Laufzeit bestimmt die vordefinierte globale int-Variable stagprec
(staggered precision) die Rechengenauigkeit der Langzahl-Arithmetik in
Schritten einer real-Zahl (64-Bit-Maschinenwort). Die Genauigkeit einer
Langzahl ist als die Anzahl von real-Zahlen definiert, die zur Speicherung der langen Zahl verwendet werden. Ein Objekt des Typs l_real oder
¨
l_interval kann seine Genauigkeit zur Laufzeit andern.
Komponenten ei¨
nes Vektors oder einer Matrix durfen
von unterschiedlicher Genauigkeit sein.
Alle Standardfunktionen und sonstigen Funktionen der Langzahl-Arithmetik
berechnen numerische Ergebnisse mit einer Genauigkeit, die durch den augenblicklichen Wert von stagprec bestimmt ist. Speicherzuweisung, das
¨
¨
Andern
der Gr¨oße von Arrays und das Arbeiten mit Subarrays verlaufen ahnlich wie bei den entsprechenden Datentypen einfacher Genauigkeit.
2.7.3.6
Ein- und Ausgabe in C-XSC
¨
Unter Verwendung des Stream-Konzeptes und der uberladbaren
Operatoren
<< und >> von C++ erm¨oglicht C-XSC das Runden und Formatieren aller sei¨
¨ die Dotprecisionner Datentypen wahrend
der Ein- und Ausgabe, auch fur
und Langzahldatentypen. Ein-/Ausgabe-Parameter wie die Richtung der
¨
Rundung, Feldbreite usw. benutzen auch die uberladenen
I/O-Operatoren
zum Formatieren der Ein- und Ausgabe. Falls ein neuer Satz von I/OParametern verwendet werden soll, kann der alte auf einem internen Stack
¨
gespeichert und bei Bedarf zuruckgeholt
werden. Das folgende Beispiel zeigt
die M¨oglichkeiten von C-XSC zur Ein- und Ausgabe:
main()
{
real a, b; interval c;
cout <<
cout <<
cin >>
cout <<
cin >>
"[0.11,
cout <<
cout <<
"Bitte reelle Zahlen a, b
RndDown;
a;
/*
RndUp;
b;
/*
0.22]" >> c;
/*
SaveOpt;
/*
SetPrecision(20, 16); /*
eingeben: ";
lies a abwaerts gerundet */
lies b aufwaerts gerundet */
String nach Intervall */
I/O-Parameter auf Stack */
Feldbreite, Stellen */
2.7 Klassen-Bibliotheken
187
cout << Hex;
cout << c << RestoreOpt;
/* hexadezimale Ausgabe */
/* alte I/O-Param. zurueck */
}
Quelle 2.72 : C-XSC-Programm mit formatierter Ein- und Ausgabe
2.7.3.7
C-XSC-Numerikbibliothek
Die C-XSC-Numerikbibliothek ist eine Sammlung von Funktionen und Programmen zur L¨osung von Standardaufgaben der numerischen Analysis mit
garantierter Genauigkeit der Ergebnisse. Folgende Bereiche werden abgedeckt:
• Auswertung und Nullstellen von Polynomen,
• Lineare Systeme, Matrizeninvertierung,
• Eigenwerte, Eigenvektoren,
• Schnelle Fourier-Transformation,
• Nullstellen nichtlinearer Gleichungen,
• Anfangswertprobleme bei gew¨ohnlichen Differentialgleichungen.
2.7.3.8
Beispiel Intervall-Newton-Verfahren
Zu bestimmen sei der Einschluß einer Nullstelle einer reellen Funktion f (x).
Die erste Ableitung f 0 (x) sei stetig im Intervall [a, b] und es gelte:
0∈
/ {f 0 (x), x ∈ [a, b]}
und f (a) · f (b) < 0.
Falls Xn eine Einschließung der Nullstelle ist, dann wird eine verbesserte
Einschließung Xn+1 mittels der Formel:
!
Xn+1
f (m(Xn ))
∩ Xn
:= m(Xn ) −
f 0 (Xn )
¨
berechnet, wobei m(X) ein Punkt im Intervall X ist, ublicherweise
die Mitte.
Die Funktion sei in diesem Beispiel:
√
f (x) = x + (x + 1) · cos x
Nun das Programm:
/* C-XSC-Programm Newton-Verfahren mit Intervallen
Funktion f(x) = sqrt(x) + (x + 1) cos(x)
Inst. Angewandte Mathematik, Universitaet Karlsruhe */
#include "interval.hpp"
#include "imath.hpp"
// Interval arithmetic package
// Interval standard functions
188
2 Programmieren in C/C++
interval f(real& x)
// Function f()
{
interval y;
y = x;
// Use interval arithmetic
return (sqrt(y) + (y + 1.0) * cos(y));
}
interval deriv(interval& x) // Derived function f’()
{
return (1.0 / (2.0 * sqrt(x)) + cos(x) - (x + 1.0) * sin(x));
}
int criter(interval& x)
// Function testing f(a)*f(b) < 0
{
interval Fa, Fb;
Fa = f(Inf(x));
Fb = f(Sup(x));
return (Sup(Fa * Fb) < 0.0 && !(0.0 <= deriv(x)));
// <= means element of
}
main()
{
interval y, y_old;
cout << "Please enter starting interval: "; cin >> y;
cout << "SetPrecision(20, 12);
if (criter(y))
do {
y_old = y;
cout << "y = " << y << endl;
y = (mid(y) - f(mid(y)) / deriv(y)) & y;
// & means intersection
} while (y != y_old);
else
cout << "Criterion not satisfied!" << endl;
}
Quelle 2.73 : C-XSC-Programm Intervall-Newton-Verfahren
Weitere Beispiele finden sich in dem Buch von R UDI K LATTE und anderen,
siehe Anhang H Zum Weiterlesen auf Seite 323.
2.7 Klassen-Bibliotheken
2.7.4
189
X11-Programmierung mit dem Qt-Toolkit
Qt ist eine Widget-Bibliothek der Firma Troll Tech (www.troll.no), die
¨ das X Window System (X11) als auch fur
¨ Microsoft Windows
sowohl fur
¨
¨
erhaltlich ist. Fur die Entwicklung freier UNIX-Software ist die Nutzung der
Bibliothek kostenlos; vor einiger Zeit hat Troll Tech die Bibliothek unter eine
¨
OpenSource-Lizenz (www.opensource.org) gestellt, so daß auch Anderungen an den Quellen erlaubt sind. Bekannt wurde Qt als Basis der Arbeitsumgebung KDE (www.kde.org).
Die X11-Programmierung gestaltet sich mit Qt deutlich einfacher als mit
¨ einerseits durch die Verwenanderen Bibliotheken (Motif) und ist gepragt
dung von C++, andererseits durch den Mechanismus von Signalen und
¨ wesentlich zur effizienteren und weniger fehleranfalligen
¨
Slots; beides tragt
Programmierung bei.
Die libQt eignet sich auch hervorragend, um das Konzept der objektorientierten Programmierung besser zu verstehen: Ben¨otigt man beispielsweise eine neue Art von Knopf, entwickelt man auf der Basis der abstrakten Klasse QButton eine neue Klasse, die damit alle Grundeigenschaften
von Kn¨opfen erbt (abstrakt bedeutet hier, daß die Klasse einige Funktionen
¨ die implementiert werden mussen,
¨
enthalt,
bevor die Klasse verwendet werden kann); neu schreiben muß man nur noch die Funktionen drawButton()
¨ die eigentliche Darstellung des Knopfes
und drawButtonLabel(), die fur
¨
verantwortlich zeichnen. Diese Vorgehensweise laßt
sich verallgemeinern:
Um ein neues Widget zu entwickeln, geht man von einem in der Bibliothek
¨
bereits vorhandenen aus, das in seinen Eigenschaften dem gewunschten
Ergebnis m¨oglichst nahe kommt, und schreibt nur diejenigen Funktionen neu,
die sich unterscheiden beziehungsweise dazukommen.
Signale und Slots gestalten die Kommunikation zwischen verschiedenen
Programmteilen. Ein Widget (z. B. ein Knopf) sendet bei einem bestimmten
¨
Ereignis (der Knopf wird vom Benutzer betatigt)
ein Signal aus (in diesem
Fall das Signal clicked()), das vorher mit einem Slot in einem anderen
Programmteil verbunden wurde. Viele Widgets beinhalten dearartige Slots;
¨
selbstverstandlich
kann man auch in seinen eigenen Klassen Funktionen als
Slots deklarieren.
Um eigene Klassen mit Slots zu implementieren, ist die Verwendung des
Meta Object Compilers moc vonn¨oten, der, auf die Klassendeklaration angewandt, einige Makros ersetzt; dieser Schritt ist notwendig, da das Konzept
¨
von Signalen und Slots nicht in C++ enthalten ist. Ublicherweise
wird man
die Klassendeklarationen in einem Include-File unterbringen, auf das dann
der Meta Object Compiler angewandt wird. Die Ausgabe von moc leitet man
in eine Datei mit der Kennung .moc um, die anstelle der Include-Datei mit
den Klassendeklarationen eingebunden wird.
Das folgende Beispiel besteht aus einem Makefile, einem Include-File und
dem eigentlichen Programm. Das Programm o¨ ffnet ein Fenster und bringt in
¨ derartige Zwecke klassidessen Mitte eine Beschriftung in Form eines fur
schen Textes sowie an der Fensterunterseite einen Knopf an. Wird der Knopf
190
2 Programmieren in C/C++
¨
¨
betatigt,
andert
sich die Beschriftung, und nach 1500 ms beendet sich das
Programm.
# Makefile fuer qhello
# es werden die Include-Files von X11 und Qt benoetigt
INC = -I/usr/X11R6/include -I/usr/lib/qt/include
# gelinkt wird gegen die libX11 (in /usr/X11R6/lib)
# und die libqt (in /usr/lib, dort automatisch gesucht)
LIB = -L/usr/X11R6/lib -lX11 -lqt
# der verwendete C++-Compiler -- hier GNU C++
CPP = g++
# benoetigt wird neben dem Source-Code das moc-File
all:
qhello.cpp qhello.moc
$(CPP) -o qhello qhello.cpp $(INC) $(LIB)
# moc-File wird aus qhello.h gewonnnen;
# moc muss im PATH stehen
qhello.moc:
qhello.h
moc qhello.h > qhello.moc
Quelle 2.74 : Makefile zu qhello.cpp
/* Include-File fuer qhello */
// Die Klasse HelloWidget erbt ihre Eigenschaften
// von der Klasse QWidget
class HelloWidget
: public QWidget
{
// Q OBJECT; muss in jeder Klasse, die Signals oder
// Slots implementiert, stehen
Q OBJECT;
// die Konstruktor-Funktion (ohne void)
public:
HelloWidget(QWidget *parent = 0, const char *name = 0);
// ein Signal, das diese Klasse aussendet
signals:
void neuerText( const char * );
// Pointer fuer verwendete Widgets
private:
QLabel *helloLabel;
QPushButton *quitButton;
QTimer *quitTimer;
// ein Slot, der spaeter mit quitButton verbunden wird
2.7 Klassen-Bibliotheken
191
private slots:
void tschuess();
};
Quelle 2.75 : Include-File zu qhello.cpp
/* qhello.cpp - Beispiel fuer die Programmierung mit Qt */
#include
#include
#include
#include
#include
<qapplication.h>
<qwidget.h>
<qlabel.h>
<qpushbutton.h>
<qtimer.h>
//
//
//
//
//
benoetigt jedes Qt-Programm
fuer unser Hauptfenster
fuer die Beschriftung
fuer den Quit-Button
fuer zeitverzoegertes Beenden
// an dieser Stelle wird das moc-File eingebunden;
// es enthaelt die Prototypen fuer unsere Klasse
#include "qhello.moc"
// die Konstruktorfunktion unserer Klasse
HelloWidget::HelloWidget(QWidget *parent, const char *name)
: QWidget( parent, name )
{
// die Groesse des Hauptfensters setzen
resize( 200, 100 );
// eine Beschriftung wird erzeugt und plaziert
helloLabel = new QLabel( "hello, world!", this );
helloLabel->move( 60, 30 );
// Signal neuerText()
// dieses Objekts wird mit helloLabel verbunden
// setText() ist Slot zum Setzen des Beschriftungstextes
connect(this, SIGNAL(neuerText(const char *)), helloLabel,
SLOT( setText( const char * ) ) );
// quitButton wird erzeugt und plaziert...
quitButton = new QPushButton( "Quit", this );
quitButton->move( 0, 80 );
quitButton->resize( 200, 20 );
// ... und verbunden mit unserem Slot tschuess()
connect(quitButton, SIGNAL(clicked()), this, \
SLOT(tschuess()));
}
// unser Slot tschuess(), der mit quitButton verbunden ist
void HelloWidget::tschuess()
{
// Signal neuerText() aussenden (an helloLabel)
emit( neuerText( "Tschuess!!!" ) );
// einen Timer einrichten und starten, Laufzeit 1500 ms
quitTimer = new QTimer( this );
192
2 Programmieren in C/C++
quitTimer->start( 1500 );
// bei Ablauf des Timers wird Slot quit() der Haupt// applikation ausgefuehrt, der das Programm beendet
connect(quitTimer, SIGNAL(timeout()), qApp, \
SLOT(quit()));
}
// Hauptprogramm
int main( int argc, char **argv )
{
// QApplication ist die Klasse fuer die Hauptapplikation
// argc und argv muessen uebergeben werden, um z. B.
// geometry-Informationen auszuwerten
QApplication MeineAnwendung( argc, argv );
// unser Hauptwidget
HelloWidget MeinWidget;
// setzen als MainWidget der Applikation
MeineAnwendung.setMainWidget( &MeinWidget );
// und darstellen
MeinWidget.show();
// hiermit wird die Hauptapplikation ausgefuehrt
return MeineAnwendung.exec();
}
Quelle 2.76 : C++-Programm qhello.cpp mit Verwendung des Qt-Toolkit
¨ das Hauptfenster werden ein neues Widget von der WidgetFur
Oberklasse QWidget abgeleitet, das Beschriftung und Knopf erzeugt und das
¨
Signal clicked(), welches der Knopf bei Betatigung
aussendet, mit dem
klasseneigenen Slot tschuess() verbunden. Dieser Slot sendet das ebenfalls
klasseneigene Signal neuerText() aus, das vorher mit dem Slot setText()
des Beschriftungsfeldes verbunden wurde. Dieser Slot setzt, seinem Namen
¨ den Text des Beschriftungsfeldes neu. Gleichzeitig wird ein Timer ergemaß,
zeugt und gestartet, der nach 1500 ms das Signal timeout() aussendet, welches wiederum mit dem Slot quit() der Hauptapplikation verbunden wird.
Die Funktion dieses Slots ergibt sich ebenfalls aus seinem Namen.
¨
Dieses Basisprogramm laßt
sich unter Zuhilfename der exzellenten
Online-Dokumentation zu Qt, die sich auf dem Webserver von Troll Tech
(www.troll.no) findet, schnell erweitern. Probieren Sie es aus: Die Pro¨ C++-Einsteiger und Anfanger
¨
grammierung mit Qt ist auch fur
in der X11Programmierung einfach zu erlernen und zeitigt schnell Erfolgserlebnisse.
¨
2.8 Uberladen
von Operatoren
2.8
193
¨
Uberladen
von Operatoren
Die arithmetischen Operationen auf Ganzzahlen unterscheiden sich von denen auf Gleitkommazahlen, insbesondere die Division. Dennoch verwenden
wir dieselben Operatoren. Das Programm erkennt aus dem Zusammenhang,
welche Art von Operation gefragt ist. Diese M¨oglichkeit, einem Operator je
nach Zusammenhang verschiedene Bedeutungen (Definitionen) zu geben, ist
¨ sich auf fast jeden Operator und jede
in C++ verallgemeinert worden und laßt
Funktion ausdehnen.
Wir sehen uns am Beispiel eines C++-Programmes zur Berechnung von
¨
Primzahlen nach dem Divisionsverfahren an, wie ein Operator uberladen
wird:
/* prim.C, C++-Programm zur Berechnung von Primzahlen
zu compilieren mit CC -o prim prim.C */
/* $Header: prim.C,v 1.5 98/07/08 10:56:50 wualex1 Exp $ */
#include <iostream.h>
#include <stdio.h>
/***********/
/* Klassen */
/***********/
class PRIM {
// Definition der Klasse PRIM
public:
PRIM(int, int);
PRIM& operator++();
int get count();
int get prim();
//
//
//
//
//
//
nach aussen sichtbar,
Methoden
Default Constructor
Ueberladen von ++ (Praefix)
Zugriff auf Anzahlen
Zugriff auf Primzahlen
int prim count;
int prim number;
//
//
//
//
nicht nach aussen sichtbar,
Daten
Anzahl der Primzahlen
aktuelle Primzahl
private:
};
/************/
/* Methoden */
/************/
PRIM::PRIM(int anzahl = 1, int primzahl = 2) // Constructor
{
prim count = anzahl;
prim number = primzahl;
}
// Folgende (triviale) Zugriffsmethoden sind erforderlich,
194
2 Programmieren in C/C++
// da die Variablen prim count und prim number privat sind:
int PRIM::get count()
{
return(prim count);
}
int PRIM::get prim()
{
return(prim number);
}
/***************************************/
/* Ueberladen des ++ Praefix-Operators */
/***************************************/
PRIM& PRIM::operator++()
{
if (prim number == 2)
prim number++;
++prim count;
return(*this);
}
{
// Test auf 2
// 2 + 1 = 3, naechste Primzahl
// Inkrementierung der Anzahl
// aktuelles Objekt zurueckgeben
for ( ; ; ) {
// ewige Schleife, bis break
prim number += 2; // naechste ungerade Zahl
int prim flag = 1;
// true
int haelfte = (prim number / 2);
for (int i = 3; i < haelfte; i += 2) {
if (((prim number / i) * i) == prim number) {
// false, teilbar
prim flag = 0;
break;
}
}
if (prim flag) break;
// Verlassen der e. S.
}
++prim count;
// Inkrementierung der Anzahl
return(*this);
// aktuelles Objekt zurueckgeben
}
/*****************/
/* Hauptprogramm */
/*****************/
int main(int argc, char *argv[])
{
int max;
PRIM pzahl;
// Obergrenze
// Erzeugung des Objektes pzahl
// Obergrenze ermitteln
if (argc > 1) {
sscanf(*(argv + 1), "%d", &max);
¨
2.9 Praprozessor
195
}
else {
cout << "Obergrenze eingeben: ";
cin >> max;
}
// Ueberschrift ausgeben
cout << "\nPrimzahlen bis " << max << " inkl.: \n\n";
// Primzahlen berechnen und ausgeben
while (pzahl.get prim() <= max) {
cout << pzahl.get prim() << ’\n’;
// naechste Primzahl mittels ++-Operator:
++pzahl;
}
// Schlussbemerkung
cout << "Gesamtzahl: " << pzahl.get count() - 1 << "\n\n";
return 0;
}
Quelle 2.77 : C++-Programm zur Berechnung von Primzahlen
¨
Im Hauptprogramm wird zunachst
die Obergrenze aus der Kommandozei¨
le oder im Dialog ermittelt. Dann wird eine Uberschrift
ausgegeben. Der Witz
¨
kommt im Rumpf der while-Schleife. Offenbar wird die jeweils nachste
Prim¨
¨
zahl durch den Prafix-Operator
++ erreicht, mit dem man vor der Uberladung
¨
nur Ganzzahlen um jeweils 1 inkrementieren konnte. Hinter dem uberlade¨
nen Operator versteckt sich der Algorithmus zur Berechnung der nachsten
Primzahl. Hier wird die Teilbarkeit der aktuellen Zahl prime_number dadurch ermittelt, daß sie durch die kleineren ungeraden Zahlen i ganzzahlig
dividiert und gleich wieder mit dem Divisor multipliziert wird. Ergibt sich der
alte Dividend, so verlief die Division ohne Rest, die aktuelle Zahl war teilbar
und somit keine Primzahl. So geht es auch, wir werden im Programm 2.93
auf Seite 226 den modulo-Operator verwenden.
¨
¨
Die Uberladung
bewirkt, daß der Prafix-Operator
++, angewandt auf ein
¨
¨
Objekt der Klasse PRIM, die jeweils nachste
Primzahl erzeugt. Man hatte
¨
auch einen anderen Operator nehmen k¨onnen. Die fur Klassen definierten
¨
¨
Operatoren wie :: durfen
nicht uberladen
werden, da sie gebraucht werden.
Bei Operatoren wie der Bedingten Bewertung ?: ist schwer vorstellbar, welche neue Bedeutung sie erhalten sollten.
2.9
¨
Praprozessor
¨
Beim Aufruf des Compilers wird der Quelltext als erstes von einem Prapro¨
zessor bearbeitet. Dieser fuhrt
die define- und include-Anweisungen
196
2 Programmieren in C/C++
aus und entfernt Kommentare sowie Zeichenpaare Backslash-Zeilenwechsel
(verbindet Fortsetzungszeilen, der Zeilenwechsel muss unmittelbar auf den
Backslash folgen).
2.9.1
define-Anweisungen
Die define-Anweisung dient zwei Zwecken: Sie definiert symbolische Konstanten sowie Makros. Eine symbolische Konstante ist ein konstanter Operand (auch ein String), der mit der define-Anweisung Namen und Wert
¨ und im weiteren Programm nur noch mit seinem Namen aufgerufen
erhalt
wird:
#define MWST 1.15
....
brutto = netto * MWST;
¨
¨
Damit erleichtert man Anderungen,
die sich so auf eine Stelle beschranken,
¨
und vermeidet das Auftauchen ratselhafter
Zahlen (magic numbers) mitten
¨
¨
im Programm. Bei Strings sind die Gansefußchen mit in die Definition zu
nehmen und beim Aufruf nicht zu wiederholen.
¨
Ein Makro ist eine nicht zu lange Folge von Ausdrucken
und Anweisungen, alternativ zu einer kurzen Funktion. Das Makro wird zu in-line-Code
¨
¨
und damit etwas schneller als die Funktion, die Parameterubergabe
entfallt.
¨
¨
Andererseits wird der ausfuhrbare
Code etwas langer.
Ein Beispiel:
#define NEWFILE fprintf(stderr, "File?\n");
if (gets(name) == NULL) done()
....
if (argc < 2) NEWFILE;
¨
¨
Der Praprozessor
ersetzt jedes NEWFILE im Programm buchstablich
durch
¨
die definierte Folge. Das spart Tipperei und verbessert die Ubersichtlichkeit.
¨
¨
Zeichenfolgen in Stringkonstanten (in Gansef
ußchen)
werden nicht ersetzt;
¨
das Programmchen:
#define PI 3.14159
int main()
{
printf("Die Zahl PI ist %f\n", PI);
}
schreibt wie erhofft auf den Bildschirm:
Die Zahl PI ist 3.141590
Bei arithmetischen Makros muß man aufpassen, damit sie nicht infolge von
¨
Vorrangregeln in unbeabsichtigter Weise ausgefuhrt
werden; am besten setzt
man deutliche Klammern:
¨
2.9 Praprozessor
197
#define DELTA(a, b) ((a) - (b))
¨
Hier k¨onnen die Ausdrucke
a und b aussehen, wie sie wollen, und in eine
beliebige Umgebung eingebettet sein, das Makro wird immer als Differenz
¨
¨
der beiden Ausdrucke
aufgefaßt. Im Gegensatz dazu wurde
eine Definition
ohne Klammern wie:
PROD(a, b) a * b
in einem Zusammenhang wie:
x = n * PROD(r - s, t + u);
¨
zu folgender Ersetzung fuhren:
x = n * r - s * t + u;
wie man durch manuelles Einsetzen leicht nachvollzieht, und das ist vermut¨
lich nicht das Gewunschte.
Mittels der undef-Anweisung widerruft man eine vorhergehende defineAnweisung. Das kommt selten vor. Hat man ein Makro und eine Funktion
desselben Namens und will unbedingt die Funktion haben, so undefiniert
man das Makro.
2.9.2
include-Anweisungen
¨
¨
Die include-Anweisung fuhrt
dazu, daß der Praprozessor
das anschließend
genannte File (Include-File, Header-File, Definitionsdatei) mit zu dem Pro¨
grammtext ladt,
bevor dieser zum eigentlichen Compiler gelangt. Die Include¨
Files ihrerseits enthalten symbolische Konstanten und Makros. Grundsatz¨
lich jedoch durfen
sie alles enthalten, was nicht gegen die Regeln von C/C++
verst¨oßt, also auch Kommentar oder Programmteile.
Die Namen der Standard-Include-Files sind in <> einzuschließen, die Na¨
¨
men eigener Include-Files in Gansef
ußchen.
Letztere werden zuerst in dem
¨
Verzeichnis gesucht, in dem auch das Quellprogramm steht. Falls der Prapro¨
zessor dort nicht fundig
wird, oder falls der Name in spitzen Klammern eingeschlossen ist, wird in vorgegebenen Verzeichnissen wie /usr/include ge¨ sich die Suche steuern.
sucht. Durch Compileroptionen (siehe man cpp) laßt
Die Include-Files sind lesbar und finden sich im Verzeichnis
/usr/include, vom Benutzer erstellte Include-Files im selben Verzeichnis
¨
wie die Programmquelle. Die File-Kennung .h ist ublich,
aber nicht notwen¨
dig. Als Beispiel sehen wir uns das haufig
gebrauchte File <stdio.h> in
¨
gekurzter
Form an:
/* @(#) $Revision: 56.4 $ */
#ifndef _NFILE
#define _NFILE 60
198
2 Programmieren in C/C++
#define BUFSIZ 1024
/*
* buffer size for multi-character output to
* unbuffered files
*/
#define _SBFSIZ 8
typedef struct {
int _cnt;
unsigned char *_ptr;
unsigned char *_base;
short _flag;
char _file;
} FILE;
/*
* _IOLBF means that a file’s output will be buffered
* line by line.
* In addition to being flags, _IONBF, _IOLBF and _IOFBF
* are possible values for "type" in setvbuf.
*/
#define _IOFBF 0000
#define _IOREAD 0001
#define _IOWRT 0002
#define _IONBF 0004
#define _IOMYBUF 0010
#define _IOEOF 0020
#define _IOERR 0040
#define _IOLBF 0200
#define _IORW 0400
#ifndef
#define
#endif
#ifndef
#define
#endif
NULL
NULL 0
EOF
EOF (-1)
#define stdin (&_iob[0])
#define stdout (&_iob[1])
#define stderr (&_iob[2])
#ifndef lint
#define get(p) ->_cnt < 0 ? _filbuf(p) : (int) *(p)->_ptr++)
#define putc(x, p)
(--(p)->_cnt < 0 ? \
¨
2.9 Praprozessor
199
_flsbuf((unsigned char) (x), (p)) : \
(int) (*(p)->_ptr++ = (unsigned char) (x)))
#define getchar()
getc(stdin)
#define putchar(x)
putc((x), stdout)
#define clearerr(p) ((void) ((p)->_flag &= \
˜(_IOERR | _IOEOF)))
#define feof(p)
((p)->_flag & _IOEOF)
#define ferror(p)
((p)->_flag & _IOERR)
#define fileno(p)
(p)->_file
#else
void clearerr();
#endif not lint
extern
extern
extern
extern
extern
extern
extern
extern
FILE _iob[_NFILE];
FILE *fopen(), *fdopen(), *freopen(), *popen();
FILE *tmpfile();
long ftell();
void rewind(), setbuf();
char *ctermid(), *cuserid(), *fgets(), *gets();
char *tmpnam();
unsigned char *_bufendtab[];
#endif NFILE
¨
Quelle 2.78 : Include-File /usr/include/stdio.h, gekurzt
¨
Die Standard-Include-Files wie stdio.h durfen
in beliebiger Reihenfol¨
¨
ge im Programm aufgefuhrt werden, auch mehrmals. Es durfen
auch zwei
¨
Standard-Include-Files aufgefuhrt
werden, die beide dasselbe Makro definieren. Ein Standard-Include-File schließt niemals ein anderes StandardInclude-File ein. Wie sich Nichtstandard-Include-Files verhalten, ist offen.
2.9.3
Bedingte Kompilation (#ifdef)
Bei der Programmentwicklung m¨ochte man gelegentlich leicht voneinan¨
der abweichende Fassungen eines ausfuhrbaren
Programms erzeugen, ohne
¨ verschiedene Quellfiles schreiben zu mussen.
¨
dafur
Unser C-Programm 2.93
auf Seite 226 zur Berechnung von Primzahlen hat verschiedene Obergren¨
zen, je nachdem ob es unter PC-DOS oder UNIX lauft.
Im Programmkopf vor
37
main() stehen daher folgende Zeilen :
#ifdef UNIX
#define MAX (unsigned long)1000000
#else
37 Manche
Zeile steht.
Compiler verlangen, daß das Doppelkreuz in jedem Fall am Beginn der
200
2 Programmieren in C/C++
#define MAX (unsigned long)100000
#endif
Die symbolische (benamte) Konstante MAX soll offenbar auf UNIX-Systemen
¨
einen h¨oheren Wert haben als auf PC-DOS-Systemen. Das hangt
mit der
Speichersegmentierung unter PC-DOS zusammen. Ruft man den Compiler
mit einer entsprechenden Option auf:
cc -o prim prim.c -DUNIX
so wird eine Konstante namens UNIX definiert und infolgedessen der if-Zweig
¨
vom Praprozessor
ausgewertet mit der Folge, daß die Konstante MAX, die
den untersuchten Zahlenbereich nach oben begrenzt, auf eine Million gesetzt
¨ die Option -DUNIX.
wird. Beim Kompilieren unter PC-DOS entfallt
Eine zweite Anwendung ist die Erzeugung von Programmversionen, die
¨
zwecks Fehlersuche etwas gesprachiger
sind als die Endfassung. Man gibt
beispielsweise Zwischenwerte folgendermaßen aus:
#define DEBUG 1
int main()
{
...
#if DEBUG
printf("Variable x hat den Wert %d\n", x);
#endif
...
}
Hier definieren wir in der Programmquelle ein symbolische Konstante DEBUG
¨
zu 1 (= true) und veranlassen damit den Praprozessor,
die printf()-Zeile
¨
einzubeziehen. Lauft
das Programm fehlerfrei, setzt man im Quellcode DEBUG
auf null. Ein anderes, im folgenden Programm angewendetes Verfahren fragt
nur danach, ob die Konstante DEBUG definiert ist oder nicht.
/* Programm itox zum Umrechnen von positiven ganzen Zahlen
zur Basis 10 auf eine andere Basis, z. B. 16 */
#define DEBUG
#define MAX 8
#include <stdio.h>
/* falls gewuenscht */
/* max. Stellen Ergebnis */
int umwandeln(int, int, int *);
int
{
int
int
int
int
/* Prototyp */
main()
b;
x;
i;
r[MAX];
/*
/*
/*
/*
neue Basis, als Dezimalzahl */
umzurechnende Dezimalzahl */
Schleifenzaehler */
Array des Ergebnisses */
¨
2.9 Praprozessor
201
while (1) {
printf("\n\nNeue Basis: ");
scanf("%d", &b);
printf("Dezimalzahl: ");
scanf("%d", &x);
/* einlesen */
if (b < 2) {
puts("Basis muss > 1 sein.");
continue;
}
if (x < 1) {
puts("Dezimalzahl muss > 0 sein.");
continue;
}
#ifdef DEBUG
printf("\nb = %d
#endif
x = %d\n\n", b, x);
for (i = 0; i < MAX; i++) {
r[i] = 0;
}
/* Array nullen */
umwandeln(b, x, r);
/* rechnen */
/*ausgeben */
printf("Die Dezimalzahl %d lautet zur Basis %d: ", x, b);
for (i = MAX - 1; i >= 0; i--) {
printf("%d ", r[i]);
}
} /* Ende while, Schleife mit control-c verlassen */
return 0;
}
/* Funktion umwandeln() */
int umwandeln(int b, int z, int *r)
{
int i, j, y;
while (z >= 1) {
y = 1;
for (i = 0; y <= z; i++) {
y *= b;
}
y = y / b; i--;
/* eins zuviel */
#ifdef DEBUG
printf("y = %d
#endif
i = %d\n", y, i);
for (j = 0; y <= z; j++) {
z -= y;
202
2 Programmieren in C/C++
}
#ifdef DEBUG
printf("z = %d
#endif
j = %d\n\n", z, j);
r[i] = j;
} /* Ende while */
return 0;
}
/* Ausgabe in Array */
Quelle 2.79 : C-Programm itox.c zur Umrechnung von Dezimalzahlen auf eine
andere Basis
2.9.4
¨
Memo Praprozessor
¨
• Im ersten Schritt des Kompiliervorgangs durchlauft
die Programmquel¨
le den Praprozessor.
¨
• Der Praprozessor
entfernt Kommentar, ersetzt symbolische Konstanten
¨ den Inhalt von Include-Files ein und
und Makros zeichengetreu, fugt
¨
berucksichtigt
bzw. verwirft Programmzeilen, die bedingt zu kompilieren sind.
2.9.5
¨
¨
Ubung
Praprozessor
¨
Erganzen
Sie das Programm zur Weganalyse dahingehend, daß es in der
DEBUG-Version nach jeder Teilstrecke die Zwischenergebnisse auf dem Bildschirm ausgibt, in der Endversion nur das Gesamtergebnis.
Schreiben Sie ferner alle Stringkonstanten in ein Include-File, von dem Sie
eine deutsche und eine englische oder franz¨osische Fassung herstellen. Beim
¨
Compiler-Aufruf soll mittels einer Option die Sprache ausgewahlt
werden.
2.10
Dokumentation
2.10.1
Zweck
Die Dokumentation dient dazu, ein Programm im Quellcode einem mensch¨
¨
lichen Leser verstandlich
zu machen. Langere
undokumentierte Programme sind nicht nachzuvollziehen. Eine Dokumentation38 geh¨ort zu jedem Pro¨
¨
gramm, das langer
als eine Seite ist und langer
als einen Tag benutzt werden
soll.
¨
Andererseits zahlt
das Schreiben von Dokumentationen nicht zu den Lieb¨
lingsbeschaftigungen
der Programmierer, das Erfolgserlebnis fehlt. Wir stel¨ Programme zum Eigengebrauch gelten; bei
len hier einige Regeln auf, die fur
kommerziellen Programmen gehen die Forderungen weiter.
38 Real
programmers write programs, not documentation.
2.10 Dokumentation
203
Die erste Gelegenheit zum Dokumentieren ist der Kommentar im Programm. Man soll reichlich kommentieren, aber keine nichtssagenden Bemer¨
kungen einflechten. Wenn der Kommentar etwa die Halfte
des ganzen Pro¨
gramms ausmacht, ist das noch nicht ubertrieben.
2.10.2
Anforderungen (DIN 66 230)
Zur Dokumentation legt die Norm DIN 66 230 Programmdokumentation Begriffe und Regeln fest. Eine weitere Norm ist der ANSI/IEEE Std 1063-1987
Standard for Software User Documentation in Verbindung mit einer Reihe
weiterer IEEE-Standards. Wir verwenden folgende vereinfachte Gliederung:
1. Allgemeines
• Name des Programms, Programmart (Vollprogramm, Funktion)
• Zweck des Programms
• Programmiersprache
• Computertyp, Betriebssystem
¨ (Drucker, Plotter, Maus)
• Gerate
• Struktur als Grafik, Fließbild
• externe Unterprogramme, soweit verwendet
2. Anwendung
• Aufruf
• Konstante, Variable
• Eingabe (von Tastatur, aus Files)
• Ausgabe (zum Bildschirm, Drucker, in Files)
¨
• Einschrankungen
• Fehlermeldungen
• Beispiel
• Speicherbedarf
• Zeitbedarf
3. Verfahren
• Algorithmus
• Genauigkeit
¨
• Gultigkeitsbereich
• Literatur zum Verfahren
4. Bearbeiter
• Name, Datum der Erstellung
204
2 Programmieren in C/C++
¨
• Name, Datum von Anderungen
¨
Das sieht nach Arbeit aus. Man braucht nicht in allen Fallen
alle Punkte
¨
¨ sich ein Prozu berucksichtigen,
aber ohne eine solche Dokumentation laßt
¨
gramm nicht zuverlassig
benutzen und weiterentwickeln. Im Netz finden sich
Werkzeuge, die in Verbindung mit dem Kommentar und der Struktur eines
Programmes halbautomatisch eine Dokumentation erstellen. Ein Beispiel ist
Doxygen:
http://www.doxygen.org/
¨
¨
¨
Zweckmaßig
beschaftigt
man sich mit solchen Werkzeugen fruhzeitig,
nicht
erst, wenn der Code fast fertig ist.
2.10.3
Erstellen einer man-Seite
Die inhaltliche Gliederung einer man-Seite wurde bereits im Abschnitt 1.5
¨
Wo schlagt
¨ man nach? auf Seite 13 erlautert.
Hier geht es um die technische
Herstellung. Hilfreich sind die man-Seiten zu man(1) und man(5).
Das Kommando man(1) sucht die Dokumentationen in den durch die
Umgebungs-Variable MANPATH bekannten Verzeichnissen. Das ist heute eine
¨
¨
lange Aufzahlung,
oft langer
als die unter PATH. Vom Benutzer eingerichtete
oder erstellte man-Seiten liegen vor allem unter:
• /usr/local/man/
• /usr/share/man/
• /opt/*/man/
¨ jede Sektion von 1 bis 9 bis zu vier
In diesen Verzeichnissen finden sich fur
Arten von Unterverzeichnissen:
• catx
• catx.Z
• manx
• manx.Z
¨ x die Sektionsnummer einzusetzen ist. Die Z-Verzeichnisse entwobei fur
halten die Dokumentationen komprimiert mit compress(1) (unter LINUX mit GNU-zip), die beiden anderen Verzeichnisse die unkomprimierten Texte. Die man-Verzeichnisse enthalten nroff(1)-Quelltexte, die
cat-Verzeichnisse die formatierten, druckfertigen Texte. Im Verzeichnis
/usr/share/man/man1.Z/ findet sich beispielsweise das File ls.1 mit der
komprimierten nroff-Quelle der man-Seite zum Kommando ls(1). Gegebenenfalls liegt unter /usr/share/man/man1/ die entkomprimierte nroffQuelle. Unter /usr/share/man/cat1.Z und /usr/share/man/cat1/ liegen die formatierten Seiten. Mittels:
cat /usr/share/man/cat1.Z/ls.1 | uncompress | more
2.11 Weitere C-Programme
205
k¨onnte man sich eine man-Seite anschauen, mit man(1) geht es einfacher.
Will man selbst eine man-Seite schreiben, kopiert man sich am besten eine
¨
ahnliche
man-Seite:
cat /usr/share/man/man1.Z/pwd.1 | uncompress > mycommand.1
und editiert diese. Vermutlich muß man sich vorher etwas mit dem nroffFormat auseinandersetzen und mit den unter man(5) beschriebenen Makros. Die so erzeugte unkomprimierte nroff(1)-Quelle geh¨ort in ein manVerzeichnis. Die mittels compress(1) verdichtete Qelle kommt ohne die
Kennung .Z nach man.Z/. Dann formatiert man die Quelle:
nroff mycommand.1 > mycommand.1.cat
und kopiert sie unter dem Namen mycommand.1 in ein cat-Verzeichnis.
Schließlich ist das formatierte File zu komprimieren und in ein cat.ZVerzeichnis zu stellen. Das File heißt in jeder Fassung immer nur
mycommand.1, das Format ergibt sich aus dem jeweiligen Verzeichnis. Man
braucht nicht alle Formate zu erzeugen, eines reicht.
Im WWW hat die Open Group unter dem URL:
http://www.opengroup.org/common_access/
ein umfangreiche Zusammenstellung von man-Seiten samt Suchmaschine
ver¨offentlicht. Eine Suche nach dem Begriff time ergab 43 Seiten, von at(1)
bis xshrealtime(). Die Zusammenstellung geh¨ort zur Single UNIX Spe¨ nicht die Seiten von zusatzlichen
¨
cification und enthalt
Programmen wie
sendmail(1).
¨ online-Hilfen das Texinfo-Format gebrauch¨
In der GNU-Welt ist fur
lich, das mittels des Kommandos info(1) gelesen wird. Einzelheiten am
¨ onlinebesten im WWW. Damit kommen wir zu einem dritten Weg fur
¨
Dokumentationen, namlich
HTML-Seiten, die mit einem WWW-Browser gelesen werden. Trotz der erweiterten M¨oglichkeiten (Unterteilung eines umfangreichen Themas, Hyperlinks, Grafik) dieser neueren Formate sind die
¨
durren
man-Seiten immer noch am weitesten verbreitet. Inhaltlich sind sie
¨
den Hilfen anderer Betriebssysteme ohnehin haushoch uberlegen.
2.11
Weitere C-Programme
2.11.1
Name
¨
Obwohl es aus den bisherigen Beispielen klar geworden sein mußte,
weisen
¨
wir nochmals darauf hin: Jedes selbstandige
C-Programm heißt im Quellcode
main(), ein anderer Programmname kommt – außer im Kommentar – nirgends im Quelltext vor (in FORTRAN oder PASCAL sieht die Sache anders
aus). Der Name des Files, in dem der kompilierte Code steht, ist der Name,
unter dem das Programm aufgerufen wird.
206
2 Programmieren in C/C++
Der Name des Files, in dem der Quellcode zu finden ist, hat die Kennung
.c; die meisten Programmierwerkzeuge erwarten das. Die UNIX-Compiler
¨
schreiben standardmaßig
das kompilierte Programm in ein File namens
a.out; Microsoft Quick-C nimmt den Namen des Quellfiles ohne die Ken¨
¨ das Ausganung. In beiden Fallen
kann man mit der Compiler-Option -o fur
befile einen beliebigen anderen Namen vereinbaren.
2.11.2
Aufbau
Wir kennen nun die Bausteine, aus denen sich ein Programm zusammen¨
¨
setzt. Wie sieht ein vollstandiges
Programm aus? Zunachst
einige Begriffe
zum Aufbau von Programmen.
Die kleinste Einheit, die etwas bewirkt, ist die Anweisung. Mehrere Anweisungen k¨onnen zu einem durch geschweifte Klammern zusammengefaßten Block vereinigt werden. Nach außen wirkt dieser Block wie eine einzige
¨ den GeltungsbeAnweisung. Der Block ist zugleich die kleinste Einheit fur
reich von Variablen.
Mehrere Anweisungen oder Bl¨ocke werden zu einer Funktion zusammengefaßt. Die Funktion ist die kleinste kompilierbare Einheit. Eine oder meh¨
rere Funktionen k¨onnen in einem File abgelegt sein. Dem Compiler ubergibt
¨
man im Minimum ein File, das eine Funktion enthalt.
Mehrere Files hin¨
¨
wiederum k¨onnen ein vollstandiges,
nach dem Kompilieren lauffahiges
Programm bilden. Erinnern Sie sich an das Werkzeug make(1)?
Das Minimalprogramm in C und C++ besteht aus einer Funktion –
¨
namlich
main() – deren Rumpf leer ist, in einem File:
main()
{
}
Quelle 2.80 : Minimales C-Programm
¨ das Hauptprogramm vorgeschrieben. main()
Der Name main() ist fur
ist eine Funktion, daher die beiden runden Klammern. Der durch die geschweiften Klammern umschlossene Block ist leer, main() tut nichts. Der
¨
¨
Syntaxprufer
lint(1) beanstandet, daß der Ruckgabewert
von main() undefiniert ist, was stimmt, uns aber nicht weiter st¨ort. Der Compiler erzeugt
¨
aus diesem Quellcode etwa 16 kB ausfuhrbaren
Code. Hinter main() steckt
einiges, was dem Programmierer verborgen ist.
¨
¨ einen defiAls nachstes
wollen wir main() als ganzzahlig deklarieren, fur
¨
nierten Ruckgabewert
sorgen und – wie es sich geh¨ort – mittels eines Kom¨
mentars das Verstandnis
erleichtern:
/* Dies ist ein einfaches C-Programm von hohem
paedagogischen, aber sonst keinem Wert. */
int main()
{
2.11 Weitere C-Programme
return 255;
}
207
/* 255 groesster zulaessiger Wert */
Quelle 2.81 : C-Programm, einfachst
Dieses Programm wird vom lint(1) gutgeheißen. Die Deklaration von
¨
main() als int k¨onnte entfallen, da sie unabanderlich
ist, aber wir wol¨
¨
len uns angew¨ohnen, alle Gr¨oßen ausdrucklich
zu deklarieren. Den Ruckgabewert k¨onnen Sie sich mit dem Shell-Kommando print $? nach der
¨
Ausfuhrung
anschauen.
¨
Um etwas Vernunftiges
zu tun, muß das Programm um einige Zeilen
angereichert werden. Wir deklarieren eine int-Variable namens i, weisen ihr einen Wert zu (definierende Deklaration) und verwenden die C¨ die Ausgabe auf stdout, den Bildschirm.
Standardfunktion printf(3) fur
printf(3) erwartet als erstes und notwendiges Argument einen Formatstring, dessen reichhaltige Syntax Sie im Referenz-Handbuch finden.
/* Dies ist ein einfaches C-Programm von hohem
paedagogischen, aber sonst fast keinem Wert. */
int main()
{
int i = 53;
printf("\nDer Wert betraegt %d\n", i);
return i;
}
Quelle 2.82 : C-Programm, einfach
¨
Nun soll auch der Praprozessor
Arbeit bekommen. Wir definieren eine
symbolische Konstante NUMBER und schließen vorsichtshalber das includeFile stdio.h ein, das man fast immer braucht, wenn es um Ein- oder Ausgabe geht. Weiterhin verwenden wir einen arithmetischen Operator und eine
Zuweisung:
/* Dies ist ein fortgeschrittenes C-Programm
#define NUMBER 2
#include <stdio.h>
int main()
{
int i = 53, x;
x = i + NUMBER;
printf("\nDer Wert betraegt %d\n", x);
return 0;
}
Quelle 2.83 : C-Programm, fortgeschritten
*/
208
2 Programmieren in C/C++
¨
Da ein Ausdruck sein Ergebnis zuruckgibt,
k¨onnen wir in der Funkti¨
on printf(3) anstelle von x auch die Summe hinschreiben. Als Ruckgabe¨
wert unseres Hauptprogrammes wollen wir den Ruckgabewert
der Funktion
¨
printf(3) haben, namlich
die Anzahl der ausgegebenen Zeichen. Das Pro¨
gramm wird kurzer,
aber auch schwieriger zu verstehen (falls man nicht ein
alter C-Hase ist):
/* Dies ist ein kleines C-Programm
*/
#define NUMBER 2
#include <stdio.h>
int main()
{
int i = 53;
return (printf("\nDer Wert betraegt %d\n", i + NUMBER));
}
Quelle 2.84 : C-Programm, fortgeschritten, Variante
¨
Der ausfuhrbare
Code ist damit auf 35 KB angewachsen. Jetzt wollen wir
die beiden Summanden im Dialog erfragen und die Summe als Makro schreiben. Außerdem soll die Rechnung wiederholt werden, bis wir eine Null eingeben:
/* Endlich mal was Vernuenftiges */
#define SUMME(x, y) (x + y)
#include <stdio.h>
int main()
{
int a = 1, b, i = 0;
while (a != 0) {
printf("Ersten Summanden eingeben : ");
scanf("%d", &a);
printf("Zweiten Summanden eingeben: ");
scanf("%d", &b);
printf("Die Summe ist %d\n", SUMME(a, b));
i++;
}
return i;
}
Quelle 2.85 : C-Programm mit Eingabe
¨
¨
Der Ruckgabewert
ist die Anzahl der Schleifendurchlaufe.
Die Stringkon-
2.11 Weitere C-Programme
209
stanten werden nicht mit puts(3) ausgegeben, da diese Funktion einen hier
¨
¨
unerwunschten
Zeilenvorschub anfugt.
Denken Sie daran, daß die Funktion
scanf(3) Pointer als Argumente braucht!
2.11.3
Fehlersuche
Einige Gesichtspunkte sind bereits im Abschnitt 2.2.4 Debugger auf Seite 47 behandelt worden. Der erfahrene Programmierer unterscheidet sich
¨
vom Anfanger
in drei Punkten:
• Er macht raffiniertere Fehler.
• Er weiß das.
• Er kennt die Wege und Werkzeuge zur Fehlersuche.
Fehlerfreie Programme schreibt auch der beste Programmierer nicht. Deshalb ist es wichtig, schon beim Programmentwurf an die Fehlersuche zu denken und vor allem das Programm so zu gestalten, daß es bei einem Fehler
¨
¨ das Schlimmste,
nicht ein richtiges Ergebnis vortauscht.
Das ist so ungefahr
was ein Programm machen kann. Dann lieber noch ein knallharter Absturz.
¨
Besser ist eine sanfte Notlandung mit einer aussagekraftigen
Fehlermeldung.
Die Programmeinheiten (Funktionen) lasse man nicht zu umfangreich
¨
werden. Ein bis zwei Seiten Quelltext uberschaut
man noch, wird es mehr,
sollte man die Funktion unterteilen. Weiterhin gebe man im Entwicklungsstadium an kritischen Stellen die Werte mittels printf() oder fprintf()
¨
aus. Diese Zeilen kommentiert man spater
aus oder klammert sie gleich in
¨
#ifdef- und #endif-Anweisungen ein. Bewahrt
hat sich auch, die eigenen
¨
¨
Programme einem anderen zu erklaren,
da wundert man sich manchmal uber
den eigenen Code. Ein Programm, das man nach ein bis zwei Wochen Pause
selbst nicht mehr versteht, war von vornherein nicht gelungen.
¨
Und wenn dann der Computerfreak zu nachtlicher
Stunde den Bugs hin¨
terherjagt, schließt sich ein weiter Bogen zuruck
in die Kreidezeit, denn die
¨
ersten Saugetiere
– Zeitgenossen der Saurier – waren auch nachtjagende Insektenfresser.
2.11.4
Optimierung
¨
Das erste und wichtigste Ziel beim Programmieren ist – nachst
der selbst¨
¨
verstandlichen,
aber unerreichbaren Fehlerfreiheit – die Ubersichtlich¨
¨
keit. Erst wenn ein Programm sauber lauft,
denkt man uber
eine Optimierung nach. Optimieren heißt schneller machen und Speicher einsparen, sowohl beim Code wie auch zur Laufzeit. Diese beiden Ziele widersprechen sich
manchmal. Im folgenden findet man einige Hinweise, die teils allgemein, teils
¨ C gelten.
nur fur
Die optimierende Compiler-Option -O ist mit Vorsicht zu gebrauchen.
¨
Es kommt vor, daß ein optimiertes Programm nicht mehr lauft.
Die Gewinne
¨
durch die Optimierung sind auch nur maßig.
Immerhin, der Versuch ist nicht
strafbar.
210
2 Programmieren in C/C++
Als erstes schaut man sich die Schleifen an, von geschachtelten die innersten. Dort sollte nur das Allernotwendigste stehen.
Bedingungen sollten so einfach wie m¨oglich formuliert sein. Mehrfache
Bedingungen sollten darauf untersucht werden, ob sie durch einfache ersetzt
werden k¨onnen. Schleifen sollten m¨oglichst dadurch beendet werden, daß die
Kontrollvariable den Wert Null und nicht irgendeinen anderen Wert erreicht.
¨
Kontrollvariable k¨onnen auch heruntergezahlt
werden statt herauf.
Eine Bedingung mit mehreren ands oder ors wird so lange ausgewertet,
bis die Richtigkeit oder Falschheit des gesamten Ausdrucks erkannt ist. Sind
mehrere Bedingungen durch or verbunden, wird die Auswertung nach Er¨
kennen des ersten richtigen Gliedes abgebrochen. Zweckmaßig
stellt man das
¨
Glied, das am haufigsten
richtig ist, an den Anfang. Umgekehrt ist ein Ausdruck mit durch and verbundenen Gliedern falsch, sobald ein Glied falsch ist.
¨
Das am haufigsten
falsche Glied geh¨ort an den Anfang.
¨
¨
¨ die switch-Anweisung. Die haufigste
¨
Ahnliche
Uberlegungen
gelten fur
Auswahl sollte als erste abgefragt werden. Ist das der default-Fall, kann er
durch eine eigene if-Abfrage vor der Auswahl abgefangen werden.
¨
¨
¨
Uberfl
ussige
Typumwandlungen – insbesondere die unauffalligen
impliziten – sollten zumindest in Schleifen vermieden werden. Der Typ numerischer Konstanten sollte von vornherein zu den weiteren Operanden passen.
¨
Beispielsweise fuhrt
float f, g;
g = f + 1.2345;
¨
zu einer Typumwandlung von f in double und einer Ruckwandlung
des Er¨
gebnisses in float, da Gleitkommakonstanten standardmaßig
vom Typ double
sind.
Gleitkommarechnungen sind aufwendiger als Rechnungen mit ganzen
¨
Zahlen und haben zudem noch Tucken
infolge von Rundungsfehlern. Eine
¨
Gleitkomma-Null ist nicht immer wirklich null. Wer mit Geldbetragen
rech¨
net, sollte mit ganzzahligen Centbetragen
anstelle von gebrochenen Eurobe¨
tragen
arbeiten. Wenn schon mit Gleitkommazahlen gerechnet werden muß
und der Speicher ausreicht, ist der Typ double vorzuziehen, der intern ausschließlich verwendet wird.
¨
Von zwei m¨oglichen Operationen ist immer die einfachere zu wahlen.
Beispielsweise ist eine Addition einfacher als eine Multiplikation, eine Multiplikation einfacher als eine Potenz und eine Bitverschiebung einfacher als
eine Multiplikation mit 2. Eine Abfrage
if (x < sqrt(y))
schreibt man besser
if (x * x < y)
Manchmal kann man durch Umstellen einer Formel die Anzahl der Rechenschritte verringern. Ob man mehrfach ben¨otigte Zwischenergebnisse speichert oder besser jedesmal neu berechnet, ist nicht allgemein zu entscheiden.
2.11 Weitere C-Programme
211
¨
Kleine Funktionen lassen sich durch Makros ersetzen, die vom Praprozessor in In-line-Code umgewandelt werden. Damit erspart man sich den Funk¨
¨
¨
tionsaufruf samt Parameterubergabe.
Der ausfuhrbare
Code wird geringfugig
¨
langer.
¨ eine Schleife nur einen Funktionsaufruf, ist es besser, die Schleife
Enthalt
in die Funktion zu verlegen, da jeder Funktionsaufruf Zeit kostet.
Die maßvolle Verwendung globaler Variabler verbessert zwar nicht den
Stil, aber die Geschwindigkeit von Programmen mit vielen Funktionsaufru¨
¨
fen, da die Parameterubergabe
entfallt.
Die Verwendung von Bibliotheksfunktionen kann in oft durchlaufenen
¨
Schleifen starker
verz¨ogern als der Einsatz spezialisierter selbstgeschriebener Funktionen, da Bibliotheksfunktionen allgemein und kindersicher sind.
¨
Verwenden Sie die einfachste Funktion, die den Zweck erfullt,
also puts(3)
anstelle von printf(3), wenn es nur um die Ausgabe eines Strings samt
Zeilenwechsel geht.
Die Adressierung von Arrayelementen durch Indizes ist langsamer als die
Adressierung durch Pointer. Der Prozessor kennt nur Adressen, also muß er
Indizes erst in Adressen umrechnen. Das erspart man ihm, wenn man gleich
mit Adressen sprich Pointern arbeitet. Wer die Pointerei noch nicht gewohnt
¨
ist, schreibt das Programm zunachst
mit Indizes, testet es aus und stellt es
dann auf Pointer um. Ein Beispiel:
long i, j, a[32];
/* Adressierung durch Indizes, langsam */
a[0] = a[i] + a[j];
/* Adressierung durch Pointer, schnell */
*a = *(a + i) + *(a + j);
Wir erinnern uns, der Name eines Arrays ist der Pointer auf das erste Element (mit dem Index 0). Experimente mit verschiedenen Compilern haben
¨
allerdings den Verdacht geschurt,
dass manche Compiler von sich aus die
¨
¨
schnellere Variante (Pointer) wahlen.
Ubergeben
Sie große Strukturen als
Pointer, nicht als Variable. Dadurch spart man das Kopieren der Daten.
¨ dieInput/Output ist immer zeitaufwendig. In vielen Programmen geht fur
se Aufgabe sogar der gr¨oßte Teil der Zeit drauf. Also unn¨otigen I/O vermeiden.
Den gr¨oßten Gewinn an Geschwindigkeit und manchmal auch zugleich
¨
an Speicherplatz erzielt man durch eine zweckmaßige
Datenstruktur und
¨
einen guten Algorithmus. Diese Uberlegungen geh¨oren jedoch an den Anfang der Programmentwicklung.
Wenn das alles noch nicht reicht, ist es Zeit, sich mittels eines Profilers
anzusehen, wo die Zeit verbraten wird, und vielleicht auch einige kritische
Programmteile in Assembler schreiben.
2.11.5
curses – Fluch oder Segen?
Im Englischen ist ein curse so viel wie ein Fluch, und die curses(3)¨
¨
Bibliothek ist fruher
wegen ihrer vielen Fehler oft verwunscht
worden. An-
212
2 Programmieren in C/C++
¨
dererseits erleichtert sie den Umgang mit dem Terminal unabhangig
von
dessen Typ. Wir beginnen mit einem einfachen Programm, das terminfoFunktionen aus der curses(3)-Bibliothek verwendet, um den Bildschirm
zu l¨oschen, wobei der Terminaltyp aus der Umgebungsvariablen TERM
und die zugeh¨origen Steuersequenzen aus der Terminalbeschreibung in
/usr/lib/terminfo(4) entnommen werden. Das Programm soll außer¨
dem, wenn ihm Filenamen als Argumente ubergeben
werden, die Files leeren,
ohne sie zu l¨oschen (der Bildschirm wird ja auch nicht verschrottet):
/* C-Programm, das Bildschirm oder Files loescht */
/* Compile: cc -o xclear xclear.c -lcurses */
/* falls terminfo-Fkt. verwendet werden sollen, noch
-DTERMINFO anhaengen */
#include <curses.h>
/* enthaelt stdio.h */
#ifdef TERMINFO
#include <term.h>
#endif
/* nur fuer terminfo */
int main(argc, argv)
int argc;
char *argv[];
{
int i;
if (argc > 1) {
/* Files leeren, nicht loeschen */
for(i = 1; i < argc; i++) {
if (!access(argv[i], 0))
close(creat(argv[i], 0));
else
printf("File %s unzugaenglich.\n", argv[i]);
}
}
else {
#ifdef TERMINFO
/* Bildschirm leeren, terminfo */
setupterm(0, 1, 0);
putp(clear screen);
resetterm();
#else
initscr();
refresh();
endwin();
#endif
/* Bildschirm leeren, curses */
2.11 Weitere C-Programme
213
}
return 0;
}
Quelle 2.86 : C-Programm zum Leeren des Bildschirms oder von Files
Das Kommando /usr/local/bin/xclear ist eine recht praktische Erweiterung von /bin/clear. Die Funktion setupterm() ermittelt vor allem den Terminaltyp. putp() schickt die Steuersequenz zum Terminal, und
reset_shell_mode() bereinigt alle Dinge, die setupterm() aufgesetzt
¨
hat. Mit diesen terminfo-Funktionen soll man nur in einfachen Fallen
wie dem obigen arbeiten, in der Regel sind die intelligenteren curses(3)Funktionen vorzuziehen.
Im folgenden Beispiel verwenden wir curses(3)-Funktionen zur Bildschirmsteuerung zum Erzeugen eines Hilfe-Fensters:
/* help.c, Programm mit curses-Funktionen */
/* Compiler: cc -o help help.c -lcurses */
#define END ((c == ’Q’) | (c == ’q’))
#define HELP ((c == ’H’) | (c == ’h’))
/* Makros */
#include <curses.h>
int main()
{
int
c, disp=1;
WINDOW *frame;
initscr();
noecho();
cbreak();
mvprintw(10,15,"Program demonstrating Curses-Windows");
mvprintw(11,15,"You get a help-window by pressing h");
mvprintw(LINES-1,0,"Press q to quit");
refresh();
while (1) {
c = getch();
if END {
clear();
refresh();
endwin();
return 0;
}
else
if HELP {
if (disp) {
frame = newwin(13,40,10,35);
wstandout(frame);
for (c = 0; c <= 4; c++)
mvwprintw(frame,c,0,"%42c",’ ’);
mvwprintw(frame,5,0,"Window built by curses. It may");
214
2 Programmieren in C/C++
mvwprintw(frame,6,0,"contain helpful messages.
");
mvwprintw(frame,7,0,"Delete the window by typing h.");
for (c = 8; c <= 12; c++)
mvwprintw(frame,c,0,"%42c",’ ’);
wrefresh(frame);
wstandend(frame);
}
else {
delwin(frame);
touchwin(stdscr);
refresh();
}
disp = !disp;
}
}
}
Quelle 2.87 : C-Programm mit curses-Funktionen
Jedes curses-Programm muß das include-File curses.h enthalten, das
seinerseits stdio.h einschließt. WINDOW ist ein in curses.h definierter
Datentyp, eine Struktur, die den Bildschirminhalt, die Cursorposition usw.
¨ Die curses(3)-Funktionen bewirken folgendes:
enthalt.
• initscr() muß die erste curses(3)-Funktion sein. Sie initialisiert
¨
die Datenstrukturen. Das Gegenstuck
dazu ist endwin(), die das Ter¨
minal wieder in seinen ursprunglichen
Zustand versetzt.
• noecho() schaltet das Echo der Tastatureingaben auf dem Bildschirm
aus.
• cbreak() bewirkt, daß jedes eingegebene Zeichen sofort an das Programm weitergeleitet wird – ohne RETURN.
• mvprintw() bewegt (move) den Cursor an die durch die ersten beiden
Argumente bezeichnete Position (0, 0 links oben) und schreibt dann in
das Standardfenster (sofern nicht anders angegeben). Syntax wie die CStandardfunktion printf(3).
• refresh() Die bisher aufgerufenen Funktionen haben nur in einen
¨
Puffer geschrieben, auf dem tatsachlichen
Bildschirm hat sich noch
¨
nichts geruhrt.
Erst mit refresh() wird der Puffer zum Bildschirm
¨
ubertragen.
• getch() liest ein Zeichen von der Tastatur
¨
• clear() putzt den Bildschirm beim nachsten
Aufruf von refresh()
• newwin() erzeugt ein neues Fenster – hier mit dem Namen frame – auf
der angegebenen Position mit einer bestimmten Anzahl von Zeilen und
Spalten.
• wstandout() setzt das Attribut des Fensters auf standout, d. h. auf
umgekehrte Helligkeiten beispielsweise. Gilt bis wstandend().
2.11 Weitere C-Programme
215
¨ ein bestimmtes Fenster.
• wrefresh() wie refresh(), nur fur
¨ zu newwin().
• delwin() l¨oscht ein Fenster, Gegenstuck
¨
• touchwin() schreibt beim nachsten
refresh() ein Fenster v¨ollig neu.
Die curses(3)-Funktionen machen von den Terminalbeschreibungen in den
/usr/lib/terminfo-Files Gebrauch, man braucht sich beim Programmieren um den Terminaltyp nicht zu sorgen. Andererseits kann man nichts verwirklichen, was in terminfo nicht vorgesehen ist, Grafik zum Beispiel.
2.11.6
¨
Mehr oder weniger zufallig
Man braucht im Leben manchmal Zufallszahlen (random number), zum Beispiel wenn eine Reihe von Vokabeln bunt durcheinander abgefragt werden
soll. Sind die Anforderungen nicht so hoch geschraubt, daß man erst einmal
¨
ein Philosophisches Seminar uber
den Begriff Zufall absolvieren muß, reichen
einige Funktionen aus der C-Standard-Bibliothek. Das folgende Programm
¨
¨
erzeugt eine Folge mehr oder weniger zufalliger
naturlicher
Zahlen und gibt
sie auf stdout aus:
/* random.c zur Erzeugung von Zufallszahlen
MAX Zufallszahlen von 1 bis MOD */
#define MAX 100
#define MOD 200
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int main()
{
int i, r, s;
s = (int) time((time t *) 0);
/*
srand((unsigned) s);
for (i = 0; i < MAX; i++) {
r = 1 + (rand() % MOD);
printf("%d\n", r);
}
*/
srandom((unsigned) s);
for (i = 0; i < MAX; i++) {
r = 1 + (random() % MOD);
printf("%d\n", r);
}
return 0;
216
2 Programmieren in C/C++
}
Quelle 2.88 : C-Programm zur Erzeugung von MAX Zufallszahlen im Bereich
von 1 bis MOD
Wir definieren die Anzahl MAX von Zufallszahlen, die wir brauchen, sowie
den Modulus MOD, der die gr¨oßte Zufallszahl bestimmt. Weiter binden wir die
¨ die Funktion printf(), time.h fur
¨ den SystemInclude-Files stdio.h fur
¨ die Funktionen srandom() und random()
aufruf time() und stdlib.h fur
¨
ein. Die Variable i ist ein Schleifenzahler,
r die jeweilige Zufallszahl und s
der sogenannte Seed (Samen), auch Salz genannt, den wir brauchen, um den
Zufallszahlengenerator zu starten.
Den Seed gewinnen wir aus der Systemuhr als Anzahl der Sekunden seit
dem 1. Januar 1970, 0 Uhr GMT. Damit ist sichergestellt, daß wir bei jedem
Aufruf einen anderen Wert haben. Die Syntax von time() holt man sich mittels man 2 time. Das Argument von time() ist hier der Nullpointer.
Die Funktion srand() oder srandom() startet den Generator rand()
beziehungsweise random. Beide Funktionspaare verwenden unterschiedliche
Algorithmen, siehe die zugeh¨origen man-Seiten. Das Ergebnis des Generators
wird modulo MOD genommen, um den Zahlenbereich zu begrenzen. Da wir
Zahlen von 1 bis MOD, die Grenzen eingeschlossen, haben wollen, addieren
¨
wir eine 1 hinzu. Das Ergebnis dieser Rechnung wird wie ublich
mittels der
Funktion printf() auf stdout ausgegeben.
Wir wollen nun das Programm so umstricken, daß die Rechnung in einer
¨
Funktion zufallszahl() durchgefuhrt
wird und das Hauptprogramm nur
die Zahlen ausgibt:
/* random2.c zur Erzeugung von Zufallszahlen
MAX Zufallszahlen von 1 bis MOD */
#define MAX 100
#define MOD 200
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
int zufallszahl(int m);
/* Prototyp */
int main()
{
int i;
for (i = 0; i < MAX; i++) {
printf("%d\n", zufallszahl((int) MOD));
}
return 0;
}
2.11 Weitere C-Programme
217
/* Funktion zufallszahl() */
int zufallszahl(int m)
{
static int r = 0;
unsigned s;
if (!r) {
s = (unsigned) time((time t *) 0);
srand(s);
}
r = 1 + (rand() % m);
return r;
}
Quelle 2.89 : C-Programm zur Erzeugung von MAX Zufallszahlen im Bereich
von 1 bis MOD, mit Funktion
Um die Funktion zufallszahl() allgemein verwendbar zu gestalten,
¨
ubergeben
wir den Modulus bei jedem Aufruf als Argument. Da der Generator nur beim ersten Aufruf gestartet werden soll, deklarieren wir die Variable r als static, initialisieren sie mit null und mißbrauchen sie als Flag
¨ den Generatorstart mittels srand(). Die Initialisierung wird nur einmal,
fur
¨
¨
beim Programmaufruf, ausgefuhrt.
Danach hat r immer den jeweils jungsten
Zufallswert, der minimal 1 ist und negiert stets false liefert.
¨ ein
Im wirklichen Leben verlangte die Aufgabe eine C-Funktion fur
¨
PASCAL-Programm. Hierzu mussen
Funktion und Hauptprogramm in getrennten Files vorliegen, da es keine zweisprachigen Compiler gibt. Also wurden die C-Funktion isoliert und ein Rahmenprogramm zum Testen in PASCAL geschrieben:
/* Funktion zufallszahl.c zur Erzeugung von Zufallszahlen
MAX Zufallszahlen von 1 bis MOD */
#include <time.h>
#include <stdlib.h>
int zufallszahl(int m)
{
static int r = 0;
unsigned s;
if (!r) {
s = (unsigned) time((time t *) 0);
srand(s);
}
218
2 Programmieren in C/C++
r = 1 + (rand() % m);
return r;
}
Quelle 2.90 : C-Funktion zur Erzeugung einer Zufallszahl im Bereich von 1
bis MOD
Die C-Funktion gibt pro Aufruf eine Zufallszahl im Bereich von 1 bis zum
¨
¨
Modulus zuruck,
der als Argument ubergeben
wird.
{PASCAL-Programm, das C-Funktion aufruft}
{Compileraufruf pc -o prandom prandom.p zufallszahl.o}
{Funktion zufallszahl() braucht als Argument den Modulus}
program prandom (input, output);
var a, i, x: integer;
function zufallszahl(x: integer): integer;
external C;
begin
writeln(’Bitte Modulus eingeben!’);
readln(x);
writeln(’Bitte Anzahl eingeben!’);
readln(a);
writeln(’Zufallszahlen:’);
for i := a downto 1 do
writeln(zufallszahl(x));
end.
Quelle 2.91 : PASCAL-Programm zur Erzeugung von Zufallszahlen im Bereich von 1 bis MOD, mit C-Funktion
Die Compileraufrufe lauten:
cc -c zufallszahl.c
pc -o prandom prandom.p zufallszahl.o
Die gemischte Programmierung funktioniert hier reibungslos, weil beide
Sprachen den Typ Ganzzahl kennen und die C-Funktion einfach ist.
Wie wir anfangs auf Seite 3 bemerkt haben, ist es prinzipiell unm¨oglich,
mit einer deterministischen Maschine Zufallsergebnisse zu erzeugen. Die vorstehenden Programme liefern daher auch nur Pseudo-Zufallszahlen (pseudo
random number), die hinsichtlich bestimmter Eigenschaften mit echten Zu¨
¨ viele Zwecke reicht das, fur
¨ einen Vokabelfallszahlen ubereinstimmen.
Fur
¨
trainer sicherlich. Eine ausfuhrliche
Diskussion findet sich bei D ONALD E.
K NUTH.
2.11 Weitere C-Programme
2.11.7
219
¨ Pointer
Ein Herz fur
¨
Pointer sind nicht schwierig, sondern allenfalls gew¨ohnungsbedurftig.
Sie
sind bei C-Programmierern beliebt, weil sie zu eleganten und schnellen Pro¨
grammen fuhren.
Wir wollen uns an Hand einiger Beispiele an ihren Gebrauch gew¨ohnen. Eine Wiederholung:
¨
• Der Computer kennt nur Speicherplatze
in Einheiten von einem Byte.
Jedes Byte hat eine absolute Adresse (Hausnummer), die uns aber
nichts angeht.
• Die Deklaration einer Variablen erzeugt eine Variable mit einem Namen
und bestimmten Eigenschaften, darunter den durch den Typ bestimmten Speicherbedarf in Bytes.
• Die Definition einer Variablen weist ihr einen Wert zu, belegt Speicherplatz und damit eine Adresse.
¨ ihre Speicheradresse. Da uns der
• Der Pointer auf eine Variable enthalt
absolute Wert der Adresse nicht interessiert, greifen wir auf den Pointer
mittels seines Namens zu. Heißt die Variable x, so ist &x der Name des
Pointers.
¨ man die Variable durch
• Deklariert man zuerst den Pointer px, so erhalt
¨
Dereferenzierung *px. Es ist nicht immer gleichgultig,
ob man den Poin¨ durch Referenzieren
ter oder die Variable deklariert und das Gegenstuck
bzw. Dereferenzieren handhabt.
• Eine Variable kann notfalls auf einen Namen verzichten, aber niemals
auf ihren Pointer.
¨
• Pointer sind keine ganzen Zahlen (die Arithmetik lauft
anders).
• Ein Pointer auf eine noch nicht oder nicht mehr existierende Variable
¨
hangt
in der Luft (dangling pointer) und ist ein Programmfehler.
Nun einige Beispiele zu bestimmten Anwendungen von Pointern.
2.11.7.1
Nullpointer
Die Zahl Null ist die einzige Konstante, die sinnvollerweise einem Pointer zu¨
gewiesen werden kann. Auf dieser Adresse liegt kein gultiges
Datenobjekt,
sie tritt nur in Verbindung mit Fehlern oder Ausnahmen auf. Um die Besonderheit dieser Adresse hervorzuheben, schreibt man sie meist nicht als Ziffer,
sondern als Wort NULL. Im Include-File stdio.h ist das Wort als symbolische Konstante mit dem Wert 0 definiert.
Im Programm 2.98 Sortieren nach Duden auf Seite 237 kommen beim
¨
Offnen
eines Files zum Lesen folgende Zeilen vor:
if ((fp = fopen(argv[1], "r")) == NULL) {
printf("File %s kann nicht goeffnet werden.\n", argv[1]);
exit(1);
}
220
2 Programmieren in C/C++
Die Funktion fopen(), die das File o¨ ffnet, gibt bei Mißerfolg – aus welchen
¨
¨
Grunden
auch immer – anstatt eines Filepointers den Nullpointer zuruck.
¨
Falls der Vergleich positiv ausfallt,
also bei Mißerfolg, wird eine Fehlermeldung ausgegeben und das Programm mit dem Systemaufruf exit() verlas¨ der Pointer fp die Adresse des Fileanfangs.
sen. Bei Erfolg enthalt
2.11.7.2
Pointer auf Typ void
Man braucht gelegentlich einen Pointer, der auf eine Variable von einem
¨
zunachst
noch unbekannten Typ zeigt. Wenn es dann zur Sache geht, legt
man den Typ mittels des cast-Operators fest.
¨
¨ Pointer auf den Typ char, denn dieser Typ beFruher
nahm man dafur
legt genau ein Byte, woraus man jeden anderen Typ aufbauen kann. Nach
¨ der Typ void zu wahlen.
¨
ANSI ist hierfur
Jeder Pointer kann ohne Verlust
an Information per cast in einen Pointer auf void verwandelt werden, und
¨
umgekehrt. Die Pointer belegen ja selbst – unabhangig
vom Typ, auf den sie
zeigen – gleich viele Bytes.
Im folgenden Beispiel wird eine Funktion xread() vorgestellt, die jede
¨
Tastatureingabe als langen String ubernimmt
und dann die Eingabe – er¨
¨
forderlichenfalls nach Prufung
– in einen gewunschten
Typ umwandelt. Die
¨ scanf(3) mit der M¨oglichkeit, fehlerhafte EinFunktion ist ein Ersatz fur
gaben nach Belieben zu behandeln. Als erstes ein Programmrahmen, der die
Funktion xread() aufruft, dann die Funktion:
/* Fkt. xread() zum Einlesen und Umwandeln von Strings */
/* mit Rahmenprogramm main() zum Testen, 1992-05-11 */
#include <stdio.h>
int xread(void *p, char *typ);
void exit();
/* Systemaufruf */
int main()
{
int error = 0;
int x;
double y;
char z[80];
/* Integer-Eingabe */
printf("Bitte Ganzzahl eingeben: \n");
if (!xread(&x, "int")) {
printf("Die Eingabe war: %d\n", x);
}
else {
puts("Fehler von xread()");
error = 1;
}
/* Gleitkomma-Eingabe */
2.11 Weitere C-Programme
221
printf("Bitte Gleitkomma-Zahl eingeben: \n");
if (!xread(&y, "float")) {
printf("Die Eingabe war: %f\n", y);
}
else {
puts("Fehler von xread()");
error = 1;
}
/* Stringeingabe */
printf("Bitte String eingeben: \n");
if (!xread(z, "char")) {
printf("Die Eingabe war: %s\n", z);
}
else {
puts("Fehler von xread()");
error = 1;
}
exit(error);
}
/* Funktion xread() */
/* Parameter: Variable als Pointer, C-Typ als String */
#define MAXLAENGE 200
#include <string.h>
int atoi();
long atol();
double atof();
/* max. Laenge der Eingabe */
/* Standard-C-Bibliothek */
/* Standard-C-Bibliothek */
/* Standard-C-Bibliothek */
int xread(p, typ)
void *p;
char *typ;
{
char input[MAXLAENGE];
int rwert = 0;
if (gets(input) != NULL) {
switch(*typ) {
case ’c’:
/* Typ char */
strcpy((char *)p, input);
break;
case ’i’:
/* Typ int */
case ’s’:
/* Typ short */
*((int *)p) = atoi(input);
break;
case ’l’:
/* Typ long */
*((long *)p) = atol(input);
break;
case ’d’:
/* Typ double */
case ’f’:
/* Typ float */
222
2 Programmieren in C/C++
*((double *)p) = atof(input);
break;
default:
puts("xread: Unbekannter Typ");
rwert = 1;
}
}
else {
puts("xread: Fehler bei Eingabe");
rwert = 2;
}
return rwert;
}
Quelle 2.92 : C-Programm mit Pointer auf void
Die Funktion xread() braucht als erstes Argument einen Pointer (aus
demselben Grund wie scanf(3), call by reference) auf die einzulesende Va¨
riable, als zweites Argument den gewunschten
Typ in Form eines Strings. Auf
eine wechselnde Anzahl von Argumenten verzichten wir hier.
¨ jeden einzulesenden Typ eine eigene Funktion schreiFalls wir nicht fur
ben wollen, muß xread() einen Pointer auf einen beliebigen Typ, sprich
¨
void, ubernehmen.
Erst nach Auswertung des zweiten Argumentes weiß
¨ einen Typ der Pointer zeigt.
xread(), auf was fur
¨
Das Programm lauft
in seiner obigen Fassung einwandfrei, der Syntax¨
Prufer
lint(1) hat aber einige Punkte anzumerken.
2.11.7.3
Arrays und Pointer
Das folgende Programm berechnet die Primzahlen von 2 angefangen bis zu
einer oberen Grenze, die beim Aufruf eingegeben werden kann. Ihr Maxi¨
¨
malwert hangt
verstandlicherweise
vom System ab. Aus Geschwindigkeits¨
¨
grunden
werden reichlich Pointer verwendet. Ursprunglich
wurden die Ele¨
mente der Arrays uber
Indizes angesprochen, was den Gewohnheiten entgegenkommt. Bei der Optimierung wurden alle Indizes durch Pointer ersetzt,
¨
wie im Abschnitt 2.11.4 Optimierung auf Seite 209 erlautert.
/* Programm zur Berechnung von Primzahlen, 1990-10-03 */
/* Compileraufruf MS-DOS/QuickC: qcl prim.c */
/* Compileraufruf unter UNIX: cc -o prim prim.c -DUNIX */
/* Die groesste zu untersuchende Zahl wird unter MS-DOS
durch die Speichersegmentierung bestimmt. Kein Datensegment p[] darf groesser als 64 KB sein. Damit liegt
MAX etwas ueber 150000.
Unter UNIX begrenzt der verfuegbare Speicher die
Groesse. Der Datentyp unsigned long geht in beiden
Faellen ueber 4 Milliarden. */
#ifdef UNIX
#define MAX (unsigned long)1000000
2.11 Weitere C-Programme
223
#else
#define MAX (unsigned long)100000
#endif
#define MIN (unsigned long)50
/* Defaultwert fuer Obergrenze */
#define DEF (unsigned long)10000
#include <stdio.h>
/* globale Variable */
unsigned
unsigned
unsigned
unsigned
unsigned
long p[MAX/10];
d[MAX/1000];
long h[2][11];
long z = 1;
n = 1;
/*
/*
/*
/*
/*
Array der Primzahlen */
Haeufigkeit der Differenzen */
Haeufigkeit der Primzahlen */
aktuelle Zahl */
lfd. Anzahl Primzahlen - 1 */
/* Funktionsprototypen */
void ttest();
long time();
/* Funktion Teilbarkeitstest */
/* Systemaufruf zur Zeitmessung */
int main(int argc,char *argv[])
/* Hauptprogramm */
{
int r;
int i = 1, j, k;
unsigned long ende = DEF;
unsigned long *q;
unsigned long dp, dmax = 1, d1, d2;
unsigned long g;
long zeit1, zeit2, zeit3;
/* Auswertung der Kommandozeile */
/* dem Aufruf kann als Argument die Obergrenze
mitgegeben werden */
/* keine Pruefung auf negative Zahlen oder Strings */
if (argc > 1) {
sscanf(*(argv + 1), "%lu", &ende);
if (ende > MAX) {
printf("\nZ. zu gross! Maximal %lu\n", MAX);
exit(1);
}
if (ende < MIN) {
printf("\nZ. zu klein; genommen wird %lu\n\n\n", \
MIN);
ende = MIN;
}
if (g = ende % 10) {
printf("\nZ. muss durch 10 teilbar sein: %lu\n\n\n", \
ende=ende - g);
224
2 Programmieren in C/C++
}
}
/* Algorithmus */
time(&zeit1);
*p = 2; *(p + 1) = 3;
ende -= 3;
/* die ersten Primzahlen */
while (z < ende) {
z += 4;
ttest();
z += 2;
ttest();
}
/*
Da z pro Durchlauf um 6 erhoeht wird, kann eine
Primzahl zuviel berechnet werden,
gegebenenfalls loeschen
*/
if (*(p + n) > (ende = ende + 3))
n -= 1;
/* Berechnung der Haeufigkeit in den Klassen */
g = ende/10; **h = 1; **(h + 1) = 0; j = 1; k = 0;
for (i = 0; i <= n; i++) {
if (*(p + i) > g) {
*(*h + j) = g;
*(*(h + 1) + j) = i - k;
k = i;
j++;
g += ende/10;
}
}
*(*h + j) = g;
*(*(h + 1) + j) = i - k;
/* Berechnung der Differenz benachbarter Primzahlen */
for (i = 1; i <= n; i++) {
dp = *(p + i) - *(p + i - 1);
(*(d + dp))++;
if (dp > dmax) {
dmax = dp;
d1 = *(p + i);
d2 = *(p + i - 1);
}
2.11 Weitere C-Programme
225
}
time(&zeit2);
/* achtspaltige Ausgabe auf stdout */
printf("\tPrimzahlen bis %lu\n\n", ende);
j = n - ( r = ((n + 1) % 8));
q = p;
for (i = 0; i <= j; i += 8) {
printf("\t%6lu\t%6lu\t%6lu\t%6lu\t%6lu\t%6lu\t%6lu \
\t%6lu\n", *q, *(q+1), *(q+2), *(q+3), \
*(q+4), *(q+5), *(q+6), *(q+7));
q += 8;
}
if (r != 0) {
printf("\t");
for (i = 0; i < r; i++)
printf("%6lu\t", *(q+i));
puts("");
}
/* letzte Zeile */
printf("\n\tGesamtzahl: %u\n\n", n + 1);
for (i = 1; i <= 10; i++)
printf("\tZwischen %6lu und %6lu gibt es
%6u Primzahlen.\n",*(*h+i-1),*(*h+i),*(*(h+1)+i) );
puts("");
printf("\tDifferenz %3d kommt %6u mal vor.\n",\
1, *(d + 1));
for (i = 2; i <= dmax; i += 2)
printf("\tDifferenz %3d kommt %6u mal vor.\n", \
i, *(d + i));
printf("\n\tGroesste Differenz %lu kommt erstmals
bei %lu und %lu vor.\n",dmax,d2,d1);
time(&zeit3);
printf("\n\tDie Rechnung brauchte %ld s,", zeit2 - zeit1);
printf(" die Ausgabe %ld s.\n", zeit3 - zeit2);
return 0;
}
/* Ende Hauptprogramm */
/* Funktion zum Testen der Teilbarkeit */
226
2 Programmieren in C/C++
/* Parameteruebergabe zwecks Zeitersparnis vermieden */
void ttest()
{
register int i;
for (i = 1; *(p + i) * *(p + i) <= z; i++)
if (!(z % *(p + i))) return;
/* z teilbar */
*(p + (++n)) = z;
/* z prim */
return;
}
Quelle 2.93 : C-Programm zur Berechnung von Primzahlen, mit Pointern anstelle von Arrayindizes
Zur Laufzeit zeigt sich, daß die meiste Zeit auf die Ausgabe verwendet
wird. Daher die Programmiererweisheit: Eingabe/Ausgabe vermeiden! Am
¨ die
Algorithmus und seiner Verwirklichung etwas zu optimieren, bringt fur
Gesamtdauer praktisch nichts. Die Ausgabe-Funktion printf(3) ließe sich
durch eine selbstgeschriebene, schnellere Funktion ersetzenr, unter Abstri¨
chen an die Allgemeingultigkeit.
2.11.7.4
Arrays von Funktionspointern
Der Name einer Funktion ohne das Klammernpaar ist der Pointer auf ihren Anfang. Es gibt Arrays von Pointern, das ist nichts Besonderes. Also gibt
es auch Arrays von Pointern auf Funktionen. Anhand eines Beispiels wollen
wir uns eine Verwendungsm¨oglichkeit und einige syntaktische Feinheiten ansehen. Dabei kommt auch make(1) nochmal zur Geltung sowie ein bißchen
Grafikprogrammierung.
/* schiff.c, Befeuerung und Schallsignale nach BinSchStrO
MS-Quick-C, DOS, VGA-Grafik */
/* #define
#include
#include
#include
#include
#include
DEBUG */
<stdio.h>
<conio.h>
<graph.h>
<stdlib.h>
<time.h>
#include "schiff.h"
/*
/*
/*
/*
/*
fuer
fuer
fuer
fuer
fuer
puts() u. a. */
getch() und kbhit() */
Grafik */
rand(), Zufallszahlen */
time(), Zufallszahlen */
/* eigenes Includefile */
/* Funktionsprototypen */
extern int titel();
void done();
/* Hauptprogramm */
int main()
/* Titelbildschirm */
/* Aufraeumen */
2.11 Weitere C-Programme
{
int i, rf, x;
struct videoconfig vc;
int (*schiff[MAX])(), index[MAXARR];
time t zeit;
/* Titel und Vorspann */
rf = titel();
/* Grafikmodus VGA 16 Farben */
if (! setvideomode( VRES16COLOR)) {
puts("Fehler: Keine VGA-Grafik");
exit(1);
}
setbkcolor(BGRAU);
/* Array der Funktionen (Bilder) fuellen */
schiff[0] = bild000; schiff[1] = bild001;
schiff[2] = bild002; schiff[3] = bild003;
....
schiff[124] = bild124; schiff[125] = bild125;
/* Index-Array fuellen (Zufallszahlen) */
if (rf == 49) {
time(&zeit);
srand((unsigned)zeit);
for (i = 0; i < MAXARR; i++) {
x = rand() % MAX;
if (x == index[i - 1])
x = rand() % MAX;
index[i] = x;
}
}
else {
for (i = 0; i < MAXARR; i++)
index[i] = i % MAX;
}
#ifdef DEBUG
for (i = 0; i < MAXARR; i++)
printf("%d\n", index[i]);
while (!kbhit());
#endif
/* Koordinatensystem */
/* x nach rechts, x = 0 in Mitte;
y nach unten, y = 0 oben */
227
228
2 Programmieren in C/C++
getvideoconfig(&vc);
setlogorg(vc.numxpixels / 2 - 1, 0);
/* Textfenster */
settextwindow(7 * vc.numtextrows / 8, 4, vc.numtextrows, \
vc.numtextcols - 3);
wrapon( GWRAPOFF);
/* Hauptschleife */
i = 0;
do {
/* Hintergrund (Tag - Nacht) */
if ( getbkcolor() == BSCHWARZ) {
setbkcolor(BGRAU);
setcolor(HWEISS);
}
else {
setbkcolor(BSCHWARZ);
setcolor(SCHWARZ);
}
if ( getbkcolor())
settextcolor(HWEISS);
else
settextcolor(SCHWARZ);
/* Aufruf der Fkt. zum Zeichnen der Schiffe */
(*schiff[index[i]])();
/* Tastatureingabe zum Weitermachen */
if ((x = getch()) == 13 || x == 43 || x == 45) {
if (x == 45) i--;
else i++;
if (i >= MAXARR || i <= 0) i = 0;
clearscreen( GCLEARSCREEN);
setbkcolor(BGRAU);
}
} while (x != 81 && x != 113);
done();
}
/* Ende main() */
/* Funktion done() zur Beendigung */
/* Ruecksetzen auf Defaultwerte */
void done()
{
2.11 Weitere C-Programme
229
clearscreen( GCLEARSCREEN);
setvideomode( DEFAULTMODE);
exit(0);
}
Quelle 2.94 : C-Programm Array von Pointern auf Funktionen
Das Programm zeichnet die Konturen von Binnenschiffen samt ihrer Befeuerung (Positionslichter etc.) auf den Schirm. Tuten kann es auch. Ist der
Hintergrund schwarz (Nacht), sieht man nur die Lichter, ist er grau (Tag),
sieht man auch die Konturen und die Bildunterschrift. Die verschiedenen Arten der Befeuerung werden durch jeweils eine Funktion bild***() erzeugt.
Die Funktionspointer stehen in einem Array:
int (*schiff[MAX]);
/* MAX = 126, in schiff.h */
¨
Die Funktionen werden uber
ihren Index aufgerufen, die Reihenfolge wird
von einem weiteren Array:
int index[MAXARR];
/* MAXARR ein Mehrfaches von MAX */
¨
bestimmt, das entweder mit einer wiederholten Folge der naturlichen
Zahlen
von 0 bis MAX - 1 belegt ist oder mit einer Zufallsfolge von Zahlen dieses
Intervalles. So kann man sich die Befeuerungen in einer systematischen oder
¨
zufalligen
Folge anzeigen lassen.
Die Funktionen bild***() sind in einem File in einem eigenen Unterverzeichnis vereinigt:
/* Funktionen bild*() */
#include "bilder.h"
/*************/
/* Sportboot */
/*************/
...
int bild001()
{
text0("Bild 001:");
text1("Sportboot von vorn");
sportboot(0);
feuersport1();
return 0;
}
...
Quelle 2.95 : C-Funktion bilder.c zum Programm schiff.c
230
2 Programmieren in C/C++
Die Funktionen rufen im wesentlichen weitere Funktionen auf. Das Un¨ ein eigenes Include-File und ein eigenes Makefile. In
terverzeichnis enthalt
¨
gleicher Weise sind die ubrigen
Funktionen organisiert.
Das Makefile des Hauptprogramms ruft Makefiles in den Unterverzeichnissen auf. Wir haben also eine Hierarchie von Makefiles:
# makefile fuer schiff.c
include make.h
# Compiler-Auswahl, make-include
# Unterverzeichnisse
A
B
F
K
S
T
=
=
=
=
=
=
assem
bilder
feuer
kontur
schall
text
# Weitere Makros
OBJS = schiff.obj titel.obj bilder.obj text.obj \
feuer.obj schall.obj kontur.obj sound.obj \
nosound.obj delay.obj
# Anweisungen
all : schiff.exe install clean
schiff.exe : schiff.obj titel.obj bilder o text o \
feuer o kontur o schall o assem o
$(LD) $(LDFLAGS) $(OBJS),,,,
schiff.obj : schiff.c schiff.h
$(CC) $(CFLAGS) schiff.c
titel.obj : titel.c
$(CC) $(CFLAGS) titel.c
bilder o :
cd $(B)
$(MAKE) all
cd ..
text o :
cd $(T)
$(MAKE) all
cd ..
feuer o :
cd $(F)
$(MAKE) all
cd ..
2.11 Weitere C-Programme
231
kontur o :
cd $(K)
$(MAKE) all
cd ..
schall o :
cd $(S)
$(MAKE) all
cd ..
assem o
:
cd $(A)
$(MAKE) all
cd ..
install :
$(CP) schiff.exe s.exe
clean :
$(RM) *.bak
$(RM) *.obj
Quelle 2.96 : Makefile zu schiff.c
¨
Dieses Projekt – obwohl bescheiden – ware
ohne make(1) nur noch
¨
¨ das Gelingen entscheidend, sich zu Bemuhsam
zu beherrschen. Es ist fur
¨
¨
ginn die Struktur sorgfaltig
zu uberlegen.
Infolge der Verwendung von Grafikfunktionen des MS-Quick-C-Compilers
¨
¨
ist das Programm nicht auf andere Systeme ubertragbar.
Man mußte
eigene
Grafikfunktionen verwenden, die Verpackungen um die Grafikfunktionen des
¨ die Funktion zum Tuten,
jeweiligen Compilers darstellen. Dasselbe gilt fur
eine Assemblerroutine. Vielleicht stellen wir das Programm einmal auf X11
um und verpacken dabei die spezifischen Funktionen.
2.11.8
Verarbeitung von Strings
Strings (Zeichenketten) sind in C/C++ ein denkbar einfacher Datentyp,
¨
namlich
Arrays of char, die mit dem ASCII-Zeichen Nr. 0 abgeschlossen sind.
¨ die haufig¨
In der Standard-C-Bibliothek finden sich fertige Funktionen fur
sten Aufgaben der Stringverarbeitung. Trotzdem hat dieses Gebiet ein paar
¨
kleine Tucken.
Ein beliebter Laufzeitfehler ist das Schreiben von Strings in Pufferspei¨
cher, die zu klein sind. Es kommt dann zu einem Uberlauf
mit nicht immer
vorhersehbaren Folgen, manchmal auch zu von b¨osen Buben beabsichtigten
Folgen. Man meint, der Puffer sei reichlich bemessen – es ist auch jahrelang
¨
alles gut gegangen – und dann taucht einmal ein uberlanger
String auf, der
¨
den Puffer sprengt. Das Gegenmittel besteht im Beschranken
des Schreibens
auf maximal ein Zeichen weniger als der Puffer fasst. Wo Eingaben verlangt
werden, ist immer damit zu rechnen, dass:
232
2 Programmieren in C/C++
• die Eingabe leer ist (leerer String, nur ASCII-Nr. 0) oder
¨
• zu lang ist (Uberlauf)
Ein gewiefter Programmierer sieht solche Fehler oder Ausnahmen voraus.
gets() – fgets()
2.11.9
Dynamische Speicherverwaltung (malloc)
Wir haben gelernt, daß die Gr¨oße eines Arrays oder einer Struktur be¨
reits zur Ubersetzungszeit
bekannt sein, d. h. im Programm stehen muß.
¨
¨
Dies fuhrt
in manchen Fallen
zur Verschwendung von Speicher, da man Ar¨
rays in der maximal m¨oglichen Gr¨oße anlegen mußte.
Die Standardfunktion malloc(3) samt Verwandtschaft hilft aus der Klemme. Im folgenden
¨
Beispiel wird ein Array zunachst
nur als Pointer la deklariert, dann mittels calloc(3) Speicher zugewiesen, mittels realloc(3) vergr¨oßert und
schließlich von free(3) wieder freigegeben:
/* Programm allo.c zum Ueben von malloc(3), 1994-06-01 */
#define MAX 40
#define DELTA 2
#include <stdio.h>
#include <stdlib.h>
long *la;
/* Pointer auf long */
int main()
{
int i, x;
/* calloc() belegt Speicher fuer Array von MAX Elementen
der Groesse sizeof(long), initialisert mit 0,
gibt Anfangsadresse zurueck.
In stdlib.h wird size t als unsigned int definiert. */
la = (long *)calloc((size t)MAX, (size t)sizeof(long));
if (la != NULL)
puts("Zuordnung ok.");
else {
puts("Ging daneben.");
exit(-1);
}
/* Array anschauen */
printf("Ganzzahl eingeben: ");
scanf("%d", &x);
for (i = 0; i < MAX; i++)
la[i] = (long)(i * x);
2.11 Weitere C-Programme
printf("Ausgabe: %ld
233
%ld\n", la[10], la[20]);
/* Array verlaengern mit realloc() */
la = (long *)realloc((void *)la, \
(size t)(DELTA * sizeof(long)));
/* Array anschauen */
la[MAX + DELTA] = x;
printf("erweitert: %ld
%ld\n", la[10], la[MAX + DELTA]);
/* Speicher freigeben mit free() */
free((void *)la);
return 0;
}
Quelle 2.97 : C-Programm mit dynamischer Speicherverwaltung (malloc(3))
¨
Das nachste
Beispiel sortiert die Zeilen eines Textes nach den Regeln des
Duden (Duden-Taschenbuch Nr. 5: Satz- und Korrekturanweisungen), die von
den Regeln in DIN 5007 etwas abweichen.
/* "duden" sortiert Textfile zeilenweise nach dem ersten
Wort unter Beruecksichtigung der Duden-Regeln */
/* Falls das Wort mit einem Komma endet, wird auch das
naechste Wort beruecksichtigt (z. B. Vorname) */
/* Compiler: cc -O -o duden duden.c -lmalloc */
#include
#include
#include
#include
<stdio.h>
<malloc.h>
<sys/types.h>
<sys/stat.h>
#define MAX 1024
/* max. Anzahl
#define EXT ".s"
/* Kennung des
#define NOWHITE(c) \
(((c) != ’ ’) && ((c) != ’\t’) &&
#define NOCHAR(c) \
(((c) == ’ ’) || ((c) == ’\t’) ||
#define SCHARF(c) (((c) == ’˜’) || ((c) ==
#define KOMMA(c) ((c) == ’,’)
der Zeilen */
sort. Files */
((c) != ’\n’))
((c) == ’\0’))
222)) /* sz */
/* statische Initialisierung eines externen Arrays */
/* ASCII-Tafel. Die Zahlen stellen die Nummer des
Zeichens dar. */
/* angefuegt HP ROMAN EXTENSION (optional) */
char wert[256] = {
/* Steuerzeichen */
234
2 Programmieren in C/C++
0, 1, 2, 3, 4, 5, 6, 7, 8, 9,
10, 11, 12, 13, 14, 15, 16, 17, 18, 19,
20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
30, 31,
/* Space, Sonder- und Satzzeichen */
32, 33, 34, 35, 36, 37, 38, 39,
40, 41, 42, 43, 44, 45, 46, 47,
/* Ziffern */
65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
/* Sonder- und Satzzeichen */
48, 49, 50, 51, 52, 53, 89,
/* Grossbuchstaben */
75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
/* Sonder- und Satzzeichen */
75, 89, 95, 58, 59, 60,
/* Kleinbuchstaben */
75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
88, 89, 90, 91, 92, 93, 94, 95, 96, 97,
/* Sonder- und Satzzeichen */
75, 89, 95, 93,
/* DEL */
111,
/* ROMAN EXTENSION */
/* undefinierte Zeichen */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0,
/* Buchstaben */
75, 75, 79, 79, 79, 83, 83,
/* Zeichen */
0, 0, 0, 0, 0,
/* Buchstaben */
93, 93,
/* Zeichen */
0, 0, 0, 0, 0,
/* Buchstaben */
77, 77, 88, 88,
/* Zeichen */
0, 0, 0, 0, 0, 0, 0, 0,
/* Buchstaben */
75, 79, 89, 95, 75, 79, 89, 95,
75, 79, 89, 95, 75, 79, 89, 95,
75, 83, 89, 75, 75, 83, 89, 75,
75, 83, 89, 95, 79, 83, 93, 89,
75, 75, 75, 78, 78, 83, 83, 89,
89, 89, 89, 93, 93, 95, 99, 99,
101, 101,
/* Zeichen und undefinierte Zeichen */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0
};
85, 86, 87,
98, 99, 100,
85, 86, 87,
98, 99, 100,
2.11 Weitere C-Programme
char *ap[MAX];
235
/* P. auf Zeilenanfaenge */
/* Hauptprogramm */
int main(int argc, char *argv[])
{
int flag = 0, i = 0, j;
char a, *mp;
FILE *fp, *fps;
struct stat buf;
extern char *ap[];
extern char *strcat();
void exit();
/* Pruefung des Programmaufrufs */
if (argc != 2) {
printf("Aufruf: duden FILENAME\n");
exit(1);
}
/* Arbeitsspeicher allokieren */
stat(argv[1], &buf);
if ((mp = malloc((unsigned)buf.st size)) == NULL) {
printf("Kein Speicher frei.\n");
exit(1);
}
ap[0] = mp;
/* Textfile einlesen, fuehrende NOCHARs loeschen */
if ((fp = fopen(argv[1], "r")) == NULL) {
printf("File %s kann nicht goeffnet werden.\n", \
argv[1]);
exit(1);
}
while((a = fgetc(fp)) != EOF) {
if ((flag == 0) && NOCHAR(a));
else {
flag = 1;
*mp = a;
if (*mp == ’\n’) {
flag = 0;
ap[++i] = ++mp;
}
else
mp++;
}
}
236
2 Programmieren in C/C++
fclose(fp);
/* Zeilenpointer sortieren */
if (sort(i - 1) != 0) {
printf("Sortieren ging daneben.\n");
exit(1);
}
/* Textfile zurueckschreiben */
if ((fps = fopen(strcat(argv[1], EXT), "w")) == NULL) {
printf("File %s.s kann nicht geoeffnet werden.\n", \
argv[1]);
exit(1);
}
for (j = 0; j < i; j++) {
while ((a = *((ap[j])++)) != ’\n’)
fputc(a, fps);
fputc(’\n’, fps);
}
fclose(fps);
}
/* Ende Hauptprogramm */
/* Sortierfunktion (Bubblesort, stabil) */
int sort(int imax)
{
int flag = 0, i = 0, j = 0, k = 0;
char *p1, *p2;
extern char *ap[];
while (flag == 0) {
flag = 1;
k = i;
p2 = ap[imax];
for (j = imax; j > k; j--) {
p1 = ap[j - 1];
if (vergleich(p1, p2) <= 0) {
ap[j] = p2;
p2 = p1;
}
else {
ap[j] = p1;
i = j;
flag = 0;
}
}
ap[j] = p2;
2.11 Weitere C-Programme
237
}
return(0);
}
/* Vergleich zweier Strings bis zum ersten Whitespace */
/* Returnwert = 0, falls Strings gleich
Returnwert < 0, falls String1 < String2
Returnwert > 0, falls String1 > String2 */
int vergleich(char *x1, *x2)
{
int
flag = 0;
while((wert[*x1] - wert[*x2]) == 0) {
if (NOWHITE(*x1)) {
if (SCHARF(*x1)) x2++;
/* scharfes s */
if (SCHARF(*x2)) {
x1++;
flag = 1;
}
x1++;
x2++;
}
else {
if (KOMMA(*(x1 - 1))) {
/* weiteres Wort */
while (NOCHAR(*x1))
x1++;
while (NOCHAR(*x2))
x2++;
flag = vergleich(x1, x2);
}
return flag;
}
}
return(wert[*x1] - wert[*x2]);
}
Quelle 2.98 : C-Programm zum Sortieren eines Textes nach den Regeln des
Duden
Die Variable flag, die auch anders heißen kann, ist ein Flag oder eine
¨
Schaltvariable, d. h. eine Variable, die in Abhangigkeit
von bestimmten Bedingungen einen Wert 0 oder nicht-0 annimmt und ihrerseits wieder in ande¨
ren Bedingungen auftritt. Ein gangiger,
einwandfreier Programmiertrick.
2.11.10
X Window System
Das folgende Beispiel zeigt, wie man unter Benutzung von Xlib-Funktionen
¨
ein Programm schreibt, das unter dem X Window System lauft:
/* xwindows.c, this program demonstrates how to use
238
2 Programmieren in C/C++
X’s base window system through the Xlib interface */
/* Compiler: cc xwindows.c -lX11 */
#include <stdio.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#define
#define
#define
#define
#define
#define
#define
#define
QUIT
CLEAR
DELETE
SUBWIN
DELSUB
WIN1
WIN2
WIN3
"Press q to quit"
"Press c to clear this window"
"Press d to delete this window"
"Press n to create subwindow"
"Press n again to delete window"
"WINDOW 1"
"WINDOW 2"
"WINDOW 3"
char hallo[]="Hallo World";
char hi[]
="Hi";
int main(int argc,char **argv)
{
Display
*mydisplay;
/* d. structure */
Window
mywin1, mywin2, newwin; /* w. structure */
Pixmap
mypixmap;
/* pixmap */
GC
mygc1, mygc12, newgc;
/* graphic context */
XEvent
myevent;
/* event to send */
KeySym
mykey;
/* keyboard key */
XSizeHints
myhint;
/* window info */
Colormap
cmap;
/* color map */
XColor
yellow, exact, color1, color2, color3;
static XSegment segments[]={{350,100,380,280}, /
{380,280,450,300}};
unsigned long myforeground;
/* fg color */
unsigned long mybackground;
/* bg color */
int
myscreen, i, num=2, del=1, win=1;
char
text[10];
/* initialization */
if (!(mydisplay = XOpenDisplay(""))) {
fprintf(stderr, "Cannot initiate a display connection");
exit(1);
}
myscreen = DefaultScreen(mydisplay); /* display screen */
/* default pixel values */
mybackground = WhitePixel(mydisplay, myscreen);
myforeground = BlackPixel(mydisplay, myscreen);
/* specification of window position and size */
myhint.x = 200; myhint.y = 300;
myhint.width = 550; myhint.height = 450;
myhint.flags = PPosition | PSize;
/* window creation */
2.11 Weitere C-Programme
239
mywin1 = XCreateSimpleWindow(mydisplay,
DefaultRootWindow(mydisplay),
myhint.x, myhint.y, myhint.width, myhint.height,
5, myforeground, mybackground);
XSetStandardProperties(mydisplay, mywin1, hallo, hallo, \
None, argv, argc, &myhint);
myhint.x = 400; myhint.y = 400;
myhint.width = 700; myhint.height = 200;
myhint.flags = PPosition | PSize;
mywin2 = XCreateSimpleWindow(mydisplay,
DefaultRootWindow(mydisplay),
myhint.x, myhint.y, myhint.width, \
myhint.height, 5, myforeground, mybackground);
/* creation of a new window */
XSetStandardProperties(mydisplay, mywin2, "Hallo", \
"Hallo", None, argv, argc, &myhint);
/* pixmap creation */
mypixmap = XCreatePixmap(mydisplay,
DefaultRootWindow(mydisplay),
400, 200, DefaultDepth(mydisplay, myscreen));
/* GC creation and initialization */
mygc1 = XCreateGC(mydisplay, mywin1, 0, 0);
mygc12 = XCreateGC(mydisplay, mywin2, 0, 0);
newgc = XCreateGC(mydisplay, mywin2, 0, 0);
/* determination of default color map for a screen */
cmap = DefaultColormap(mydisplay, myscreen);
yellow.red = 65535; yellow.green = 65535; yellow.blue = 0;
/* allocation of a color cell */
if (XAllocColor(mydisplay, cmap, &yellow) == 0) {
fprintf(stderr, "Cannot specify color");
exit(2);
}
/* allocation of color cell using predefined
color-name */
if (XAllocNamedColor(mydisplay, cmap, "red", &exact, \
&color1) == 0)
{
fprintf(stderr, "Cannot use predefined color");
exit(3);
}
if (XAllocNamedColor(mydisplay, cmap, "blue", &exact, \
&color2) == 0)
{
fprintf(stderr, "Cannot use predefined color");
exit(3);
}
if (XAllocNamedColor(mydisplay, cmap, "green", \
240
2 Programmieren in C/C++
&exact, &color3) == 0)
{
fprintf(stderr, "Cannot use predefined color");
exit(3);
}
XSetWindowBackground(mydisplay, mywin1, color2.pixel);
/* changing the background of window */
XSetWindowBackground(mydisplay, mywin2, color3.pixel);
XSetBackground(mydisplay, mygc1, color2.pixel);
/* setting foreground attribute in GC structure */
XSetForeground(mydisplay, mygc1, yellow.pixel);
/* setting background attribute in GC structure */
XSetForeground(mydisplay, mygc12, color1.pixel);
XSetBackground(mydisplay, mygc12, color3.pixel);
XSetBackground(mydisplay, newgc, mybackground);
XSetFont(mydisplay, mygc1, XLoadFont(mydisplay, \
"vrb-25"));
/* setting font attribute in GC structure */
XSetFont(mydisplay, mygc12, XLoadFont(mydisplay, \
"vri-25"));
XSetFont(mydisplay, newgc, XLoadFont(mydisplay, \
"vri-25"));
/* window mapping */
XMapRaised(mydisplay, mywin1);
XMapRaised(mydisplay, mywin2);
/* input event selection */
XSelectInput(mydisplay, mywin1, \
KeyPressMask | ExposureMask);
XSelectInput(mydisplay, mywin2, \
KeyPressMask | ExposureMask |
ButtonPressMask);
/* main event-reading loop */
while (1) {
XNextEvent(mydisplay, &myevent); /* read next event */
switch (myevent.type) {
/* process keyboard input */
case KeyPress:
i = XLookupString(&myevent, text, 10, &mykey, 0);
if (i == 1 && (text[0] == ’q’ | text[0] == ’Q’)) {
XFreeGC(mydisplay, mygc1);
XFreeGC(mydisplay, mygc12);
XFreeGC(mydisplay, newgc);
if (!win) XDestroyWindow(mydisplay, newwin);
XDestroyWindow(mydisplay, mywin1);
if (del) XDestroyWindow(mydisplay, mywin2);
XFreePixmap(mydisplay, mypixmap);
XCloseDisplay(mydisplay);
exit(0);
}
else
if (i == 1 && (text[0] == ’c’ | text[0] == ’C’) &&
2.11 Weitere C-Programme
241
myevent.xkey.window == mywin1) {
XClearWindow(mydisplay, mywin1);
XSetFont(mydisplay, mygc1, \
XLoadFont(mydisplay, "fgb-13"));
XDrawImageString(mydisplay, mywin1, mygc1, \
240, 400,
SUBWIN, strlen(SUBWIN));
XDrawImageString(mydisplay, mywin1, mygc1, \
240, 420,
CLEAR, strlen(CLEAR));
XDrawImageString(mydisplay, mywin1, mygc1, \
240, 440,
QUIT, strlen(QUIT));
XSetFont(mydisplay, mygc1, \
XLoadFont(mydisplay, "vrb-25"));
}
else
if (i == 1 && (text[0] == ’d’ | text[0] == ’D’) \
&& myevent.xkey.window == mywin2) {
XDestroyWindow(mydisplay, mywin2);
del = 0;
}
else
if (i == 1 && (text[0] == ’n’ | text[0] == ’N’) \
&& myevent.xkey.window == mywin1) {
if (win) {
newwin = XCreateSimpleWindow(mydisplay, \
mywin1, 70, 60, 400, 200, 1, \
myforeground, mybackground);
/* window mapping */
XMapRaised(mydisplay, newwin);
XSetForeground(mydisplay, newgc, \
mybackground);
XFillRectangle(mydisplay, mypixmap, newgc,
0, 0, 400, 200);
XSetForeground(mydisplay, newgc, \
color1.pixel);
XDrawImageString(mydisplay, mypixmap, newgc,
140, 100, WIN3, strlen(WIN3));
XSetFont(mydisplay, newgc, \
XLoadFont(mydisplay, "fgb-13"));
XDrawImageString(mydisplay, mypixmap, newgc, 25,
180, DELSUB, strlen(DELSUB));
XSetFont(mydisplay, newgc, \
XLoadFont(mydisplay, "vri-25"));
/* copying pixels from pixmap to window */
XCopyArea(mydisplay, mypixmap, newwin, newgc, \
0, 0, 400, 200, 0, 0);
}
else
XDestroySubwindows(mydisplay, mywin1);
win = !win;
}
break;
242
2 Programmieren in C/C++
/* repaint window on expose event */
case Expose:
if (myevent.xexpose.count == 0) {
XDrawImageString(mydisplay, mywin1, mygc1,
50, 50, WIN1, strlen(WIN1));
XDrawImageString(mydisplay, mywin2, mygc12,
270, 50, WIN2, strlen(WIN2));
XSetFont(mydisplay, mygc1, \
XLoadFont(mydisplay, "fgb-13"));
XDrawImageString(mydisplay, mywin1, mygc1, \
240, 400, SUBWIN, strlen(SUBWIN));
XDrawImageString(mydisplay, mywin1, mygc1, \
240, 420, CLEAR, strlen(CLEAR));
XDrawImageString(mydisplay, mywin1, mygc1, \
240, 440, QUIT, strlen(QUIT));
XSetFont(mydisplay, mygc1, \
XLoadFont(mydisplay, "vrb-25"));
XDrawImageString(mydisplay, mywin2, mygc12, \
300, 180, DELETE, strlen(DELETE));
XDrawLine(mydisplay, mywin1, mygc1, \
100, 100, 300, 300);
XDrawSegments(mydisplay, mywin1, mygc1, \
segments, num);
XDrawArc(mydisplay, mywin1, mygc1, 200, \
160, 200, 200, 0, 23040);
XFillArc(mydisplay, mywin1, mygc12, 60, \
200, 120, 120, 0, 23040);
XDrawRectangle(mydisplay, mywin1, mygc1, \
60, 200, 120, 120);
}
break;
/* process mouse-button presses */
case ButtonPress:
XSetFont(mydisplay, mygc1, \
XLoadFont(mydisplay,"vxms-37"));
XDrawImageString(myevent.xbutton.display, \
myevent.xbutton.window, mygc1, \
myevent.xbutton.x, \
myevent.xbutton.y, \
hi, strlen(hi));
XSetFont(mydisplay, mygc1, \
XLoadFont(mydisplay, "vrb-25"));
break;
/* process keyboard mapping changes */
case MappingNotify:
XRefreshKeyboardMapping(&myevent);
}
}
}
2.11 Weitere C-Programme
243
¨ das X Window System mit Funktionen der XlibQuelle 2.99 : C-Programm fur
Bibliothek
Die Xlib-Biliothek stellt die unterste Stufe der X11-Bibliotheken dar. Nach
M¨oglichkeit verwendet man h¨ohere Bibliotheken, die ihrerseits auf der Xlib
¨
aufsetzen. Man erspart sich damit viel Muhe.
2.11.11
cgi-Programme
¨
Die Abkurzung
cgi bedeutet Common Gateway Interface. Das ist ein Protokoll zum Gedankenaustausch zwischen HTML-Forms und Programmen. Die
Programme k¨onnen in jeder Sprache verfasst sein, die es erm¨oglicht, von
stdin zu lesen, nach stdout zu schreiben und außerdem Umgebungsvariable auszuwerten. Obwohl viele derartige Programme Perl-Skripte sind – siehe
Abschnitt ?? Forms und cgi-Scripts auf Seite ?? – ist das nicht zwingend, ein
C-Programm tut es genau so gut und ist schneller.
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0//EN">
<!-cgi test.html
Teil einer Imlpementation der CGI-Schnittstelle in C.
-->
<HTML>
<HEAD>
<TITLE>
Test
</TITLE>
</HEAD>
<BODY>
<FORM action="/cgi-bin/cgi test.cgi" method="get">
<!-- Method "get" is deprecated -->
<H2>
GET-Formular
</H2>
<INPUT type="hidden" name="foobar" value="42"><INPUT type=
"text" name="eingabe"><INPUT type="submit">
</FORM>
<HR>
<FORM action="/cgi-bin/cgi test.cgi" method="post">
<H2>
POST-Formular
</H2>
<INPUT type="hidden" name="foobar" value="42"><INPUT type=
"text" name="eingabe"><INPUT type="submit">
</FORM>
</BODY>
</HTML>
Quelle 2.100 : Webseite cgi test.html mit FORM-Elementen zum Ausprobieren der cgi-Schnittstelle
244
2 Programmieren in C/C++
Ein Benutzer ruft mittels seines Brausers eine Webseite auf, die ein FORM¨ Was das im einzelnen ist, tut hier nichts zur Sache und kann
Element enthalt.
in HTML-Anleitungen nachgelesen werden. Unter den Attributen des FORM¨
Elements finden sich action und method. Die action gibt den vollstandigen
39
¨
oder relativen URL des Programms an, das auf dem Webserver ausgefuhrt
werden soll. Hinter method findet sich entweder post oder get, wobei letzteres veraltet (deprecated in HTML 4.0) ist.
Der Benutzer gibt in die Webseite verschiedene Werte ein, die durch die
¨
¨
INPUT-Elemente naher
spezifiert sind, und druckt
dann ein Kn¨opfchen, das
¨
submit oder ahnlich
heißt. Darauf hin verlangt der Brauser vom WWW den
¨
unter action genannten URL unter Beifugung
der eingegebenen Werte. Der
Webserver stellt fest, dass eines seiner cgi-Skripte verlangt wird, und ruft
dieses auf.
/*
* cgi.h
* Teil einer Implementation der CGI-Schnittstelle in C.
*/
#define MAX QUERY LEN 4095
/* gegen Missbrauch */
struct list item {
struct list item *next;
char *key, *value;
};
struct array item {
char *key, *value;
};
/* eigene Funktionen */
void unescape str(char *);
char *get query();
struct list item *parse list(char *);
struct array item *parse array(char *);
Quelle 2.101 : Include-File cgi.h zum Programm cgi test.c
/*
* cgi test.c, Hauptprogramm
* Teil einer Implementation der CGI-Schnittstelle in C.
* normalerweise entweder linked list oder array verwenden
*/
#include <stdio.h>
#include <string.h>
#include "cgi.h"
39 Etwas
v¨ollig anderes sind aktive Inhalte (Anweisungen in Javascript, Java¨
Applets) von Webseiten, die auf dem Computer des Benutzers ausgefuhrt
werden.
2.11 Weitere C-Programme
245
int main() {
char *list query, *array query;
struct list item *param list;
struct array item *param array;
/* hiermit beginnt die Ausgabe */
printf("Content-Type: text/plain\015\012\015\012");
/* query string ermitteln und duplizieren */
list query = get query();
if (list query == NULL) {
printf("Keine Parameter!\n");
return 0;
}
array query = strdup(list query);
/* linked list erzeugen */
param list = parse list(list query);
printf("Parameter per Linked List:\n");
while (param list != NULL) {
printf("%s = %s\n", param list->key, param list->value);
param list = param list->next;
}
/* array erzeugen */
param array = parse array(array query);
printf("\nParameter per Array:\n");
while (param array->key != NULL) {
printf("%s = %s\n", param array->key, param array->value);
param array++;
}
return 0;
}
Quelle 2.102 : C-Programm cgi test.c zum Ausprobieren der cgi-Schnittstelle
/*
* cgi.c, Funktionen
* Teil einer Implementation der CGI-Schnittstelle in C.
*/
#include
#include
#include
#include
#include
<stdio.h>
<stdlib.h>
<string.h>
<ctype.h>
"cgi.h"
/*
* Wandelt alle %xx-Tripel in einzelne Zeichen um und ’+’ in ’ ’,
* wobei der uebergebene String veraendert wird!
*/
void unescape str(char *s) {
246
2 Programmieren in C/C++
size t i;
for(i = strlen(s); i > 2; i--, s++) {
if (*s == ’+’)
*s = ’ ’;
else if (*s == ’%’ && isxdigit(s[1]) && isxdigit(s[2])) {
*s = (isdigit(s[1]) ? s[1] - ’0’ : tolower(s[1]) - ’a’ + 10)
(isdigit(s[2]) ? s[2] - ’0’ : tolower(s[2]) - ’a’ + 10);
memmove(s + 1, s + 3, i -= 2);
}
}
}
/*
* Gibt den query string zurueck, wenn keine Fehler auftreten,
* ansonsten NULL. Unterscheidet dabei zwischen GET und POST.
* Darf bei POST nur einmal aufgerufen werden!
*/
char *get query() {
char *p, *q;
size t len;
/* REQUEST METHOD suchen */
p = getenv("REQUEST METHOD");
if (p == NULL) return NULL;
/* keine REQUEST METHOD */
/* 1. Fall: GET */
if (strcmp(p, "GET") == 0) {
p = getenv("QUERY STRING");
if (p == NULL) return NULL; /* kein QUERY STRING bei GET */
len = strlen(p);
if (len < 1 || len > MAX QUERY LEN) return NULL;
q = malloc(len + 1);
if (q == NULL) return NULL;
memmove(q, p, len + 1);
/* spart Linken von strcpy */
return q;
/* 2. Fall: POST */
} else if (strcmp(p, "POST") == 0) {
p = getenv("CONTENT LENGTH");
if (p == NULL) return NULL; /* keine CONTENT LENGTH */
len = strtoul(p, NULL, 0);
if (len < 1 || len > MAX QUERY LEN) return NULL;
q = malloc(len + 1);
if (q == NULL) return NULL;
if (fread(q, 1, len, stdin) < len)
return NULL;
/* Laenge von stdin < CONTENT LENGTH */
q[len] = ’\0’;
return q;
/* 3. Fall: weder noch - kann von diesem Programm
nicht behandelt werden */
} else return NULL;
}
2.11 Weitere C-Programme
247
/*
* Gibt eine linked list des geparsten query string zurueck,
* wenn keine Fehler auftreten, ansonsten NULL. Veraendert
* den uebergebenen String!
*/
struct list item *parse list(char *query) {
struct list item first = { NULL }, *last = &first;
while (*query != ’\0’) {
/* neues Listenelement allozieren */
last->next = malloc(sizeof *last);
if(last == NULL) return first.next;
last = last->next;
last->next = NULL;
/* einen Parameter extrahieren */
last->key = query;
do {
query++;
} while (*query != ’\0’ && (*query != ’&’ || *(query + 1) ==
if (*query != ’\0’) *query++ = ’\0’;
/* in key und value splitten */
last->value = last->key;
do {
last->value++;
} while (*last->value != ’\0’ && *last->value != ’=’);
if (*last->value != ’\0’) *(last->value++) = ’\0’;
/* "%xx"-Tripel umwandeln */
unescape str(last->key);
unescape str(last->value);
}
return first.next;
}
/*
* Gibt ein Array von Strukturen zurueck mit den geparsten
* Parametern, falls keine Fehler auftreten, ansonsten NULL.
* Geht dabei zweimal ueber den query string, was aber nicht
* weiter schlimm ist. Das Array wird durch eine Struktur
* abgeschlossen, bei der beide Werte (key und value) NULL sind.
* Veraendert den uebergebenen String!
*/
struct array item *parse array(char *query) {
int count;
char *temp;
struct array item *first, *last;
/* Anzahl Parameter bestimmen */
for (count = 0, temp = query; *temp != ’\0’; count++) {
do {
temp++;
248
2 Programmieren in C/C++
} while (*temp != ’\0’ && (*temp != ’&’ || *(temp + 1) == ’\0’));
}
if (count == 0) return NULL;
/* Array allozieren */
last = first = malloc(sizeof *first * (count + 1));
if (last == NULL) return NULL;
first[count].key = first[count].value = NULL;
while (*query != ’\0’) {
/* einen Parameter extrahieren */
last->key = query;
do {
query++;
} while (*query != ’\0’ && (*query != ’&’ || *(query + 1) == ’\0’
if (*query != ’\0’) *query++ = ’\0’;
/* in key und value splitten */
last->value = last->key;
do {
last->value++;
} while (*last->value != ’\0’ && *last->value != ’=’);
if (*last->value != ’\0’) *(last->value++) = ’\0’;
/* "%xx"-Tripel umwandeln */
unescape str(last->key);
unescape str(last->value);
last++;
}
return first;
}
Quelle 2.103 : C-Funktionen zum Programm cgi test.c
¨
Nun wird es spannend. Wie erfahrt
das cgi-Skript, hier ein C-Programm,
von den vom Benutzer eingegebenen Werten? Bei der Methode get stehen
die Werte als ein langer String in der Umgebungs-Variablen QUERY STRING,
bei der Methode post wird der String von stdin gelesen. Der Rest besteht
im Aufdr¨oseln (parsen) des Strings, der Verarbeitung der einzelnen Werte
und der Ausgabe eines HTML-konformen Dokumentes nach stdout. Dieses
¨
Dokument schickt der Webserver an den anfragenden Brauser zuruck.
Das
¨
¨
wars. Fehler macht man vor allem bei den Kleinigkeiten wie Gansef
ußchen
¨
oder Semikolons. Ein großer Teil des Programms besteht wie ublich
im Abfan¨
gen unzulassiger
Eingaben. Bedenken Sie, dass wildfremde Benutzer dieses
Programm auf Ihrem WWW-Server starten. Lesen Sie das Programmbeispiel
und weitere aus dem Netz. Dort finden sich auch Funktions- und Klassenbi¨ cgi-Programme in C/C++.
bliotheken fur
2.12 Obfuscated C
2.12
249
Obfuscated C
¨
Wie bereits in einer Fußnote auf Seite 29 bemerkt, findet jahrlich
ein Wettbewerb um das undurchsichtigste C-Programm statt (to obfuscate = vernebeln, verwirren). Die Siegerprogramme haben außer Nebel auch noch einen
Witz aufzuweisen. Als Beispiel geben wir ein Programm von J ACK A PPLIN,
Hewlett-Packard, Fort Collins/USA wieder, das erfolgreich am Contest 1986
teilgenommen hat. Es ist das Hello-World-Programm in einer Fassung, die
¨
als C-Programm, FORTRAN-77-Programm und als Bourne-Shellscript gultig
40
ist
cat =13 /*/ >/dev/null 2>&1; echo "Hello, world!"; exit
*
* This program works under cc, f77, and /bin/sh.
*
*/; main() {
write(
cat-˜-cat
/*,’(
*/
,"Hello, world!"
,
cat); putchar(˜-˜-˜-cat); } /*
,)’)
end
*/
Auch die Leerzeichen sind wichtig. Entfernt man die Kommentare, bleibt als
¨
C-Programm ubrig:
cat =13;
main() {
write(cat-˜-cat, "Hello, world!", cat);
putchar(˜-˜-˜-cat); }
Zuerst wird eine globale Variable cat – per Default vom Typ int – auf 13
gesetzt. Dann wird der Systemaufruf write(1, "Hello, world!", 13)
¨
ausgefuhrt,
der 13 Zeichen des Strings Hello, world! nach stdout (Filedeskriptor 1) schreibt, anschließend die Standardfunktion putchar(10). Der
¨
Gebrauch des unaren
Minuszeichens samt der bitweisen Negation ist ungewohnt. Man muß sich die Umrechnungen in Bits aufschreiben (negative Zahlen werden durch ihr Zweierkomplement dargestellt). Bei write():
13
-13
40 Unter
gibt 0000 0000
gibt 1111 1111
0000 0000
1111 1111
0000 0000
1111 1111
0000 1101
1111 0011
¨
www.ee.ryerson.ca:8080/˜elf/hack/multilang.htm liegt ein ahnliches Programm, das als C-Programm, Perl-Skript, Tcl-Skript und Shell-Skript
¨
gultig
ist.
250
2 Programmieren in C/C++
˜(-13)
gibt 0000 0000
13 - (˜(-13))
gibt 0000 0000
0000 0000
0000 0000
0000 1100
0000 0000
0000 0000
0000 0001
was dezimal 1 ist. Bei putchar() sieht die Geschichte so aus:
13
gibt 0000
-13
gibt 1111
˜(-13)
gibt 0000
-(˜(-13))
gibt 1111
˜(-(˜(-13)))
gibt 0000
-(˜(-(˜(-13))))
gibt 1111
˜(-(˜(-(˜(-13)))))
gibt 0000
0000
1111
0000
1111
0000
1111
0000
1111
0000
1111
0000
1111
0000
1111
0000
1111
0000
1111
0000
1111
0000
1111
0000
1111
1101
0011
1100
0100
0000
0000 0000
0000 0000
0000 1011
1111
1111 1111
1111 1111
1111 0101
0000
0000 0000
0000 0000
0000 1010
was dezimal 10 = ASCII-Zeichen Linefeed ist.
¨ FORTRAN 77 bleiben folgende Zeilen ubrig:
¨
Fur
write(*, ’("Hello, world!")’)
end
Zeilen, die an erster Stelle ein c oder ein * enthalten, gelten als Kommentar.
Zeilen, die an sechster Stelle irgendein Zeichen enthalten, werden als Fortsetzungen aufgefaßt. Anweisungen beginnen in Spalte 7 (die Sitte stammt aus
der Lochkartenzeit).
¨ als einzige wirksame Kommandos:
Das Shellscript enthalt
echo "Hello, world!"; exit
Was davor steht, geht nach /dev/null. Mit exit wird das Script verlassen.
Mehr solcher Scherze findet man im Netz oder in dem Buch von D ON L IBES.
¨
Eine ahnliche
intellektuelle Herausforderung stellen die QuineProgramme dar. Das sind Programme, die ihren eigenen Quellcode ausgeben.
¨
Naheres
unter:
http://www.nyx.net/˜gthompso/quine.htm
2.13
Portieren von Programmen
2.13.1
Regeln
¨
Unter dem Ubertragen
oder Portieren von Programmen versteht man das
Anpassen an ein anderes System unter Beibehaltung der Programmierspra¨
che oder das Ubersetzen
in eine andere Programmiersprache auf demselben
System, schlimmstenfalls beides zugleich.
2.13 Portieren von Programmen
251
¨ sich immer portieren, indem man bis zur AufgabenEin Programm laßt
¨
stellung zuruckgeht.
Das ist mit dem maximalen Aufwand verbunden; es
¨
¨
¨
lauft
auf Neuschreiben hinaus. Unter gunstigen
Umstanden
kann ein Pro¨ Zeile ubertragen
¨
gramm Zeile fur
werden, ohne die Aufgabe und die Algorithmen zu kennen. In diesem Fall reicht die Intelligenz eines Computers zum
41
¨ diese Tatigkeit
¨
Portieren; es gibt auch Programme fur
. Die wirklichen Auf¨
gaben liegen zwischen diesen beiden Grenzfallen.
¨
Schon beim ersten Schreiben eines Programmes erleichtert man ein kunftiges Portieren, wenn man einige Regeln beherzigt. Man vermeide:
¨
¨
• Annahmen uber
Eigenheiten des File-Systems (z. B. Lange
der Namen),
¨
¨
• Annahmen uber
die Reihenfolge der Auswertung von Ausdrucken,
Funktionsargumenten oder Nebeneffekten (z. B. bei printf(3)),
¨
• Annahmen uber
die Anordnung der Daten im Arbeitsspeicher,
¨
• Annahmen uber
die Anzahl der signifikanten Zeichen von Namen,
¨
• Annahmen uber
die automatische Initialisierung von Variablen,
• den Gebrauch von stillschweigenden (automatischen) Typumwandlungen, zum Beispiel von long nach int unter der Annahme, daß die beiden Typen gleich lang sind,
• das Mischen von vorzeichenlosen und vorzeichenbehafteten Werten,
• die Dereferenzierung von Nullpointern (Null ist keine Adresse),
¨
• Annahmen uber
die Darstellung von Pointern (Pointer sind keine Ganzzahlen), Zuweisungen von Pointerwerten an int- oder long-Variable,
• die Annahme, einen Pointer dereferenzieren zu k¨onnen, der nicht richtig
auf eine Datengrenze ausgerichtet ist (Alignment),
• die Annahme, daß Groß- und Kleinbuchstaben unterschieden werden,
• die Annahme, daß der Typ char vorzeichenbehaftet oder vorzeichenlos
ist (EOF = -1?),
• Bitoperationen mit vorzeichenbehafteten Ganzzahlen,
• die Verwendung von Bitfeldern mit anderen Typen als unsigned,
¨
• Annahmen uber
das Vorzeichen des Divisionsrestes bei der ganzzahligen Division,
• die Annahme, daß eine extern-Deklaration in einem Block auch außerhalb des Blockes gilt.
Diese und noch einige Dinge werden von unterschiedlichen Betriebssystemen
und Compilern unterschiedlich gehandhabt, und man weiß nie, was einem
begegnet. Dagegen soll man:
¨
• den Syntax-Prufer
lint(1) befragen,
¨
GNU-Projekt finden sich ein Program f2c (lies: f to c) zum Ubertragen
von
FORTRAN nach C und ein Programm p2c zum Portieren von PASCAL nach C.
41 Im
252
2 Programmieren in C/C++
¨
¨
• Praprozessor-Anweisungen
und typedef benutzen, um Abhangigkeiten
einzugrenzen,
• alle Variablen, Pointer und Funktionen ordentlich deklarieren,
• Funktions-Prototypen verwenden,
¨
• symbolische Konstanten (#define) anstelle von ratselhaften
Werten im
Programm verwenden,
¨
• richtig ausgerichtete Unions anstelle von trickreichen Uberlagerungen
von Typen verwenden,
• den sizeof()-Operator verwenden, wenn man die Gr¨oße von Typen
oder Variablen braucht,
• daran denken, daß die Gr¨oße von Datentypen je nach Architektur unterschiedlich ist,
• umfangreiche Deklarationen in Header-Files packen,
¨ andere Funktionen
• nur die C-Standard-Funktionen verwenden oder fur
die Herkunft oder den Quellcode angeben, mindestens aber die Funktio¨ und die Syntax,
nalitat
• bei printf(3) oder scanf(3) die richtigen Platzhalter verwenden
¨ long),
(%ld fur
¨
• alle unvermeidlichen Systemabhangigkeiten
auf wenige Stellen konzentrieren und deutlich kommentieren.
Im folgenden wollen wir einige Beispiele betrachten, die nicht allzu lang und
daher auch nur einfach sein k¨onnen.
2.13.2
¨
Ubertragen
von ALGOL nach C
Wir haben hier ein ALGOL-Programm von R ICHARD WAGNER aus dem Buch
¨
von K ARL N ICKEL ALGOL-Praktikum (1964) ausgewahlt,
weil es mit Sicher¨
heit nicht im Hinblick auf eine Ubertragung nach C geschrieben worden ist.
Es geht um die Bestimmung des gr¨oßten gemeinsamen Teilers mit dem Algorithmus von E UKLID. Daß wir die Aufgabe und den Algorithmus kennen,
¨
erleichtert die Arbeit, daß außer einigen Graubarten
niemand mehr ALGOL
kennt, erschwert sie.
’BEGIN’ ’COMMENT’ BEISPIEL 12 ;
’INTEGER’ A, B, X, Y, R ;
L1:
READ(A,B) ;
’IF’ A ’NOT LESS’ B
’THEN’’BEGIN’ X:= A ; Y:= B ’END’
’ELSE’’BEGIN’ X:= B ; Y:= A ’END’ ;
L2:
R:= X - Y*ENTIER(X/Y) ;
’IF’ R ’NOT EQUAL’ 0 ’THEN’’BEGIN’ X:= Y ; Y:= R ;
’GO TO’ L2 ’END’ ;
2.13 Portieren von Programmen
253
PRINT(A,B,Y) ;
’GO TO’ L1
’END’
Quelle 2.104 : ALGOL-Programm ggT nach Euklid
¨
Die Einlese- und Ubersetzungszeit
auf einer Z22 betrug 50 s, die Rechenund Druckzeit 39 s. Damals hatten schnelle Kopfrechner noch eine Chance.
Eine Analyse des Quelltextes ergibt:
• Das Programm besteht aus einem File mit dem Hauptprogramm (war
kaum anders m¨oglich),
¨
• Schlusselw¨
orter stehen in Hochkommas,
• logische Bl¨ocke werden durch begin und end begrenzt,
• es kommen nur ganzzahlige Variable vor,
• es wird Ganzzahl-Arithmetik verwendet,
• an Funktionen treten read() und print() auf,
• an Kontrollanweisungen werden if - then - else und goto verwendet.
¨
Das sieht hoffnungsvoll aus. Die Ubertragung
nach C:
/* Groesster gemeinsamer Teiler nach Euklid
Uebertragung eines ALGOL-Programms aus K. Nickel nach C
zu compilieren mit cc -o ggt ggt.c
*/
#include <stdio.h>
int main()
{
int a, b, x, y, r;
while(1) {
/* Eingabe */
puts("ggT von a und b nach Euklid");
puts("Beenden mit Eingabe 0");
printf("Bitte a und b eingeben: ");
scanf("%d %d", &a, &b);
/* Beenden, falls a oder b gleich 0 */
if ((a == 0) || (b == 0)) exit(0);
/* x muss den groesseren Wert aus a und b enthalten */
if (a >= b) { x = a; y = b; }
else
{ x = b; y = a; }
254
2 Programmieren in C/C++
/* Euklid */
while (r = x % y) {
x = y;
y = r;
}
/* Ausgabe */
printf("%d und %d haben den ggT %d\n", a, b, y);
}
}
Quelle 2.105 : C-Programm ggT nach Euklid
¨
Der auch nach UNIX-Maßstaben
karge Dialog des ALGOL-Programms
wurde etwas angereichert, die goto-Schleifen wurden durch while-Schleifen
ersetzt und der ALGOL-Behelf zur Berechnung des Divisionsrestes (entier)
durch die in C vorhandene Modulo-Operation.
Bei einem Vergleich mit dem Programm 2.55 C-Programm ggt nach Euklid, rekursiv auf Seite 143 sieht man, wie unterschiedlich selbst ein so einfacher Algorithmus programmiert werden kann. Dazu kommen andere Algorithmen zur L¨osung derselben Aufgabe, beispielsweise das Ermitteln aller
Teiler der beiden Zahlen und das Herausfischen des ggT.
2.13.3
¨
Ubertragen
von FORTRAN nach C
Gegeben sei ein einfaches Programm zur L¨osung quadratischer Gleichungen
in FORTRAN77:
c
c
c
c
c
-----------------------------------------------Loesung der quadratischen Gleichung
a*x*x + b*x + c = 0
reelle Koeffizienten, Loesungen auch komplex
-----------------------------------------------program quad
c
real
real
complex
data
a,b,c,d,h,r,s,x1,x2
eps
x1c,x2c
eps/1.0e-30/
c
c
c
c
write(*,*) ’Loesung von a*x*x + b*x + c = 0’
write(*,*) ’Bitte a, b, und c eingeben’
read (*,*) a,b,c
-----------------------------------------------1. Fall : a nahe Null, lineare Gleichung
-----------------------------------------------if (abs(a) .lt. eps) then
write(*,*) ’WARNUNG : a nahe Null,
1
Null angenommen’
if (abs(b) .lt. eps) then
2.13 Portieren von Programmen
write(*,*) ’WARNUNG :
1
255
auch b nahe Null,
Unsinn’
goto 100
else
write(*,*) ’Loesung :
goto 100
endif
c
c
c
c
c
c
c
c
c
c
c
c
100
x = ’,-c/b
else
-----------------------------------------------Berechnung der Diskriminanten d
-----------------------------------------------d = b*b - 4.0*a*c
h = a+a
-----------------------------------------------2. Fall : eine oder zwei reelle Loesungen
-----------------------------------------------if ( d .ge. 0.0 ) then
s = sqrt(d)
x1 = (-b + s) / h
x2 = (-b - s) / h
write(*,*) ’Eine oder zwei reelle
1
Loesungen’
write(*,*) ’x1 = ’, x1
write(*,*) ’x2 = ’, x2
goto 100
-----------------------------------------------3. Fall : konjugiert komplexe Loesungen
-----------------------------------------------else
r = -b / h
s = sqrt(-d) / h
x1c = cmplx(r,s)
x2c = cmplx(r,-s )
write(*,*) ’Konjugiert komplexe
1
Loesungen’
write(*,*) ’x1 = ’, x1c
write(*,*) ’x2 = ’, x2c
goto 100
endif
endif
-----------------------------------------------Programmende
-----------------------------------------------stop
end
Quelle 2.106 : FORTRAN-Programm Quadratische Gleichung mit reellen Koeffizienten
Eine Analyse des Quelltextes ergibt:
• Das Programm besteht aus einem File mit einem Hauptprogramm,
• es kommen reelle und komplexe Variable vor,
256
2 Programmieren in C/C++
• es wird Gleitkomma-Arithmetik verwendet, aber keine Komplex¨
Arithmetik (was die Ubertragung
nach C erleichtert),
• an Funktionen treten abs(), sqrt() und cmplx() auf,
• an Kontrollanweisungen werden if - then - else - endif und
goto verwendet.
Wir werden etwas Arbeit mit den komplexen Operanden haben. Die Sprunganweisung goto gibt es zwar in C, aber wir bleiben standhaft und vermeiden
¨
sie. Alles ubrige
sieht einfach aus.
¨ den komplexen Datentyp bietet sich ein Array of float
Als Ersatz fur
¨ auch m¨oglich. Falls komplexe Arithmeoder double an. Eine Struktur ware
¨
¨
tik vorkame,
mußten
wir uns die Operationen selbst schaffen. Hier werden
aber nur die komplexen Zahlen ausgegeben, was harmlos ist. Das goto wird
hier nur gebraucht, um nach der Ausgabe der L¨osung ans Programmende zu
¨ eine Funktion done() aufrufen. Das nach C
springen. Wir werden in C dafur
¨
ubertragene
Programm:
/* Loesung der quadratischen Gleichung a*x*x + b*x + c = 0
reelle Koeffizienten, Loesungen auch komplex
zu compilieren mit cc quad.c -lm */
#define EPS 1.0e-30
/* Typ double! */
#include <stdio.h>
#include <math.h>
/* wg. puts, printf, scanf */
/* wg. fabs, sqrt */
int done();
int main()
{
double a, b, c, d, h, s, x1, x2;
double z[2];
puts("Loesung von a*x*x + b*x + c = 0");
puts("Bitte a, b und c eingeben");
scanf("%lf %lf %lf", &a, &b, &c);
/* 1. Fall: a nahe Null, lineare Gleichung */
if (fabs(a) < EPS) {
puts("WARNUNG: a nahe Null, als Null angenommen");
if (fabs(b) < EPS) {
puts("WARNUNG: auch b nahe Null, Unsinn");
done();
}
else {
printf("Loesung: %lf\n", -c/b);
done();
}
}
else {
2.13 Portieren von Programmen
257
/* Berechnung der Diskriminanten d */
d = b * b - 4.0 * a * c;
h = a + a;
/* 2. Fall: eine oder zwei reelle Loesungen */
if (d >= 0.0) {
s = sqrt(d);
x1 = (-b + s) / h;
x2 = (-b - s) / h;
puts("Eine oder zwei reelle Loesungen");
printf("x1 = %lf\n", x1);
printf("x2 = %lf\n", x2);
done();
}
else {
/* 3. Fall: konjugiert komplexe Loesungen */
z[0] = -b / h;
z[1] = sqrt(-d) / h;
puts("Konjugiert komplexe Loesungen");
printf("x1 = (%lf
%lf)\n", z[0], z[1]);
printf("x2 = (%lf %lf)\n", z[0], -z[1]);
done();
}
}
}
/* Funktion done() zur Beendigung des Programms */
int done()
{
return(0);
}
Quelle 2.107 : C-Programm Quadratische Gleichung mit reellen Koeffizienten
¨
und komplexen L¨osungen, aus FORTRAN ubertragen
¨
Bei der Ubertragung
haben wir keinen Gebrauch von unseren Kenntnis¨
sen uber
quadratische Gleichungen gemacht, sondern ziemlich schematisch
gearbeitet. Mathematische Kenntnisse sind trotzdem hilfreich, auch sonst im
Leben.
Wir erh¨ohen den Reiz der Aufgabe, indem wir auch komplexe Koeffizienten zulassen: Schließlich wollen wir das Programm als Funktion (Subroutine)
¨
schreiben, die von einem ubergeordneten
Programm aufgerufen wird:
258
2.14
2 Programmieren in C/C++
¨
Exkurs uber
Algorithmen
Der Begriff Algorithmus – benannt nach einem usbekischen Mathematiker
des 9. Jahrhunderts – kommt im vorliegenden Text selten vor, taucht aber
¨
¨
in fast allen Programmierbuchern
auf. Ein betrachtlicher
Teil der Informa¨
tik befaßt sich damit. Locker ausgedruckt
ist ein Algorithmus eine Vorschrift,
¨
die mit endlich vielen Schritten zur L¨osung eines gegebenen Problems fuhrt.
Ein Programm ist die Umsetzung eines Algorithmus in eine Programmiersprache. Algorithmen werden mit Worten, Formeln oder Grafiken dargestellt.
Ein Existenzbeweis ist in der Mathematik schon ein Erfolg, in der Technik
brauchen wir einen L¨osungsweg, einen Algorithmus.
¨
Das klingt alltaglich.
Das Rezept zum Backen einer Prinzregententor42
¨
te oder die Beschreibung des Aufstiegs auf die Hochwilde in den Otztaler
43
Alpen sind demnach Algorithmen. Einige Anforderungen an Algorithmen
sind:
¨
• Korrektheit. Das klingt selbstverstandlich,
ist aber meist schwierig zu
beweisen. Und Korrektheit in einem Einzelfall besagt gar nichts. Umgekehrt beweist bereits ein Fehler die Inkorrektheit.
• Eindeutigkeit. Das stellt Anforderungen an die Darstellungsweise, die
Sprache; denken Sie an eine technische Zeichnung oder an Klavierno¨
¨
ten. Verschiedene Ausfuhrungswege
sind zulassig,
bei gleichen Eingaben muß das gleiche Ergebnis herauskommen.
• Endlichkeit. Die Beschreibung des Algorithmus muß eine endliche
¨
Lange
haben, sonst k¨onnte man ihn endlichen Wesen nicht mitteilen.
¨
Er muß ferner eine endliche Ausfuhrungszeit
haben, man m¨ochte seine
¨
¨
Fruchte
ja noch zu Lebzeiten ernten. Er darf zur Ausfuhrung
nur eine
endliche Menge von Betriebsmitteln belegen.
• Allgemeinheit. 3×4 = 12 ist kein Algorithmus, wohl aber die Vorschrift,
¨
¨
wie man die Multiplikation auf die Addition zuruckf
uhrt.
Man kann die Anforderungen herabschrauben und kommt dabei zu reizvollen
¨ den Anfang gilt obiges. Eine funfte,
¨
Fragestellungen, aber fur
technisch wie
¨
theoretisch bedeutsame Forderung ist die nach einem guten, zweckmaßigen
Algorithmus oder gar die nach dem besten. Denken Sie an die vielen Sortier¨ alle Falle).
¨
verfahren (keines ist das beste fur
¨
Es gibt – sogar ziemlich leicht verstandliche
– Aufgaben, die nicht mittels
¨
eines Algorithmus zu l¨osen sind. Falls Sie Bedarf an solchen Nussen
haben,
suchen Sie unter dem Stichwort Entscheidbarkeit in Werken zur Theoretischen Informatik.
42 Dr.
¨
Oetker Backen macht Freude, Ceres-Verlag, Bielefeld. Die Ausfuhrung
dieses
¨ sich teilweise parallelisieren.
Algorithmus laßt
43 H. K LIER , Alpenvereinsfuhrer
¨
¨
Otztaler
Alpen, Bergverlag Rudolf Rother,
¨
Munchen.
Der Algorithmus muß sequentiell abgeschwitzt werden.
... aber die Daten fehlen, um den ganzen
¨
Nonsens richtig zu uberblicken
–
¨
Benn, Drei alte Manner
A
Zahlensysteme
Außer dem Dezimalsystem sind das Dual-, das Oktal- und das Hexade¨
¨ codierte Dezimalsyzimalsystem gebrauchlich.
Ferner spielt das Binar
stem (BCD) bei manchen Anwendungen eine Rolle. Bei diesem sind die ein¨ sich dual dargestellt. Die folgende Tabelle enthalt
¨
zelnen Dezimalstellen fur
die Werte von 0 bis dezimal 255. Bequemlichkeitshalber sind auch die zuge¨
ordneten ASCII-Zeichen aufgefuhrt.
dezimal
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
dual
0
1
10
11
100
101
110
111
1000
1001
1010
101
1100
1101
1110
1111
10000
10001
10010
10011
10100
10101
10110
10111
11000
11001
11010
11011
11100
oktal
0
1
2
3
4
5
6
7
10
11
12
13
14
15
16
17
20
21
22
23
24
25
26
27
30
31
32
33
34
hex
0
1
2
3
4
5
6
7
8
9
a
b
c
d
e
f
10
11
12
13
14
15
16
17
18
19
1a
1b
1c
259
BCD
0
1
10
11
100
101
110
111
1000
1001
1.0
1.1
1.10
1.11
1.100
1.101
1.110
1.111
1.1000
1.1001
10.0
10.1
10.10
10.11
10.100
10.101
10.110
10.111
10.1000
ASCII
nul
soh
stx
etx
eot
enq
ack
bel
bs
ht
lf
vt
ff
cr
so
si
dle
dc1
dc2
dc3
dc4
nak
syn
etb
can
em
sub
esc
fs
260
A Zahlensysteme
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
11101
11110
11111
100000
100001
100010
100011
100100
100101
100110
100111
101000
101001
101010
101011
101100
101101
101110
101111
110000
110001
110010
110011
110100
110101
110110
110111
111000
111001
111010
111011
111100
111101
111110
111111
1000000
1000001
1000010
1000011
1000100
1000101
1000110
1000111
1001000
1001001
1001010
35
36
37
40
41
42
43
44
45
46
47
50
51
52
53
54
55
56
57
60
61
62
63
64
65
66
67
70
71
72
73
74
75
76
77
100
101
102
103
104
105
106
107
110
111
112
1d
1e
1f
20
21
22
23
24
25
26
27
28
29
2a
2b
2c
2d
2e
2f
30
31
32
33
34
35
36
37
38
39
3a
3b
3c
3d
3e
3f
40
41
42
43
44
45
46
47
48
49
4a
10.1001
11.0
11.1
11.10
11.11
11.100
11.101
11.110
11.111
11.1000
11.1001
100.0
100.1
100.10
100.11
100.100
100.101
100.110
100.111
100.1000
100.1001
101.0
101.1
101.10
101.11
101.100
101.101
101.110
101.111
101.1000
101.1001
110.0
110.1
110.10
110.11
110.100
110.101
110.110
110.111
110.1000
110.1001
111.0
111.1
111.10
111.11
111.100
gs
rs
us
space
!
”
#
$
%
&
’
(
)
*
+
,
.
/
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
@
A
B
C
D
E
F
G
H
I
J
261
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
1001011
1001100
1001101
1001110
1001111
1010000
1010001
1010010
1010011
1010100
1010101
1010110
1010111
1011000
1011001
1011010
1011011
1011100
1011101
1011110
1011111
1100000
1100001
1100010
1100011
1100100
1100101
1100110
1100111
1101000
1101001
1101010
1101011
1101100
1101101
1101110
1101111
1110000
1110001
1110010
1110011
1110100
1110101
1110110
1110111
1111000
113
114
115
116
117
120
121
122
123
124
125
126
127
130
131
132
133
134
135
136
137
140
141
142
143
144
145
146
147
150
151
152
153
154
155
156
157
160
161
162
163
164
165
166
167
170
4b
4c
4d
4e
4f
50
51
52
53
54
55
56
57
58
59
5a
5b
5c
5d
5e
5f
60
61
62
63
64
65
66
67
68
69
6a
6b
6c
6d
6e
6f
70
71
72
73
74
75
76
77
78
111.101
111.110
111.111
111.1000
111.1001
1000.0
1000.1
1000.10
1000.11
1000.100
1000.101
1000.110
1000.111
1000.1000
1000.1001
1001.0
1001.1
1001.10
1001.11
1001.100
1001.101
1001.110
1001.111
1001.1000
1001.1001
1.0.0
1.0.1
1.0.10
1.0.11
1.0.100
1.0.101
1.0.110
1.0.111
1.0.1000
1.0.1001
1.1.0
1.1.1
1.1.10
1.1.11
1.1.100
1.1.101
1.1.110
1.1.111
1.1.1000
1.1.1001
1.10.0
K
L
M
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
ˆ
‘
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
262
A Zahlensysteme
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
1111001
1111010
1111011
1111100
1111101
1111110
1111111
10000000
10000001
10000010
10000011
10000100
10000101
10000110
10000111
10001000
10001001
10001010
10001011
10001100
10001101
10001110
10001111
10010000
10010001
10010010
10010011
10010100
10010101
10010110
10010111
10011000
10011001
10011010
10011011
10011100
10011101
10011110
10011111
10100000
10100001
10100010
10100011
10100100
10100101
10100110
171
172
173
174
175
176
177
200
201
202
203
204
205
206
207
210
211
212
213
214
215
216
217
220
221
222
223
224
225
226
227
230
231
232
233
234
235
236
237
240
241
242
243
244
245
246
79
7a
7b
7c
7d
7e
7f
80
81
82
83
84
85
86
87
88
89
8a
8b
8c
8d
8e
8f
90
91
92
93
94
95
96
97
98
99
9a
9b
9c
9d
9e
9f
a0
a1
a2
a3
a4
a5
a6
1.10.1
1.10.10
1.10.11
1.10.100
1.10.101
1.10.110
1.10.111
1.10.1000
1.10.1001
1.11.0
1.11.1
1.11.10
1.11.11
1.11.100
1.11.101
1.11.110
1.11.111
1.11.1000
1.11.1001
1.100.0
1.100.1
1.100.10
1.100.11
1.100.100
1.100.101
1.100.110
1.100.111
1.100.1000
1.100.1001
1.101.0
1.101.1
1.101.10
1.101.11
1.101.100
1.101.101
1.101.110
1.101.111
1.101.1000
1.101.1001
1.110.0
1.110.1
1.110.10
1.110.11
1.110.100
1.110.101
1.110.110
y
z
{
|
}
˜
del
263
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
10100111
10101000
10101001
10101010
10101011
10101100
10101101
10101110
10101111
10110000
10110001
10110010
10110011
10110100
10110101
10110110
10110111
10111000
10111001
10111010
10111011
10111100
10111101
10111110
10111111
11000000
11000001
11000010
11000011
11000100
11000101
11000110
11000111
11001000
11001001
11001010
11001011
11001100
11001101
11001110
11001111
11010000
11010001
11010010
11010011
11010100
247
250
251
252
253
254
255
256
257
260
261
262
263
264
265
266
267
270
271
272
273
274
275
276
277
300
301
302
303
304
305
306
307
310
311
312
313
314
315
316
317
320
321
322
323
324
a7
a8
a9
aa
ab
ac
ad
ae
af
b0
b1
b2
b3
b4
b5
b6
b7
b8
b9
ba
bb
bc
bd
be
bf
c0
c1
c2
c3
c4
c5
c6
c7
c8
c9
ca
cb
cc
cd
ce
cf
d0
d1
d2
d3
d4
1.110.111
1.110.1000
1.110.1001
1.111.0
1.111.1
1.111.10
1.111.11
1.111.100
1.111.101
1.111.110
1.111.111
1.111.1000
1.111.1001
1.1000.0
1.1000.1
1.1000.10
1.1000.11
1.1000.100
1.1000.101
1.1000.110
1.1000.111
1.1000.1000
1.1000.1001
1.1001.0
1.1001.1
1.1001.10
1.1001.11
1.1001.100
1.1001.101
1.1001.110
1.1001.111
1.1001.1000
1.1001.1001
10.0.0
10.0.1
10.0.10
10.0.11
10.0.100
10.0.101
10.0.110
10.0.111
10.0.1000
10.0.1001
10.1.0
10.1.1
10.1.10
264
A Zahlensysteme
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
11010101
11010110
11010111
11011000
11011001
11011010
11011011
11011100
11011101
11011110
11011111
11100000
11100001
11100010
11100011
11100100
11100101
11100110
11100111
11101000
11101001
11101010
11101011
11101100
11101101
11101110
11101111
11110000
11110001
11110010
11110011
11110100
11110101
11110110
11110111
11111000
11111001
11111010
11111011
11111100
11111101
11111110
11111111
325
326
327
330
331
332
333
334
335
336
337
340
341
342
343
344
345
346
347
350
351
352
353
354
355
356
357
360
361
362
363
364
365
366
367
370
371
372
373
374
375
376
377
d5
d6
d7
d8
d9
da
db
dc
dd
de
df
e0
e1
e2
e3
e4
e5
e6
e7
e8
e9
ea
eb
ec
ed
ee
ef
f0
f1
f2
f3
f4
f5
f6
f7
f8
f9
fa
fb
fc
fd
fe
ff
10.1.11
10.1.100
10.1.101
10.1.110
10.1.111
10.1.1000
10.1.1001
10.10.0
10.10.1
10.10.10
10.10.11
10.10.100
10.10.101
10.10.110
10.10.111
10.10.1000
10.10.1001
10.11.0
10.11.1
10.11.10
10.11.11
10.11.100
10.11.101
10.11.110
10.11.111
10.11.1000
10.11.1001
10.100.0
10.100.1
10.100.10
10.100.11
10.100.100
10.100.101
10.100.110
10.100.111
10.100.1000
10.100.1001
10.101.0
10.101.1
10.101.10
10.101.11
10.101.100
10.101.101
B
¨
Zeichensatze
B.1
EBCDIC, ASCII, Roman8, IBM-PC
¨
¨
Die Zeichensatze
sind in den Ein- und Ausgabegeraten
(Terminal, Drucker)
¨ umsetzen.
gespeicherte Tabellen, die die Zeichen in Zahlen und zuruck
dezimal
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
oktal
0
1
2
3
4
5
6
7
10
11
12
13
14
15
16
17
20
21
22
23
24
25
26
27
30
31
32
33
34
35
36
37
40
41
42
43
EBCDIC
nul
soh
stx
etx
pf
ht
lc
del
rlf
smm
vt
ff
cr
so
si
dle
dc1
dc2
dc3
res
nl
bs
il
can
em
cc
ifs
igs
irs
ius
ds
sos
fs
ASCII-7
nul
soh
stx
etx
eot
enq
ack
bel
bs
ht
lf
vt
ff
cr
so
si
dle
dc1
dc2
dc3
dc4
nak
syn
etb
can
em
sub
esc
fs
gs
rs
us
space
!
”
#
265
Roman8
nul
soh
stx
etx
eot
enq
ack
bel
bs
ht
lf
vt
ff
cr
so
si
dle
dc1
dc2
dc3
dc4
nak
syn
etb
can
em
sub
esc
fs
gs
rs
us
space
!
”
#
IBM-PC
nul
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
bel
Grafik
ht
lf
home
ff
cr
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
cur right
cur left
cur up
cur down
space
!
”
#
¨
B Zeichensatze
266
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
44
45
46
47
50
51
52
53
54
55
56
57
60
61
62
63
64
65
66
67
70
71
72
73
74
75
76
77
100
101
102
103
104
105
106
107
110
111
112
113
114
115
116
117
120
121
122
123
124
byp
lf
etb
esc
sm
enq
ack
bel
syn
pn
rs
uc
eot
dc4
nak
sub
space
aˆ
a¨
a`
a´
a˜
a˚
c¸
n˜
[
.
<
(
+
!
&
e´
eˆ
e¨
e`
$
%
&
’
(
)
*
+
,
.
/
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
$
%
&
’
(
)
*
+
,
.
/
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
$
%
&
’
(
)
*
+
,
.
/
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
@
A
B
C
D
E
F
G
H
I
J
K
L
M
N
O
P
Q
R
S
T
B.1 EBCDIC, ASCII, Roman8, IBM-PC
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
125
126
127
130
131
132
133
134
135
136
137
140
141
142
143
144
145
146
147
150
151
152
153
154
155
156
157
160
161
162
163
164
165
166
167
170
171
172
173
174
175
176
177
200
201
202
203
204
´ı
ˆı
¨ı
`ı
ß
]
$
*
)
;
ˆ
–
/
ˆ
A
¨
A
`
A
´
A
˜
A
˚
A
C
¸
˜
N
|
,
%
>
?
ø
´
E
ˆ
E
¨
E
`
E
I´
Iˆ
I¨
I`
‘
:
#
@
’
=
”
Ø
a
b
c
d
267
U
V
W
X
Y
Z
[
\
]
ˆ
U
V
W
X
Y
Z
[
\
]
ˆ
U
V
W
X
Y
Z
[
\
]
ˆ
‘
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
{
|
}
˜
del
‘
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
{
|
}
˜
del
‘
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
{
|
}
˜
Grafik
C
¸
u¨
e´
aˆ
a¨
¨
B Zeichensatze
268
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
205
206
207
210
211
212
213
214
215
216
217
220
221
222
223
224
225
226
227
230
231
232
233
234
235
236
237
240
241
242
243
244
245
246
247
250
251
252
253
254
255
256
257
260
261
262
263
264
a`
a˚
c¸
eˆ
e¨
e`
ı
ˆı
`ı
¨
A
˚
A
´
E
e
f
g
h
i
y´
±
j
k
l
m
n
o
p
q
r
a
o¯
æ¯
–
Æ
µ
∼
s
t
u
v
w
x
y
z
¡
¿
´
Y
œ
Æ
oˆ
o¨
o`
uˆ
u`
y
¨
O
¨
U
`
A
ˆ
A
`
E
ˆ
E
¨
E
Iˆ
I¨
’
‘
ˆ
˜
`
U
ˆ
U
£
Yen
f
◦
C
¸
£
Yen
Pt
f
a´
´ı
o´
u´
n˜
˜
N
a
¯
o
¿¯
Grafik
Grafik
1/2
1/4
¡
Grafik
Grafik
Grafik
Grafik
Grafik
B.1 EBCDIC, ASCII, Roman8, IBM-PC
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
265
266
267
270
271
272
273
274
275
276
277
300
301
302
303
304
305
306
307
310
311
312
313
314
315
316
317
320
321
322
323
324
325
326
327
330
331
332
333
334
335
336
337
340
341
342
343
344
269
§
¶
c¸
˜
N
n˜
¡
¿
|
–
£
Yen
§
f
=
{
A
B
C
D
E
F
G
H
I
oˆ
o¨
o`
o´
o˜
}
J
K
L
M
N
O
P
Q
R
uˆ
u¨
u`
u´
y
\
S
T
U
aˆ
eˆ
oˆ
uˆ
a´
e´
o´
u´
a`
e`
o`
u`
a¨
e¨
o¨
u¨
˚
A
ˆı
Ø
Æ
a˚
´ı
ø
æ
¨
A
`ı
¨
O
¨
U
´
E
ı
ß
ˆ
O
´
A
˜
A
a˜
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
Grafik
α
β
Γ
π
Σ
¨
B Zeichensatze
270
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
B.2
345
346
347
350
351
352
353
354
355
356
357
360
361
362
363
364
365
366
367
370
371
372
373
374
375
376
377
I´
I`
´
O
`
O
˜
O
V
W
X
Y
Z
o˜
Sˇ
sˇ
´
U
ˆ
O
¨
O
`
O
´
O
˜
O
Y
y
thorn
Thorn
0
1
2
3
4
5
6
7
8
9
–
1/4
1/2
a
o¯
¯
t
±
ˆ
U
¨
U
`
U
´
U
σ
µ
τ
Φ
θ
Ω
δ
∞
Ø
∈
∩
≡
±
≥
≤
Haken
Haken
÷
≈
◦
•
·
√
n
2
t
(FF)
German-ASCII
¨ einen deutschen 7-Bit-ASCII-Zeichensatz
Falls das Ein- oder Ausgabegerat
¨ sind folgende Ersetzungen der amerikanischen Zeichen durch deutenthalt,
¨
sche Sonderzeichen ublich:
Nr.
US-Zeichen
91
92
93
123
124
125
126
linke eckige Klammer
Backslash
rechte eckige Klammer
linke geschweifte Klammer
senkrechter Strich
rechte geschweifte Klammer
Tilde
US-ASCII
[
\
]
{
|
}
˜
German ASCII
¨
A
¨
O
¨
U
a¨
o¨
u¨
ß
¨ von Hewlett-Packard verwenden
Achtung: Der IBM-PC und Ausgabegerate
¨
keinen 7-Bit-ASCII-Zeichensatz, sondern eigene 8-Bit-Zeichensatze,
die die
Sonderzeichen unter Nummern h¨oher 127 enthalten, siehe vorhergehende
Tabelle.
B.3 ASCII-Steuerzeichen
B.3
271
ASCII-Steuerzeichen
¨
¨
Die Steuerzeichen der Zeichensatze
dienen der Ubermittlung
von Befehlen
¨ und nicht der Ausgabe eines
und Informationen an das empfangende Gerat
¨ kennen in der Regel jesicht- oder druckbaren Zeichens. Die Ausgabegerate
doch einen Modus (transparent, Monitor, Display Functions), in der die Steu¨
erzeichen nicht ausgefuhrt,
sondern angezeigt werden. Die meisten Steuerzeichen belegen keine eigene Taste auf der Tastatur, sondern werden als Kombination aus der control-Taste und einer Zeichentaste eingegeben. In C/C++
¨ sich jedes Zeichen durch seine oktale Nummer in der Form \123 oder
laßt
durch seine hexadezimale Nummer in der Form \x53 eingeben (hier das S).
dezimal
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
127
C-Konst.
\x00
\a
\b
\t
\n
\v
\f
\r
\x1b
ASCII
nul
soh
stx
etx
eot
enq
ack
bel
bs
ht
lf
vt
ff
cr
so
si
dle
dc1
dc2
dc3
dc4
nak
syn
etb
can
em
sub
esc
fs
gs
rs
us
del
Bedeutung
ASCII-Null
Start of heading
Start of text
End of text
End of transmission
Enquiry
Acknowledge
Bell
Backspace
Horizontal tab
Line feed
Vertical tab
Form feed
Carriage return
Shift out
Shift in
Data link escape
Device control 1, xon
Device control 2, tape
Device control 3, xoff
Device control 4, tape
Negative acknowledge
Synchronous idle
End transmission block
Cancel
End of medium
Substitute
Escape
File separator
Group separator
Record separator
Unit separator
Delete
Tasten
control @
control a
control b
control c
control d
control e
control f
control g
control h, BS
control i, TAB
control j, LF
control k
control l
control m, RETURN
control n
control o
control p
control q
control r
control s
control t
control u
control v
control w
control x
control y
control z
control [, ESC
control \
control ]
control ˆ
control
DEL, RUBOUT
¨
B Zeichensatze
272
B.4
Latin-1 (ISO 8859-1)
¨
¨
Die internationale Norm ISO 8859 beschreibt gegenwartig
zehn Zeichensatze,
die jedes Zeichen durch jeweils ein Byte darstellen. Jeder Zeichensatz umfaßt also maximal 256 druckbare Zeichen und Steuerzeichen. Der erste –
¨ west- und mitteleuropaische
¨
Latin-1 genannt – ist fur
Sprachen – darunter Deutsch – vorgesehen. Latin-2 deckt Mittel- und Osteuropa ab, soweit
das lateinische Alphabet verwendet wird. Wer einen polnisch-deutschen Text
schreiben will, braucht Latin 2. Die deutschen Sonderzeichen liegen in Latin 1 bis 6 an denselben Stellen. Weiteres siehe in der ISO-Norm und im
RFC 1345 Character Mnemonics and Character Sets vom Juni 1992. Auch
http://wwwwbs.cs.tu-berlin.de/˜czyborra/charsets/ hilft weiter.
¨
¨
Die erste Halfte
(0 – 127) aller Latin-Zeichensatze
stimmt mit US-ASCII
¨
¨
uberein,
die zweite mit keinem der anderen Zeichensatze.
Zu jedem Zeichen geh¨ort eine standardisierte verbale Bezeichnung. Einige Zeichen wie das
¨
islandische
Thorn oder das Cent-Zeichen konnten hier mit LaTeX nicht dargestellt werden.
dezimal
000
001
002
003
004
005
006
007
008
009
010
011
012
013
014
015
016
017
018
019
020
021
022
023
024
025
026
027
028
oktal
000
001
002
003
004
005
006
007
010
011
012
013
014
015
016
017
020
021
022
023
024
025
026
027
030
031
032
033
034
hex
00
01
02
03
04
05
06
07
08
09
0a
0b
0c
0d
0e
0f
10
11
12
13
14
15
16
17
18
19
1a
1b
1c
Zeichen
nu
sh
sx
ex
et
eq
ak
bl
bs
ht
lf
vt
ff
cr
so
si
dl
d1
d2
d3
d4
nk
sy
eb
cn
em
sb
ec
fs
Bezeichnung
Null (nul)
Start of heading (soh)
Start of text (stx)
End of text (etx)
End of transmission (eot)
Enquiry (enq)
Acknowledge (ack)
Bell (bel)
Backspace (bs)
Character tabulation (ht)
Line feed (lf)
Line tabulation (vt)
Form feed (ff)
Carriage return (cr)
Shift out (so)
Shift in (si)
Datalink escape (dle)
Device control one (dc1)
Device control two (dc2)
Device control three (dc3)
Device control four (dc4)
Negative acknowledge (nak)
Synchronous idle (syn)
End of transmission block (etb)
Cancel (can)
End of medium (em)
Substitute (sub)
Escape (esc)
File separator (is4)
B.4 Latin-1 (ISO 8859-1)
029
030
031
032
033
034
035
036
037
038
039
040
041
042
043
044
045
046
047
048
049
050
051
052
053
054
055
056
057
058
059
060
061
062
063
064
065
066
067
068
069
070
071
072
073
074
075
076
077
035
036
037
040
041
042
043
044
045
046
047
050
051
052
053
054
055
056
057
060
061
062
063
064
065
066
067
070
071
072
073
074
075
076
077
100
101
102
103
104
105
106
107
110
111
112
113
114
115
1d
1e
1f
20
21
22
23
24
25
26
27
28
29
2a
2b
2c
2d
2e
2f
30
31
32
33
34
35
36
37
38
39
3a
3b
3c
3d
3e
3f
40
41
42
43
44
45
46
47
48
49
4a
4b
4c
4d
273
gs
rs
us
sp
!
”
#
$
%
&
’
(
)
*
+
,
.
/
0
1
2
3
4
5
6
7
8
9
:
;
<
=
>
?
@
A
B
C
D
E
F
G
H
I
J
K
L
M
Group separator (is3)
Record separator (is2)
Unit separator (is1)
Space
Exclamation mark
Quotation mark
Number sign
Dollar sign
Percent sign
Ampersand
Apostrophe
Left parenthesis
Right parenthesis
Asterisk
Plus sign
Comma
Hyphen-Minus
Full stop
Solidus
Digit zero
Digit one
Digit two
Digit three
Digit four
Digit five
Digit six
Digit seven
Digit eight
Digit nine
Colon
Semicolon
Less-than sign
Equals sign
Greater-than sign
Question mark
Commercial at
Latin capital letter a
Latin capital letter b
Latin capital letter c
Latin capital letter d
Latin capital letter e
Latin capital letter f
Latin capital letter g
Latin capital letter h
Latin capital letter i
Latin capital letter j
Latin capital letter k
Latin capital letter l
Latin capital letter m
¨
B Zeichensatze
274
078
079
080
081
082
083
084
085
086
087
088
089
090
091
092
093
094
095
096
097
098
099
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
116
117
120
121
122
123
124
125
126
127
130
131
132
133
134
135
136
137
140
141
142
143
144
145
146
147
150
151
152
153
154
155
156
157
160
161
162
163
164
165
166
167
170
171
172
173
174
175
176
4e
4f
50
51
52
53
54
55
56
57
58
59
5a
5b
5c
5d
5e
5f
60
61
62
63
64
65
66
67
68
69
6a
6b
6c
6d
6e
6f
70
71
72
73
74
75
76
77
78
79
7a
7b
7c
7d
7e
N
O
P
Q
R
S
T
U
V
W
X
Y
Z
[
\
]
ˆ
‘
a
b
c
d
e
f
g
h
i
j
k
l
m
n
o
p
q
r
s
t
u
v
w
x
y
z
{
|
}
˜
Latin capital letter n
Latin capital letter o
Latin capital letter p
Latin capital letter q
Latin capital letter r
Latin capital letter s
Latin capital letter t
Latin capital letter u
Latin capital letter v
Latin capital letter w
Latin capital letter x
Latin capital letter y
Latin capital letter z
Left square bracket
Reverse solidus
Right square bracket
Circumflex accent
Low line
Grave accent
Latin small letter a
Latin small letter b
Latin small letter c
Latin small letter d
Latin small letter e
Latin small letter f
Latin small letter g
Latin small letter h
Latin small letter i
Latin small letter j
Latin small letter k
Latin small letter l
Latin small letter m
Latin small letter n
Latin small letter o
Latin small letter p
Latin small letter q
Latin small letter r
Latin small letter s
Latin small letter t
Latin small letter u
Latin small letter v
Latin small letter w
Latin small letter x
Latin small letter y
Latin small letter z
Left curly bracket
Vertical line
Right curly bracket
Tilde
B.4 Latin-1 (ISO 8859-1)
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
177
200
201
202
203
204
205
206
207
210
211
212
213
214
215
216
217
220
221
222
223
224
225
226
227
230
231
232
233
234
235
236
237
240
241
242
243
244
245
246
247
250
251
252
253
254
255
256
257
7f
80
81
82
83
84
85
86
87
88
89
8a
8b
8c
8d
8e
8f
90
91
92
93
94
95
96
97
98
99
9a
9b
9c
9d
9e
9f
a0
a1
a2
a3
a4
a5
a6
a7
a8
a9
aa
ab
ac
ad
ae
af
275
dt
pa
ho
bh
nh
in
nl
sa
es
hs
hj
vs
pd
pu
ri
s2
s3
dc
p1
p2
ts
cc
mw
sg
eg
ss
gc
sc
ci
st
oc
pm
ac
ns
¡
£
§
c
a
¬
¯
Delete (del)
Padding character (pad)
High octet preset (hop)
Break permitted here (bph)
No break here (nbh)
Index (ind)
Next line (nel)
Start of selected area (ssa)
End of selected area (esa)
Character tabulation set (hts)
Character tabulation with justification (htj)
Line tabulation set (vts)
Partial line forward (pld)
Partial line backward (plu)
Reverse line feed (ri)
Single-shift two (ss2)
Single-shift three (ss3)
Device control string (dcs)
Private use one (pu1)
Private use two (pu2)
Set transmit state (sts)
Cancel character (cch)
Message waiting (mw)
Start of guarded area (spa)
End of guarded area (epa)
Start of string (sos)
Single graphic character introducer (sgci)
Single character introducer (sci)
Control sequence introducer (csi)
String terminator (st)
Operating system command (osc)
Privacy message (pm)
Application program command (apc)
No-break space
Inverted exclamation mark
Cent sign
Pound sign
¨
Currency sign (kunftig
Euro?)
Yen sign
Broken bar
Section sign
Diaresis
Copyright sign
Feminine ordinal indicator
Left-pointing double angle quotation mark
Not sign
Soft hyphen
Registered sign
Overline
¨
B Zeichensatze
276
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
260
261
262
263
264
265
266
267
270
271
272
273
274
275
276
277
300
301
302
303
304
305
306
307
310
311
312
313
314
315
316
317
320
321
322
323
324
325
326
327
330
331
332
333
334
335
336
337
b0
b1
b2
b3
b4
b5
b6
b7
b8
b9
ba
bb
bc
bd
be
bf
c0
c1
c2
c3
c4
c5
c6
c7
c8
c9
ca
cb
cc
cd
ce
cf
d0
d1
d2
d3
d4
d5
d6
d7
d8
d9
da
db
dc
dd
de
df
◦
±
2
3
’
µ
¶
·
¸
1
◦
1/4
1/2
3/4
¿
`
A
´
A
ˆ
A
˜
A
¨
A
˚
A
Æ
C
¸
`
E
´
E
ˆ
E
¨
E
I`
I´
Iˆ
I¨
˜
N
`
O
´
O
ˆ
O
˜
O
¨
O
×
Ø
`
U
´
U
ˆ
U
¨
U
´
Y
ß
Degree sign
Plus-minus sign
Superscript two
Superscript three
Acute accent
Micro sign
Pilcrow sign
Middle dot
Cedilla
Superscript one
Masculine ordinal indicator
Right-pointing double angle quotation mark
Vulgar fraction one quarter
Vulgar fraction one half
Vulgar fraction three quarters
Inverted question mark
Latin capital letter a with grave
Latin capital letter a with acute
Latin capital letter a with circumflex
Latin capital letter a with tilde
Latin capital letter a with diaresis
Latin capital letter a with ring above
Latin capital letter ae
Latin capital letter c with cedilla
Latin capital letter e with grave
Latin capital letter e with acute
Latin capital letter e with circumflex
Latin capital letter e with diaresis
Latin capital letter i with grave
Latin capital letter i with acute
Latin capital letter i with circumflex
Latin capital letter i with diaresis
Latin capital letter eth (Icelandic)
Latin capital letter n with tilde
Latin capital letter o with grave
Latin capital letter o with acute
Latin capital letter o with circumflex
Latin capital letter o with tilde
Latin capital letter o with diaresis
Multiplication sign
Latin capital letter o with stroke
Latin capital letter u with grave
Latin capital letter u with acute
Latin capital letter u with circumflex
Latin capital letter u with diaresis
Latin capital letter y with acute
Latin capital letter thorn (Icelandic)
Latin small letter sharp s (German)
B.4 Latin-1 (ISO 8859-1)
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
340
341
342
343
344
345
346
347
350
351
352
353
354
355
356
357
360
361
362
363
364
365
366
367
370
371
372
373
374
375
376
377
e0
e1
e2
e3
e4
e5
e6
e7
e8
e9
ea
eb
ec
ed
ee
ef
f0
f1
f2
f3
f4
f5
f6
f7
f8
f9
fa
fb
fc
fd
fe
ff
277
a`
a´
aˆ
a˜
a¨
a˚
æ
c¸
e`
e´
eˆ
e¨
`ı
´ı
ˆı
¨ı
n˜
o`
o´
oˆ
o˜
o¨
÷
ø
u`
u´
uˆ
u¨
y´
y¨
Latin small letter a with grave
Latin small letter a with acute
Latin small letter a with circumflex
Latin small letter a with tilde
Latin small letter a with diaresis
Latin small letter a with ring above
Latin small letter ae
Latin small letter c with cedilla
Latin small letter e with grave
Latin small letter e with acute
Latin small letter e with circumflex
Latin small letter e with diaresis
Latin small letter i with grave
Latin small letter i with acute
Latin small letter i with circumflex
Latin small letter i with diaresis
Latin small letter eth (Icelandic)
Latin small letter n with tilde
Latin small letter o with grave
Latin small letter o with acute
Latin small letter o with circumflex
Latin small letter o with tilde
Latin small letter o with diaresis
Division sign
Latin small letter o with stroke
Latin small letter u with grave
Latin small letter u with acute
Latin small letter u with circumflex
Latin small letter u with diaresis
Latin small letter y with acute
Latin small letter thorn (Icelandic)
Latin small letter y with diaresis
C
UNIX-Systemaufrufe
Systemaufrufe werden vom Anwendungsprogramm wie eigene oder fremde
Funktionen angesehen. Ihrem Ursprung nach sind es auch C-Funktionen.
Sie sind jedoch nicht Bestandteil einer Funktionsbibliothek, sondern geh¨oren
zum Betriebssystem und sind nicht durch andere Funktionen erweiterbar.
¨ alle
Die Systemaufrufe – als Bestandteil des Betriebssystems – sind fur
¨
Programmiersprachen dieselben, wahrend
die Funktionsbibliotheken zur jeweiligen Programmiersprache geh¨oren. Folgende Systemaufrufe sind unter
¨
UNIX verfugbar:
access
acct
alarm
atexit
brk
chdir
chmod
chown
chroot
close
creat
dup
errno
exec
exit
fcntl
fork
fsctl
fsync
getaccess
getacl
getcontext
getdirentries
getgroups
gethostname
getitimer
getpid
gettimeofday
getuid
ioctl
kill
link
¨ Zugriff auf File
pruft
startet und stoppt Prozess Accounting
¨ Prozess
setzt Weckeruhr fur
¨ Programmende
Funktion fur
¨
andert
Speicherzuweisung
wechselt Arbeitsverzeichnis
¨
andert
Zugriffsrechte eines Files
¨
andert
Besitzer eines Files
¨
andert
Root-Verzeichnis
schließt einen File-Deskriptor
o¨ ffnet File, ordnet Deskriptor zu
dupliziert File-Deskriptor
Fehlervariable der Systemaufrufe
¨
fuhrt
ein Programm aus
beendet einen Prozess
Filesteuerung
erzeugt einen neuen Prozess
liest Information aus File-System
schreibt File aus Arbeitsspeicher auf Platte
ermittelt Zugriffsrechte
ermittelt Zugriffsrechte
ermittelt Kontext eines Prozesses
¨
ermittelt Verzeichnis-Eintrage
ermittelt Gruppenrechte eines Prozesses
ermittelt Namen des Systems
setzt oder liest Intervall-Uhr
liest Prozess-ID
ermittelt Zeit
liest User-ID des aufrufenden Prozesses
I/O-Steuerung
schickt Signal an einen Prozess
linkt ein File
278
279
lockf
lseek
mkdir
mknod
mount
msgctl
nice
open
pause
pipe
prealloc
profil
read
readlink
rename
rmdir
rtprio
semctl
setgrp
setuid
signal
stat
statfs
symlink
sync
szsconf
time
times
truncate
umask
umount
unlink
ustat
utime
wait
write
setzt Semaphore und Record-Sperren
bewegt Schreiblesezeiger in einem File
erzeugt Verzeichnis
erzeugt File
¨
hangt
File-System in File-Hierarchie ein
Interprozess-Kommunikation
¨
¨ eines Prozesses
andert
die Prioritat
o¨ ffnet File zum Lesen oder Schreiben
suspendiert Prozess bis zum Empfang eines Signals
erzeugt eine Pipe
reserviert Arbeitsspeicher
¨
ermittelt Zeiten bei der Ausfuhrung
eines Programmes
liest aus einem File
liest symbolisches Link
¨
andert
Filenamen
l¨oscht Verzeichnis
¨
¨
andert
Echtzeit-Prioritat
Semaphore
setzt Gruppen-Zugriffsrechte eines Prozesses
setzt User-ID eines Prozesses
legt fest, was auf ein Signal hin zu tun ist
liest die Inode eines Files
liest Werte des File-Systems
erzeugt symbolischen Link
schreibt Puffer auf Platte
ermittelt Systemwerte
ermittelt die Systemzeit
ermittelt Zeitverbrauch eines Prozesses
schneidet File ab
setzt oder ermittelt Filezugriffsmaske
entfernt Filesystem aus File-Hierarchie
l¨oscht File
liest Werte des File-Systems
setzt Zeitstempel eines Files
wartet auf Ende eines Kindprozesses
schreibt in ein File
¨
Die Aufzahlung
kann durch weitere Systemaufrufe des jeweiligen Lieferan¨
ten des Betriebssystems (z. B. Hewlett-Packard) erganzt
werden. Diese er¨ Zu den
leichtern das Programmieren, verschlechtern aber die Portabilitat.
¨ set..., das in
meisten Systemaufrufen mit get... gibt es ein Gegenstuck
¨
einigen Fallen
dem Superuser vorbehalten ist.
D
C-Lexikon
¨
¨
D.1 Schlusselw
orter
¨
¨
In C/C++ durfen
Schlusselw¨
orter keinesfalls als Namen verwendet werden.
¨
Laut ANSI verwendet C folgende Schlusselw¨
orter (Wortsymbole, keywords):
• Deklaratoren
– auto, Default-Speicherklasse (kann weggelassen werden)
– char, Zeichentyp
– const, Typattribut (neu in ANSI-C)
– double, Typ Gleitkommazahl doppelter Genauigkeit
¨
– enum, Aufzahlungstyp
– extern, Speicherklasse
– float, Typ Gleitkommazahl einfacher Genauigkeit
¨
– int, Typ Ganzzahl einfacher Lange
¨
– long, Typ Ganzzahl doppelter Lange
– register, Speicherklasse Registervariable
¨
– short, Typ Ganzzahl halber Lange
– signed, Typzusatz zu Ganzzahl oder Zeichen
– static, Speicherklasse
– struct, Strukturtyp
– typedef, Definition eines benutzereigenen Typs
– union, Typ Union
– unsigned, Typzusatz zu Ganzzahl oder Zeichen
– void, leerer Typ
– volatile, Typattribut (neu in ANSI-C)
• Schleifen und Bedingungen (Kontrollanweisungen)
– break, Verlassen einer Schleife
– case, Fall einer Auswahl (switch)
¨
– continue, Rucksprung
vor eine Schleife
– default, Default-Fall einer Auswahl (switch)
– do, Beginn einer do-Schleife
280
¨
D.1 Schlusselw¨
orter
– else, Alternative einer Verzweigung
– for, Beginn einer for-Schleife
– goto, unbedingter Sprung
– if, Bedingung oder Beginn einer Verzweigung
– switch, Beginn einer Auswahl
– while, Beginn einer while-Schleife
• Sonstige
¨
– return, Rucksprung
in die aufrufende Einheit
– sizeof, Bytebedarf eines Typs oder einer Variablen
In C++ kommen laut B JARNE S TROUSTRUP hinzu:
• catch, Ausnahmebehandlung
• class, Klassendeklaration
• delete, L¨oschen eines Objektes
• friend, Deklaration einer Funktion
• inline, inline-Funktion
• new, Erzeugen eines Objektes
¨
• operator, Uberladen
von Operatoren
• private, Deklaration von Klassenmitgliedern
• protected, Deklaration von Klassenmitgliedern
• public, Deklaration von Klassenmitgliedern
• template, Deklaration eines Templates (Klasse)
• this, Pointer auf Objekt
• throw, Ausnahmebehandlung
• try, Ausnahmebehandlung
• virtual, Deklaration
¨
¨
Daruber
hinaus verwenden einige Compiler weitere Schlusselw¨
orter:
• asm, Assembler-Aufruf innerhalb einer C- oder C++-Quelle
• bool, logischer oder boolescher Typ
• cdecl, Aufruf einer Funktion nach C-Konventionen
¨ const-Werte
• const_cast, cast-Operator fur
• dynamic_cast, cast-Operator
¨ kunftigen
¨
• entry, (war in K&R-C fur
Gebrauch vorgesehen)
• explicit, Konstruktor-Vereinbarung
281
282
D C-Lexikon
• export, Vereinbarung bei Klassen-Templates
• false, boolesche Konstante
• far, Typzusatz unter MS-DOS
• fortran, Aufruf einer Funktion nach FORTRAN-Konventionen
• huge, Typzusatz unter MS-DOS
• mutable, Typattribut
• namespace, Vereinbarung des Geltungsbereiches von Namen
• near, Typzusatz unter MS-DOS
• pascal, Aufruf einer Funktion nach PASCAL-Konventionen
• reinterpret_cast, cast-Operator
• static_cast, cast-Operator
• true, boolesche Konstante
• typeid, Operator zum Ermitteln des Typs
¨
• typename, Alternative zum Schlusselwort
class
• using, Deklaration in Verbindung mit namespace
• wchar_t, Typ (wide character literal)
D.2 Operatoren
Die Operatoren von C/C++ sind im folgenden ihrem Vorrang nach geordnet,
h¨ochster Rang (Bindungskraft) zuoberst. Alle Operatoren eines Abschnitts
haben gleichen Rang. l bzw. r bedeutet von links bzw. rechts her assoziativ. Ein
¨
¨
¨
unarer
Operator verlangt einen Operanden, ein binarer
zwei und ein ternarer
drei.
Operator
::
::
::
( )
[ ]
->
.
++
-typeid
const cast
dynamic cast
reinterpret cast
static cast
A
r
l
l
l
l
l
l
r
r
¨
unar
¨
binar
¨
binar
¨
unar
¨
unar
¨
binar
¨
binar
¨
unar
¨
unar
¨
unar
¨
binar
¨
binar
¨
binar
¨
binar
Bedeutung
Bezugsrahmen, global
Bezugsrahmen, Klasse
Bezugsrahmen, Namensraum
Klammerung, Funktion
Index
Auswahl
Auswahl
Postfix Inkrement
Postfix Dekrement
Typabfrage
Typumwandlung
Typumwandlung
Typumwandlung
Typumwandlung
D.3 Standardfunktionen
sizeof
++
-˜
!
+
*
&
( )
new
delete
->*
.*
*
/
%
+
<<
>>
<
<=
>
>=
==
!=
&
ˆ
|
&&
||
?:
=
+=, -=, *=, /=
%=, >>=, <<=,
&=, |=, ˆ=
throw
,
D.3
283
r
r
r
r
r
r
r
r
r
r
r
r
l
l
l
l
l
l
l
l
l
l
l
l
l
l
l
l
l
l
l
l
l
r
r
¨
unar
¨
unar
¨
unar
¨
unar
¨
unar
¨
unar
¨
unar
¨
unar
¨
unar
¨
binar
¨
unar
¨
unar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
binar
¨
ternar
¨
binar
¨
binar
Gr¨oßenabfrage
¨
Prafix
Inkrement
¨
Prafix
Dekrement
bitweise Negation
logische Negation
negatives Vorzeichen
positives Vorzeichen
Dereferenzierung
Referenzierung
cast-Operator
dynamische Speicherbelegung
dynamische Speicherfreigabe
Auswahl
Auswahl
Multiplikation
Division
Modulus (Divisionsrest)
Addition
Subtraktion
bitweises Shiften links
bitweises Shiften rechts
kleiner als
kleiner gleich
gr¨oßer als
gr¨oßer gleich
Gleichheit
Ungleichheit
bitweises Und
bitweises exklusives Oder
bitweises Oder
logisches Und
logisches Oder
bedingte Bewertung
Zuweisung
zusammengesetzte
Zuweisung
¨
unar
Ausnahmebehandlung
Komma-Operator
l
Standardfunktionen
¨
Folgende Standardfunktionen oder -makros sind gebrauchlich:
• Pufferbehandlung
284
D C-Lexikon
– memchr, sucht Zeichen im Puffer
– memcmp, vergleicht Zeichen mit Pufferinhalt
– memcpy, kopiert Zeichen in Puffern
– memset, setzt Puffer auf bestimmtes Zeichen
• Zeichenbehandlung
¨ Zeichen, ob alphanumerisch
– isalnum, pruft
¨ Zeichen, ob Buchstabe
– isalpha, pruft
¨ Zeichen, ob Kontrollzeichen
– iscntrl, pruft
¨ Zeichen, ob Ziffer
– isdigit, pruft
¨ Zeichen, ob sichtbar
– isgraph, pruft
¨ Zeichen, ob Kleinbuchstabe
– islower, pruft
¨ Zeichen, ob druckbar
– isprint, pruft
¨ Zeichen, ob Satzzeichen
– ispunct, pruft
¨ Zeichen, ob Whitespace
– isspace, pruft
¨ Zeichen. ob Großbuchstabe
– isupper, pruft
¨ Zeichen, ob hexadezimale Ziffer
– isxdigit, pruft
– tolower, wandelt Großbuchstaben in Kleinbuchstaben um
– toupper, wandelt Kleinbuchstaben in Großbuchstaben um
• Datenumwandlung
– atof, wandelt String in double-Wert um
– atoi, wandelt String in int-Wert um
– atol, wandelt String in long-Wert um
– strtod, wandelt String in double-Wert um
– strtol, wandelt String in long-Wert um
– strtoul, wandelt String in unsigned long-Wert um
• Filebehandlung
– remove, l¨oscht File
¨
– rename, andert
Namen eines Files
• Ein- und Ausgabe
– clearerr, l¨oscht Fehlermeldung eines Filepointers
– fclose, schließt Filepointer
– fflush, leert Puffer eines Filepointers
– fgetc, liest Zeichen von Filepointer
D.3 Standardfunktionen
– fgetpos, ermittelt Stand des Lesezeigers
– fgets, liest String von Filepointer
– fopen, o¨ ffnet Filepointer
– fprintf, schreibt formatiert nach Filepointer
– fputc, schreibt Zeichen nach Filepointer
– fputs, schreibt String nach Filepointer
– fread, liest Bytes von Filepointer
– freopen, ersetzt ge¨offneten Filepointer
– fscanf, liest formatiert von Filepointer
– fseek, setzt Lesezeiger auf bestimmte Stelle
– fsetpos, setzt Lesezeiger auf bestimmte Stelle
– ftell, ermittelt Stellung des Lesezeigers
– fwrite, schreibt Bytes nach Filepointer
– getc, liest Zeichen von Filepointer
– getchar, liest Zeichen von stdin
– gets, liest String von Filepointer
– printf, schreibt formatiert nach stdout
– putc, schreibt Zeichen nach Filepointer
– putchar, schreibt Zeichen nach stdout
– puts, schreibt String nach Filepointer
– rewind, setzt Lesezeiger auf Fileanfang
– scanf, liest formatiert von stdin
– setbuf, ordnet einem Filepointer einen Puffer zu
– setvbuf, ordnet einem Filepointer einen Puffer zu
– sprintf, schreibt formatiert in einen String
– sscanf, liest formatiert aus einem String
¨
– tempnam, erzeugt einen temporaren
Filenamen
¨
– tmpfile, erzeugt ein temporares
File
¨
– ungetc, schreibt letztes gelesenes Zeichen zuruck
– vfprintf, schreibt formatiert aus einer Argumentenliste
– vprintf, schreibt formatiert aus einer Argumentenliste
– vsprintf, schreibt formatiert aus einer Argumentenlsite
• Mathematik
– acos, arcus cosinus
– asin, arcus sinus
285
286
D C-Lexikon
– atan, arcus tangens
– atan2, arcus tangens, erweiterter Bereich
– ceil, kleinste Ganzzahl
– cos, cosinus
– cosh, cosinus hyperbolicus
– exp, Exponentialfunktion
– fabs, Absolutwert, Betrag
– floor, gr¨oßte Ganzzahl
– fmod, Divisionsrest
– frexp, teilt Gleitkommazahl auf
– ldexp, teilt Gleitkommazahl auf
– log, Logarithmus naturalis
– log10, dekadischer Logarithmus
– modf, teilt Gleitkommazahl auf
– pow, allgemeine Potenz
– sin, sinus
– sinh, sinus hyperbolicus
– sqrt, positive Quadratwurzel
– tan, tangens
– tanh, tangens hyperbolicus
• Speicherzuweisung
¨ Array
– calloc, allokiert Speicher fur
– free, gibt allokierten Speicher frei
– malloc, allokiert Speicher
¨
– realloc, andert
Gr¨oße des allokierten Speichers
• Prozesssteuerung
– abort, erzeugt SIGABRT-Signal
– atexit, Funktionsaufruf bei Programmende
– exit, Programmende
– raise, sendet Signal
– signal, legt Antwort auf Siganl fest
¨
– system, ubergibt
Argument an Kommandointerpreter
• Suchen und Sortieren
¨ Suche
– bsearch, binare
D.4 printf(3), scanf(3)
287
– qsort, Quicksort
• Stringbehandlung
– strcat, verkettet Strings
– strchr, sucht Zeichen in String
– strcmp, vergleicht Strings
– strcpy, kopiert String
– strcspn, sucht Teilstring
– strerror, verweist auf Fehlermeldung
¨
– strlen, ermittelt Stringlange
– strncat, verkettet n Zeichen von Strings
– strncmp, vergleicht n Zeichen von Strings
– strncpy, kopiert n Zeichen eines Strings
– strpbrk, sucht Zeichen in String
– strrchr, sucht Zeichen in String
¨
– strspn, ermittelt Lange
eines Teilstrings
– strstr, sucht Zeichen in String
Dies sind alle Funktionen des ANSI-Vorschlags. Die meisten Compiler bieten
¨
daruberhinaus
eine Vielzahl weiterer Funktionen, die das Programmieren er¨ verschlechtern.
leichtern, aber die Portabilitat
D.4
printf(3), scanf(3)
printf(3) und scanf(3) sind die beiden Standardfunktionen zum Ein- und
Ausgeben von Daten. Wichtiger Unterschied: printf(3) erwartet Variable,
¨
scanf(3) Pointer. Die Formatbezeichner stimmen weitgehend uberein:
Bezeichner
%c
%s
%d
%i
%u
%ld
%f
%e
%g
%o
%x
%p
Typ
char
char *
int
int
unsigned
long
double
double
double
unsigned octal
unsigned hex
void *
Beispiel
Bedeutung
a
Zeichen
Karlsruhe String
-1234
dezimale Ganzzahl mit Vorzeichen
-1234
dezimale Ganzzahl mit Vorzeichen
1234
dezimale Ganzzahl ohne Vorzeichen
¨
1234
dezimal Ganzzahl doppelter Lange
12.34
Gleitkommazahl mit Vorzeichen
1.234 E 1 Gleitkommazahl, Exponentialform
12.34
kurze Darstellung von %e oder %f
2322
oktale Ganzzahl ohne Vorzeichen
4d2
hexadezimale Ganzzahl o. Vorzeichen
68ff32e4
Pointer
288
%%
D C-Lexikon
-
%
Prozentzeichen
¨
Weiteres im Referenz-Handbuch unter printf(3) oder scanf(3). Lange,
¨
¨
¨
Bundigkeit,
Unterdruckung
fuhrender
Nullen, Vorzeichenangabe k¨onnen
festgelegt werden.
D.5 Include-Dateien
Die Standard-Include-Dateien enthalten in lesbarer Form Definitionen von
Konstanten und Typen, Deklarationen von Funktionen und Makrodefinitionen. Sie werden von Systemaufrufen und Bibliotheksfunktionen ben¨otigt.
Bei der Beschreibung jeder Funktion im Referenz-Handbuch ist angegeben,
¨
¨
welche Include-Dateien jeweils eingebunden werden mussen.
Gebrauchliche
Include-Dateien sind:
• ctype.h, Definition von Zeichenklassen (conv(3))
• curses.h, Bildschirmsteuerung (curses(3))
• errno.h, Fehlermeldungen des Systems (errno(2))
• fcntl.h, Steuerung des Dateizugriffs (fcntl(2), open(2))
• malloc.h, Speicherallokierung (malloc(3))
• math.h, mathematische Funktionen (log(3), sqrt(3), floor(3))
• memory.h, Speicherfunktionen (memory(3))
• search.h, Suchfunktionen (bsearch(3))
• signal.h, Signalbehandlung (signal(2))
• stdio.h, Ein- und Ausgabe (printf(3), scanf(3), fopen(3))
• string.h, Stringbehandlung (string(3))
• time.h, Zeitfunktionen (ctime(3))
¨
• varargs.h, Argumentenliste variabler Lange
(vprintf(3))
• sys/ioctl.h, Ein- und Ausgabe (ioctl(2))
• sys/stat.h, Zugriffsrechte (chmod(2), mkdir(2), stat(2))
• sys/types.h , verschiedene Deklarationen (chmod(2), getut(3))
¨
Auch diese Liste ist vom Compiler und damit von der Hardware abhangig.
So
findet man die include-Datei dos.h nicht auf UNIX-Anlagen, sondern nur bei
¨ PCs.
Compilern unter MS-DOS fur
¨
D.6 Praprozessor-Anweisungen
D.6
289
¨
Praprozessor-Anweisungen
Der erste Schritt beim Compilieren ist die Bearbeitung des Quelltextes durch
¨
¨
den Praprozessor.
Dieser entfernt den Kommentar und fuhrt
Ersetzungen
¨
¨ der folgenden Anweisungen (directives) aus:
und Einfugungen
gemaß
¨
• #define buchstabliche
Ersetzung einer symbolischen Konstanten oder
eines Makros. Ist kein Ersatz angegeben, wird nur der Name als defi¨ #ifdef). Haufig.
¨
niert angesehen (fur
• #undefine l¨oscht die Definition eines Namens.
¨
¨
• #error fuhrt
zu einer Fehlermeldung des Praprozessors.
¨
• #include zieht die angegebene Datei herein. Haufig.
• #if, #else, #elif, #endif falls Bedingung zutrifft, werden die
¨
¨
nachfolgenden Praprozessor-Anweisungen
ausgefuhrt.
• #ifdef, #ifndef falls der angegebene Name definiert bzw. nicht de¨
finiert ist, werden die nachfolgenden Praprozessor-Anweisungen
aus¨
gefuhrt.
¨
• #line fuhrt
bei Fehlermeldungen zu einem Sprung auf die angegebenen
Zeilennummer.
¨
¨
• #pragma veranlaßt den Praprozessor
zu einer systemabhangigen
Handlung.
E
Karlsruher Test
¨ so schwierige Dinge wie die elektronische
Nicht jedermann eignet sich fur
Datenverarbeitung. Um Ihnen die Entscheidung zu erleichtern, ob Sie in die
EDV einsteigen oder sich angenehmeren Dingen widmen sollten, haben wir
¨ Sie einen Test entwickelt. Woran denken Sie bei:
ganz besonders fur
Bit
Bier aus der Eifel (1 Punkt)
Schraubendrehereinsatz (1)
kleinste Dateneinheit (2 Punkte)
Festplatte
Was zum Essen, vom Partyservice (1)
Schallplatte (0)
Massenspeicher (2)
Menu¨
Was zum Essen (1)
Dialogtechnik (2)
mittelalterlicher Tanz (0)
CPU
politische Partei (0)
Zentralprozessor (2)
Carnevalsverein (0)
Linker
¨
Linkshander
(0)
¨
Anhanger
einer Linkspartei (1)
Programm zum Binden von Modulen (2)
IBM
¨ (1)
Ich Bin Mude
International Business Machines (2)
International Brotherhood of Magicians (1)
Schnittstelle
Verletzung (1)
¨ (2)
Verbindungsstelle zweier EDV-Gerate
Werkstatt eines Bartscherers (0)
Slot
Steckerleiste im Computer (2)
einarmiger Bandit (1)
¨ Kamin (0)
niederdeutsch fur
290
291
Fortran
starker Lebertran (0)
Formal Trash Notation (0)
Programmiersprache (2)
Mainframe
Frachtkahn auf dem Main (0)
Damit wollte F RIDTJOF N ANSEN zum Nordpol (0)
großer Computer (2)
PC
Plumpsklo (Gravitationstoilette) (1)
Personal Computer (2)
Power Computing Language (0)
Puffer
Was zum Essen, aus Kartoffeln (1)
Was am Eisenbahnwagen (1)
Zwischenspeicher (2)
Software
¨ Softice (0)
Rohstoff fur
Programme, Daten und so Zeugs (2)
was zum Trinken (0)
Port
was zum Trinken (1)
Hafen (1)
¨ Peripheriegerate
¨ (2)
Steckdose fur
Strichcode
maschinell lesbarer Code (2)
Geheimsprache im Rotlichtviertel (0)
Urliste in der Statistik (0)
Chip
was zum Essen (1)
was zum Spielen (1)
Halbleiterbaustein (2)
Pointer
Hund (1)
starker Whisky (0)
Zeiger auf Daten, Adresse (2)
Page
Hotelboy (1)
englisch, Seite in einem Buch (1)
Untergliederung eines Speichers (2)
Character
was manchen Politikern fehlt (1)
Schriftzeichen (2)
Wasserfall (0)
292
E Karlsruher Test
Betriebssystem
Konzern (0)
betriebsinternes Telefonsystem (0)
wichtigstes Programm im Computer (2)
Traktor
Papiereinzugsvorrichtung (2)
landwirtschaftliches Fahrzeug (1)
Zahl beim Multiplizieren (0)
Treiber
Hilfsperson bei der Jagd (1)
Programm zum Ansprechen der Peripherie (2)
Vorarbeiter (0)
Animator
was zum Trinken (1)
Unterhalter (1)
¨ bewegte Grafik (2)
Programm fur
Hackbrett
Musikinstrument (1)
Werkzeug im Hackbau (0)
Tastatur (2)
emulieren
nachahmen (2)
¨ in Wasser verteilen (0)
Ol
entpflichten (0)
Font
Menge von Schriftzeichen (2)
Soßengrundlage (1)
Hintergrund, Geldmenge (0)
Server
Brettsegler (0)
Kellner (0)
¨ Dienstleistungen (2)
Computer fur
Yabbawhap
Datenkompressionsprogramm (2)
¨
Kriegsruf der Sudstadt-Indianer
(0)
was zum Essen (0)
Terminal
Schnittstelle Mensch - Computer (2)
Bahnhof oder Hafen (1)
Zubeh¨or zu Drahttauwerk (1)
Ampersand
Sand aus der Amper (1)
et-Zeichen, Kaufmanns-Und (2)
Untiefe im Wattenmeer (0)
293
Alias
altgriechisches Epos (0)
alttestamentarischer Prophet (0)
Zweitname (2)
Buscontroller
Busfahrer (0)
Busschaffner (0)
Programm zur Steuerung eines Datenbusses (2)
Algol
was zum Trinken (0)
Doppelstern (1)
Programmiersprache (2)
Rom
Stadt in Italien (1)
¨ Rum (1)
schwedisch fur
Read only memory (2)
Dram
Dynamic random access memory (2)
¨
¨ Schnaps (1)
danisch
fur
Straßenbahn (0)
Diskette
¨
Madchen,
das oft in Discos geht (0)
weiblicher Diskjockey (0)
Massenspeicher (2)
Directory
oberste Etage einer Firma (0)
Inhaltsverzeichnis (2)
Kunststil zur Zeit der Franz. Revolution (0)
Dekrement
¨
¨ (0)
was die Verdauung ubrig
laßt
Anordnung von oben (0)
¨
Wert, um den ein Zahler
verringert wird (2)
Sprungbefehl
¨
Vorkommnis wahrend
Ihres Wehrdienstes (0)
Kommando im Pferdesport (0)
Anweisung in einem Programm (2)
Oktalzahl
¨ die Klopffestigkeit (0)
Maß fur
Zahl zur Basis 8 (2)
Anzahl der Oktaven einer Orgel (0)
Subroutine
¨ eines Priesters (0)
Kleidungsstuck
was im Unterbewußten (0)
Unterprogramm (2)
294
E Karlsruher Test
Spoiler
Was zum Essen (0)
Posting in den Netnews (2)
Was am Auto (1)
virtuell
tugendhaft (0)
die Augen betreffend (0)
nicht wirklich vorhanden, scheinbar (2)
Klammeraffe
ASCII-Zeichen (2)
¨
¨ (1)
Buroger
at
¨
Affenart in Sudamerika
(0)
ESC
Eisenbahner-Spar- und Creditverein (0)
Eishockeyclub (0)
escape, Fluchtsymbol (2)
Monitor
Karlsruher Brauerei (0)
Fernsehsendung (1)
¨
¨ Uberwachungsprogramm
Bildschirmgerat,
(2)
Unix
¨
Tutensuppe
(0)
Freund von Asterix und Obelix (0)
hervorragendes Betriebssystem (2)
Joystick
Computerzubeh¨or (2)
¨
mannlicher
K¨orperteil (0)
Hebel am Spielautomat (0)
Maus
¨
kleines Saugetier
(1)
Computerzubeh¨or (2)
junge Dame (1)
Icon
russisches Heiligenbild (0)
Sinnbild (2)
Kamerafabrik (0)
Pascal
franz¨osischer Mathematiker (1)
¨ Druck (1)
Maßeinheit fur
Programmiersprache (2)
Wysiwyg
¨ Wolpertinger (0)
englisch fur
¨ Elmentritschen (0)
franz¨osisch fur
what you see is what you get (2)
295
Register
was in Flensburg (1)
was an der Orgel (1)
Speicher (2)
Record
was im Sport (1)
¨ Blockfl¨ote (0)
englisch fur
Datensatz (2)
HP
High Price (0)
Hewlett-Packard (2)
Horse Power (1)
Kermit
Klebstoff (0)
Frosch aus der Muppet-Show (1)
¨
Fileubertragungs-Protokoll
(2)
Ethernet
Baustoff (Asbestzement) (0)
Local Area Network (2)
¨
Student der ETH Zurich
(0)
Algorithmus
¨
¨
¨
Uberm
aßiger
Genuß geistiger Getranke
(0)
Krankheit (0)
Rechenvorschrift (2)
File
Was zum Essen (0)
Menge von Daten (2)
Durchtriebener Kerl (0)
Bug
Vorderteil eines Schiffes (1)
Fehler im Programm (2)
¨ Wanze (1)
englisch fur
Router
jemand mit Routine (0)
franz¨osischer LKW-Fahrer (0)
Verbindungsglied zweier Netze (2)
Zylinder
Kopfbedeckung (1)
Teil einer Kolbenmaschine (1)
Unterteilung eines Plattenspeichers (2)
FTP
kleine, aber liberale Partei (0)
File Transfer Protocol (2)
Floating Point Processor (0)
296
E Karlsruher Test
¨
Domane
Geist(0)
Bereich (2)
Blume (0)
Bridge
Kartenspiel (1)
internationales Computernetz (0)
Verbindung zweier Computernetze (2)
Email
Glasur (1)
elektronische Post (2)
Sultanspalast (0)
Baum
was im Wald (Wurzel unten) (1)
was auf einem Schiff (keine Wurzel) (1)
was aus der Informatik (Wurzel oben) (2)
Internet
Schule mit Schlafgelegenheit (0)
Zwischenraum (0)
Weltweites Computernetz (2)
Split
UNIX-Kommando (2)
kantige Steinchen (0)
Stadt in Dalmatien (1)
Mini
Damenoberbekleidung (1)
kleiner Computer (2)
Frau von Mickey Mouse (0)
Cut
Herrenoberbekleidung (1)
Colonia Ulpia Traiana (1)
UNIX-Kommando (2)
2B|!2B
Parallelprozessor (0)
Assembler-Befehl (0)
ein Wort Hamlets (2)
Shell
Filmschauspielerin (Maria S.) (0)
Kommando-Interpreter (2)
Mineral¨ol-Gesellschaft (1)
Slip
Unterbekleidung (1)
Schlupfschuh (0)
Internet-Protokoll (2)
297
¨
Diaresis
Durchfall (0)
Diakritisches Zeichen (Umlaute) (2)
¨
Ernahrungslehre
(0)
Space Bar
Kneipe im Weltraum (www.spacebar.com) (0)
¨ den Druck im Weltraum (0)
Maßeinheit fur
Gr¨oßte Taste auf der Tastatur (2)
Popper
Popcorn-R¨oster (0)
Mail-Programm (2)
Philosoph aus Wien (1)
Rohling
¨
Wuster
Kerl (1)
Noch zu beschreibende CD/DVD (2)
Rohkost-Liebhaber (0)
Schleife
¨ (1)
Kleidungsstuck
Schlitterbahn (1)
Kontrollanweisung eines Programmes (2)
Alex
Altlasten-Expertensystem (1)
Automatic Login Executor (1)
Globales Filesystem (1)
Altair
Stern (Alpha Aquilae) (1)
Gebirge in Zentralasien (0)
¨
fruher
Personal Computer (2)
Halbbitter
Was zum Essen (Schokolade) (1)
Strom- und bitsparender Prozessor (0)
Was zum Trinken (0)
¨
Eure Prioritat
Anrede des Priors in einem Kloster (0)
¨ im Vatikan (0)
Anrede des Ersten Sekretars
Anrede des System-Managers (6)
¨
Zahlen
Sie Ihre Punkte zusammen. Die Auswertung ergibt Folgendes:
¨
¨
¨
• uber
170 Punkte: Uberlassen
Sie das Rechnen kunftig
dem Computer.
• 85 bis 170 Punkte: Mit etwas Fleiß wird aus Ihnen ein EDV-Experte.
• 18 bis 84 Punkte: Machen Sie eine m¨oglichst steile Karriere außerhalb
¨
der EDV und suchen Sie sich fahige
Mitarbeiter.
• unter 18 Punkten: Vielleicht hatten Sie schlechte Lehrer?
F
GNU Lizenzen
F.1
GNU General Public License
Kopiert von http://www.gnu.org/copyleft/.
Version 2, June 1991
c 1989, 1991 Free Software Foundation, Inc.
Copyright 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.
P REAMBLE
The licenses for most software are designed to take away your freedom to share and change it. By contrast, the GNU General Public License is intended to
guarantee your freedom to share and change free software—to make sure the
software is free for all its users. This General Public License applies to most
of the Free Software Foundation’s software and to any other program whose
authors commit to using it. (Some other Free Software Foundation software is
covered by the GNU Library General Public License instead.) You can apply
it to your programs, too.
When we speak of free software, we are referring to freedom, not price. Our
General Public Licenses are designed to make sure that you have the freedom
to distribute copies of free software (and charge for this service if you wish),
that you receive source code or can get it if you want it, that you can change
the software or use pieces of it in new free programs; and that you know you
can do these things.
To protect your rights, we need to make restrictions that forbid anyone to
deny you these rights or to ask you to surrender the rights. These restrictions translate to certain responsibilities for you if you distribute copies of the
software, or if you modify it.
For example, if you distribute copies of such a program, whether gratis or
for a fee, you must give the recipients all the rights that you have. You must
make sure that they, too, receive or can get the source code. And you must
show them these terms so they know their rights.
We protect your rights with two steps: (1) copyright the software, and
(2) offer you this license which gives you legal permission to copy, distribute and/or modify the software.
Also, for each author’s protection and ours, we want to make certain that
everyone understands that there is no warranty for this free software. If the
298
F.1 GNU General Public License
299
software is modified by someone else and passed on, we want its recipients to
know that what they have is not the original, so that any problems introduced
by others will not reflect on the original authors’ reputations.
Finally, any free program is threatened constantly by software patents. We
wish to avoid the danger that redistributors of a free program will individually
obtain patent licenses, in effect making the program proprietary. To prevent
this, we have made it clear that any patent must be licensed for everyone’s
free use or not licensed at all.
The precise terms and conditions for copying, distribution and modification
follow.
GNU G ENERAL P UBLIC L ICENSE
T ERMS AND C ONDITIONS F OR C OPYING,
D ISTRIBUTION AND M ODIFICATION
0. This License applies to any program or other work which contains a notice placed by the copyright holder saying it may be distributed under
the terms of this General Public License. The “Program”, below, refers to
any such program or work, and a “work based on the Program” means
either the Program or any derivative work under copyright law: that is
to say, a work containing the Program or a portion of it, either verbatim
or with modifications and/or translated into another language. (Hereinafter, translation is included without limitation in the term “modification”.) Each licensee is addressed as “you”.
Activities other than copying, distribution and modification are not covered by this License; they are outside its scope. The act of running the
Program is not restricted, and the output from the Program is covered
only if its contents constitute a work based on the Program (independent
of having been made by running the Program). Whether that is true depends on what the Program does.
1. You may copy and distribute verbatim copies of the Program’s source code as you receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice and
disclaimer of warranty; keep intact all the notices that refer to this License and to the absence of any warranty; and give any other recipients
of the Program a copy of this License along with the Program.
You may charge a fee for the physical act of transferring a copy, and you
may at your option offer warranty protection in exchange for a fee.
2. You may modify your copy or copies of the Program or any portion of it,
thus forming a work based on the Program, and copy and distribute such
modifications or work under the terms of Section 1 above, provided that
you also meet all of these conditions:
(a) You must cause the modified files to carry prominent notices stating
that you changed the files and the date of any change.
300
F GNU Lizenzen
(b) You must cause any work that you distribute or publish, that in
whole or in part contains or is derived from the Program or any part
thereof, to be licensed as a whole at no charge to all third parties
under the terms of this License.
(c) If the modified program normally reads commands interactively
when run, you must cause it, when started running for such interactive use in the most ordinary way, to print or display an announcement including an appropriate copyright notice and a notice
that there is no warranty (or else, saying that you provide a warranty) and that users may redistribute the program under these
conditions, and telling the user how to view a copy of this License.
(Exception: if the Program itself is interactive but does not normally print such an announcement, your work based on the Program is
not required to print an announcement.)
These requirements apply to the modified work as a whole. If identifiable sections of that work are not derived from the Program, and can be
reasonably considered independent and separate works in themselves,
then this License, and its terms, do not apply to those sections when you
distribute them as separate works. But when you distribute the same
sections as part of a whole which is a work based on the Program, the
distribution of the whole must be on the terms of this License, whose
permissions for other licensees extend to the entire whole, and thus to
each and every part regardless of who wrote it.
Thus, it is not the intent of this section to claim rights or contest your
rights to work written entirely by you; rather, the intent is to exercise the
right to control the distribution of derivative or collective works based on
the Program.
In addition, mere aggregation of another work not based on the Program
with the Program (or with a work based on the Program) on a volume
of a storage or distribution medium does not bring the other work under
the scope of this License.
3. You may copy and distribute the Program (or a work based on it, under
Section 2) in object code or executable form under the terms of Sections
1 and 2 above provided that you also do one of the following:
(a) Accompany it with the complete corresponding machine-readable
source code, which must be distributed under the terms of Sections
1 and 2 above on a medium customarily used for software interchange; or,
(b) Accompany it with a written offer, valid for at least three years, to
give any third party, for a charge no more than your cost of physically performing source distribution, a complete machine-readable
copy of the corresponding source code, to be distributed under the
terms of Sections 1 and 2 above on a medium customarily used for
software interchange; or,
F.1 GNU General Public License
301
(c) Accompany it with the information you received as to the offer to
distribute corresponding source code. (This alternative is allowed
only for noncommercial distribution and only if you received the
program in object code or executable form with such an offer, in
accord with Subsection b above.)
The source code for a work means the preferred form of the work for
making modifications to it. For an executable work, complete source code
means all the source code for all modules it contains, plus any associated
interface definition files, plus the scripts used to control compilation and
installation of the executable. However, as a special exception, the source
code distributed need not include anything that is normally distributed
(in either source or binary form) with the major components (compiler,
kernel, and so on) of the operating system on which the executable runs,
unless that component itself accompanies the executable.
If distribution of executable or object code is made by offering access
to copy from a designated place, then offering equivalent access to copy
the source code from the same place counts as distribution of the source
code, even though third parties are not compelled to copy the source
along with the object code.
4. You may not copy, modify, sublicense, or distribute the Program except
as expressly provided under this License. Any attempt otherwise to copy,
modify, sublicense or distribute the Program is void, and will automatically terminate your rights under this License. However, parties who
have received copies, or rights, from you under this License will not have
their licenses terminated so long as such parties remain in full compliance.
5. You are not required to accept this License, since you have not signed
it. However, nothing else grants you permission to modify or distribute
the Program or its derivative works. These actions are prohibited by law
if you do not accept this License. Therefore, by modifying or distributing the Program (or any work based on the Program), you indicate your
acceptance of this License to do so, and all its terms and conditions for
copying, distributing or modifying the Program or works based on it.
6. Each time you redistribute the Program (or any work based on the Program), the recipient automatically receives a license from the original
licensor to copy, distribute or modify the Program subject to these terms
and conditions. You may not impose any further restrictions on the recipients’ exercise of the rights granted herein. You are not responsible for
enforcing compliance by third parties to this License.
7. If, as a consequence of a court judgment or allegation of patent infringement or for any other reason (not limited to patent issues), conditions are
imposed on you (whether by court order, agreement or otherwise) that
contradict the conditions of this License, they do not excuse you from the
302
F GNU Lizenzen
conditions of this License. If you cannot distribute so as to satisfy simultaneously your obligations under this License and any other pertinent
obligations, then as a consequence you may not distribute the Program
at all. For example, if a patent license would not permit royalty-free redistribution of the Program by all those who receive copies directly or
indirectly through you, then the only way you could satisfy both it and
this License would be to refrain entirely from distribution of the Program.
If any portion of this section is held invalid or unenforceable under any
particular circumstance, the balance of the section is intended to apply
and the section as a whole is intended to apply in other circumstances.
It is not the purpose of this section to induce you to infringe any patents
or other property right claims or to contest validity of any such claims;
this section has the sole purpose of protecting the integrity of the free
software distribution system, which is implemented by public license
practices. Many people have made generous contributions to the wide
range of software distributed through that system in reliance on consistent application of that system; it is up to the author/donor to decide if
he or she is willing to distribute software through any other system and
a licensee cannot impose that choice.
This section is intended to make thoroughly clear what is believed to be
a consequence of the rest of this License.
8. If the distribution and/or use of the Program is restricted in certain countries either by patents or by copyrighted interfaces, the original copyright holder who places the Program under this License may add an explicit geographical distribution limitation excluding those countries, so
that distribution is permitted only in or among countries not thus excluded. In such case, this License incorporates the limitation as if written
in the body of this License.
9. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of this License which applies to it and “any
later version”, you have the option of following the terms and conditions either of that version or of any later version published by the Free
Software Foundation. If the Program does not specify a version number
of this License, you may choose any version ever published by the Free
Software Foundation.
10. If you wish to incorporate parts of the Program into other free programs
whose distribution conditions are different, write to the author to ask
for permission. For software which is copyrighted by the Free Software
F.1 GNU General Public License
303
Foundation, write to the Free Software Foundation; we sometimes make exceptions for this. Our decision will be guided by the two goals of
preserving the free status of all derivatives of our free software and of
promoting the sharing and reuse of software generally.
N O WARRANTY
11. B ECAUSE
THE PROGRAM IS LICENSED FREE OF CHARGE , THERE IS NO
WARRANTY FOR THE PROGRAM , TO THE EXTENT PERMITTED BY AP PLICABLE LAW.
E XCEPT
WHEN OTHERWISE STATED IN WRITING THE
COPYRIGHT HOLDERS AND / OR OTHER PARTIES PROVIDE THE PROGRAM
“AS
IS ” WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED OR
IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRAN TIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPO SE .
T HE
ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
PROGRAM IS WITH YOU.
S HOULD
THE PROGRAM PROVE DEFECTIVE ,
YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR
CORRECTION.
12. I N
NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO
IN WRITING WILL ANY COPYRIGHT HOLDER , OR ANY OTHER PARTY
WHO MAY MODIFY AND / OR REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE , BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GE NERAL , SPECIAL , INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
OUT OF THE USE OR INABILITY TO USE THE PROGRAM ( INCLUDING BUT
NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURA TE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE
OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS ), EVEN IF
SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBI LITY OF SUCH DAMAGES.
E ND OF T ERMS AND C ONDITIONS
Appendix: How to Apply These Terms to Your
New Programs
If you develop a new program, and you want it to be of the greatest possible
use to the public, the best way to achieve this is to make it free software which
everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest to attach
them to the start of each source file to most effectively convey the exclusion of
warranty; and each file should have at least the “copyright” line and a pointer
to where the full notice is found.
304
F GNU Lizenzen
¡one line to give the program’s name and a brief idea of what it
does.¿
Copyright (C) ¡year¿ ¡name of author¿
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published
by the Free Software Foundation; either version 2 of the License,
or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty
of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
USA.
Also add information on how to contact you by electronic and paper mail.
If the program is interactive, make it output a short notice like this when
it starts in an interactive mode:
Gnomovision version 69, Copyright (C) ¡year¿ ¡name of author¿
Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type ‘show w’.
This is free software, and you are welcome to redistribute it under
certain conditions; type ‘show c’ for details.
The hypothetical commands show w and show c should show the appropriate parts of the General Public License. Of course, the commands you use
may be called something other than show w and show c; they could even be
mouse-clicks or menu items—whatever suits your program.
You should also get your employer (if you work as a programmer) or your
school, if any, to sign a “copyright disclaimer” for the program, if necessary.
Here is a sample; alter the names:
Yoyodyne, Inc., hereby disclaims all copyright interest in the
program
‘Gnomovision’ (which makes passes at compilers) written by James
Hacker.
¡signature of Ty Coon¿, 1 April 1989
Ty Coon, President of Vice
This General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you may
consider it more useful to permit linking proprietary applications with the
library. If this is what you want to do, use the GNU Library General Public
License instead of this License.
F.2 GNU Free Documentation License
F.2
305
GNU Free Documentation License
Kopiert von http://www.gnu.org/copyleft/.
Version 1.2, November 2002
c
Copyright 2000,2001,2002
Free Software Foundation, Inc.
59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
Everyone is permitted to copy and distribute verbatim copies of this license
document, but changing it is not allowed.
Preamble
The purpose of this license is to make a manual, textbook, or other functional and useful document free in the sense of freedom: to assure everyone the
effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this license preserves for
the author and publisher a way to get credit for their work, while not being
considered responsible for modifications made by others.
This license is a kind of copyleft, which means that derivative works of
the document must themselves be free in the same sense. It complements
the GNU General Public License, which is a copyleft license designed for free
software.
We have designed this license in order to use it for manuals for free software, because free software needs free documentation: a free program should
come with manuals providing the same freedoms that the software does. But
this license is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed
book. We recommend this license principally for works whose purpose is instruction or reference.
1. APPLICABILITY AND DEFINITIONS
This license applies to any manual or other work, in any medium, that
contains a notice placed by the copyright holder saying it can be distributed
under the terms of this license. Such a notice grants a world-wide, royalty-free
license, unlimited in duration, to use that work under the conditions stated
herein. The Document, below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as you. You accept the license
if you copy, modify or distribute the work in a way requiring permission under
copyright law.
A Modified Version of the Document means any work containing the
Document or a portion of it, either copied verbatim, or with modifications
and/or translated into another language.
A Secondary Section is a named appendix or a front-matter section of
the Document that deals exclusively with the relationship of the publishers or
306
F GNU Lizenzen
authors of the Document to the Document’s overall subject (or to related matters) and contains nothing that could fall directly within that overall subject.
(Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter
of historical connection with the subject or with related matters, or of legal,
commercial, philosophical, ethical or political position regarding them.
The Invariant Sections are certain Secondary Sections whose titles are
designated, as being those of Invariant Sections, in the notice that says that
the Document is released under this license. If a section does not fit the above
definition of Secondary then it is not allowed to be designated as Invariant.
The Document may contain zero Invariant Sections. If the Document does not
identify any Invariant Sections then there are none.
The Cover Texts are certain short passages of text that are listed, as
Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this license. A Front-Cover Text may be at most 5
words, and a Back-Cover Text may be at most 25 words.
A Transparent copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public,
that is suitable for revising the Document straightforwardly with generic text
editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to
text formatters or for automatic translation to a variety of formats suitable
for input to text formatters. A copy made in an otherwise Transparent file
format whose markup, or absence of markup, has been arranged to thwart or
discourage subsequent modification by readers is not Transparent. An image
format is not Transparent if used for any substantial amount of text. A copy
that is not Transparent is called Opaque.
Examples of suitable formats for Transparent copies include plain ASCII
without markup, Texinfo input format, LaTeX input format, SGML or XML
using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent
image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors,
SGML or XML for which the DTD and/or processing tools are not generally
available, and the machine-generated HTML, PostScript or PDF produced by
some word processors for output purposes only.
The Title Page means, for a printed book, the title page itself, plus such
following pages as are needed to hold, legibly, the material this license requires to appear in the title page. For works in formats which do not have any
title page as such, Title Pagemeans the text near the most prominent appearance of the work’s title, preceding the beginning of the body of the text.
A section Entitled XYZ means a named subunit of the Document whose
title either is precisely XYZ or contains XYZ in parentheses following text that
translates XYZ in another language. (Here XYZ stands for a specific section
name mentioned below, such as Acknowledgements, Dedications, Endorsements, or History.) To Preserve the Title of such a section when you
F.2 GNU Free Documentation License
307
modify the Document means that it remains a section Entitled XYZ according
to this definition.
The Document may include Warranty Disclaimers next to the notice which
states that this license applies to the Document. These Warranty Disclaimers
are considered to be included by reference in this license, but only as regards
disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this license.
2. VERBATIM COPYING
You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this license, the copyright notices, and the license notice saying this license applies to the Document are
reproduced in all copies, and that you add no other conditions whatsoever to
those of this license. You may not use technical measures to obstruct or control
the reading or further copying of the copies you make or distribute. However,
you may accept compensation in exchange for copies. If you distribute a large
enough number of copies you must also follow the conditions in section 3.
You may also lend copies, under the same conditions stated above, and you
may publicly display copies.
3. COPYING IN QUANTITY
If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document’s
license notice requires Cover Texts, you must enclose the copies in covers that
carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front
cover, and Back-Cover Texts on the back cover. Both covers must also clearly
and legibly identify you as the publisher of these copies. The front cover must
present the full title with all words of the title equally prominent and visible.
You may add other material on the covers in addition. Copying with changes
limited to the covers, as long as they preserve the title of the Document and
satisfy these conditions, can be treated as verbatim copying in other respects.
If the required texts for either cover are too voluminous to fit legibly, you
should put the first ones listed (as many as fit reasonably) on the actual cover,
and continue the rest onto adjacent pages.
If you publish or distribute Opaque copies of the Document numbering
more than 100, you must either include a machine-readable Transparent
copy along with each Opaque copy, or state in or with each Opaque copy
a computer-network location from which the general network-using public
has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the
latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will
remain thus accessible at the stated location until at least one year after the
last time you distribute an Opaque copy (directly or through your agents or
retailers) of that edition to the public.
308
F GNU Lizenzen
It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a
chance to provide you with an updated version of the Document.
4. MODIFICATIONS
You may copy and distribute a Modified Version of the Document under
the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this license, with the Modified Version filling
the role of the Document, thus licensing distribution and modification of the
Modified Version to whoever possesses a copy of it. In addition, you must do
these things in the Modified Version:
A. Use in the Title Page (and on the covers, if any) a title distinct from that
of the Document, and from those of previous versions (which should, if
there were any, be listed in the History section of the Document). You
may use the same title as a previous version if the original publisher of
that version gives permission.
B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version,
together with at least five of the principal authors of the Document (all
of its principal authors, if it has fewer than five), unless they release you
from this requirement.
C. State on the Title page the name of the publisher of the Modified Version,
as the publisher.
D. Preserve all the copyright notices of the Document.
E. Add an appropriate copyright notice for your modifications adjacent to
the other copyright notices.
F. Include, immediately after the copyright notices, a license notice giving
the public permission to use the Modified Version under the terms of this
license, in the form shown in the Addendum below.
G. Preserve in that license notice the full lists of Invariant Sections and
required Cover Texts given in the Document’s license notice.
H. Include an unaltered copy of this license.
I. Preserve the section entitled History, Preserve its title, and add to it
an item stating at least the title, year, new authors, and publisher of the
Modified Version as given on the Title Page. If there is no section entitled
History in the Document, create one stating the title, year, authors, and
publisher of the Document as given on its Title Page, then add an item
describing the Modified Version as stated in the previous sentence.
J. Preserve the network location, if any, given in the Document for public
access to a Transparent copy of the Document, and likewise the network
locations given in the Document for previous versions it was based on.
F.2 GNU Free Documentation License
309
These may be placed in the History section. You may omit a network
location for a work that was published at least four years before the
Document itself, or if the original publisher of the version it refers to
gives permission.
K. For any section entitled Acknowledgements or Dedications, Preserve the
title of the section, and preserve in the section all the substance and tone
of each of the contributor acknowledgements and/or dedications given
therein.
L. Preserve all the Invariant Sections of the Document, unaltered in their
text and in their titles. Section numbers or the equivalent are not considered part of the section titles.
M. Delete any section entitled Endorsements. Such a section may not be
included in the Modified Version.
N. Do not retitle any existing section to be entitled Endorsements or to conflict in title with any Invariant Section.
O. Preserve any Warranty Disclaimers.
If the Modified Version includes new front-matter sections or appendices
that qualify as Secondary Sections and contain no material copied from the
Document, you may at your option designate some or all of these sections as
invariant. To do this, add their titles to the list of Invariant Sections in the
Modified Version’s license notice. These titles must be distinct from any other
section titles.
You may add a section entitled Endorsements, provided it contains nothing
but endorsements of your Modified Version by various parties – for example,
statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.
You may add a passage of up to five words as a Front-Cover Text, and a
passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover
Texts in the Modified Version. Only one passage of Front-Cover Text and one
of Back-Cover Text may be added by (or through arrangements made by) any
one entity. If the Document already includes a cover text for the same cover,
previously added by you or by arrangement made by the same entity you are
acting on behalf of, you may not add another; but you may replace the old one,
on explicit permission from the previous publisher that added the old one.
The author(s) and publisher(s) of the Document do not by this license give
permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.
5. COMBINING DOCUMENTS
You may combine the Document with other documents released under this
license, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all
of the original documents, unmodified, and list them all as Invariant Sections
310
F GNU Lizenzen
of your combined work in its license notice, and that you preserve all their
Warranty Disclaimers.
The combined work need only contain one copy of this license, and multiple
identical Invariant Sections may be replaced with a single copy. If there are
multiple Invariant Sections with the same name but different contents, make
the title of each such section unique by adding at the end of it, in parentheses,
the name of the original author or publisher of that section if known, or else a
unique number. Make the same adjustment to the section titles in the list of
Invariant Sections in the license notice of the combined work.
In the combination, you must combine any sections entitled History in
the various original documents, forming one section entitled History; likewise
combine any sections entitled Acknowledgements, and any sections entitled
Dedications. You must delete all sections entitled Endorsements.
6. COLLECTIONS OF DOCUMENTS
You may make a collection consisting of the Document and other documents released under this license, and replace the individual copies of this
license in the various documents with a single copy that is included in the collection, provided that you follow the rules of this license for verbatim copying
of each of the documents in all other respects.
You may extract a single document from such a collection, and distribute it
individually under this license, provided you insert a copy of this license into
the extracted document, and follow this license in all other respects regarding
verbatim copying of that document.
7. AGGREGATION WITH INDEPENDENT
WORKS
A compilation of the Document or its derivatives with other separate and
independent documents or works, in or on a volume of a storage or distribution
medium, is called an aggregate if the copyright resulting from the compilation
is not used to limit the legal rights of the compilation’s users beyond what the
individual works permit. When the Document is included in an aggregate,
this license does not apply to the other works in the aggregate which are not
themselves derivative works of the Document.
If the Cover Text requirement of section 3 is applicable to these copies
of the Document, then if the Document is less than one half of the entire
aggregate, the Document’s Cover Texts may be placed on covers that bracket
the Document within the aggregate, or the electronic equivalent of covers if
the Document is in electronic form. Otherwise they must appear on printed
covers that bracket the whole aggregate.
8. TRANSLATION
F.2 GNU Free Documentation License
311
Translation is considered a kind of modification, so you may distribute
translations of the Document under the terms of section 4. Replacing Invariant Sections with translations requires special permission from their copyright holders, but you may include translations of some or all Invariant Sections in addition to the original versions of these Invariant Sections. You may
include a translation of this license, and all the license notices in the Document, and any Warranty Disclaimers, provided that you also include the original English version of this license and the original versions of those notices
and disclaimers. In case of a disagreement between the translation and the
original version of this license or a notice or disclaimer, the original version
will prevail.
If a section in the Document is entitled Acknowledgements, Dedications,
or History, the requirement (section 4) to Preserve its title (section 1) will
typically require changing the actual title.
9. TERMINATION
You may not copy, modify, sublicense, or distribute the Document except as
expressly provided for under this license. Any other attempt to copy, modify,
sublicense or distribute the Document is void, and will automatically terminate your rights under this license. However, parties who have received copies,
or rights, from you under this license will not have their licenses terminated
so long as such parties remain in full compliance.
10. FUTURE REVISIONS OF THIS LICENSE
The Free Software Foundation may publish new, revised versions of the
GNU Free Documentation License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to address
new problems or concerns. See http://www.gnu.org/copyleft/.
Each version of the license is given a distinguishing version number. If
the Document specifies that a particular numbered version of this license or
any later version applies to it, you have the option of following the terms and
conditions either of that specified version or of any later version that has been
published (not as a draft) by the Free Software Foundation. If the Document
does not specify a version number of this license, you may choose any version
ever published (not as a draft) by the Free Software Foundation.
ADDENDUM: How to use this license for your
documents
To use this license in a document you have written, include a copy of the
license in the Document and put the following copyright and license notices
just after the title page:
312
F GNU Lizenzen
c
Copyright YEAR
YOUR NAME. Permission is granted to copy,
distribute and/or modify this document under the terms of the
GNU Free Documentation License, Version 1.2 or any later version
published by the Free Software Foundation; with no Invariant Sections, no Front-Cover Texts, and no Back-Cover Texts. A copy of the
license is included in the section entitled GNU Free Documentation
License.
If you have Invariant Sections, Front-Cover Texts and Back-Cover Texts,
replace the with...Texts. line with this:
with the Invariant Sections being LIST THEIR TITLES, with the
Front-Cover Texts being LIST, and with the Back-Cover Texts
being LIST.
If you have Invariant Sections without Cover Texts, or some other combination of the three, merge those two alternatives to suit the situation.
If your document contains nontrivial examples of program code, we recommend releasing these examples in parallel under your choice of free software
license, such as the GNU General Public License, to permit their use in free
software.
G
Zeittafel
¨
Ausfuhrlichere
Angaben sind den im Anhang ?? Zum Weiterlesen in Abschnitt
¨
Geschichte auf S. 336 aufgefuhrten
Werken zu entnehmen. Die meisten Er¨
rungenschaften entwickelten sich uber
manchmal lange Zeitspannen, so dass
vor viele Jahreszahlen um etwa zu setzen ist.
-10E8
-2000
-400
20
600
1200
1550
1617
1623
1642
1674
1714
1801
1821
1840
1847
1861
1873
Der beliebte Tyrannosaurus hatte zwei Finger an jeder Hand
¨
und rechnete vermutlich im Dualsystem, wenn uberhaupt.
¨ besondere Aufgaben ein
Die Babylonier verwenden fur
gemischtes Stellenwertsystem zur Basis 60.
¨
¨
In China werden Zahlst
abchen
zum Rechnen verwendet.
¨
¨
In der Bergpredigt wird das Binarsystem
erwahnt
(Matth. 5, 37).
Die R¨omer schieben Rechensteinchen (calculi).
¨
Die Inder entwickeln das heute ubliche
reine Stellenwertsystem,
¨
die Null ist jedoch alter.
Etwa gleichzeitig entwickeln die Mayas
in Mittelamerika ein Stellenwertsystem zur Basis 20.
¨ die
L EONARDO VON P ISA, genannt F IBONACCI, setzt sich fur
¨
Einfuhrung
des indisch-arabischen Systems im Abendland ein.
¨
Die europaischen
Rechenmeister verwenden sowohl die r¨omische
wie die indisch-arabische Schreibweise.
J OHN N APIER erfindet die Rechenknochen (Napier’s Bones).
¨
Erste mechanische Rechenmaschine mit Zehnerubertragung
¨
und Multiplikation, von W ILHELM S CHICKARD, Tubingen.
¨ kaufmannische
¨
Rechenmaschine von B LAISE PASCAL, Paris fur
Rechnungen seines Vaters.
G OTTFRIED W ILHELM L EIBNIZ baut eine mechanische
¨ die vier Grundrechenarten und befaßt sich
Rechenmaschine fur
mit der dualen Darstellung von Zahlen. In der Folgezeit
technische Verbesserungen an vielen Stellen in Europa.
¨ ein Patent auf eine Schreibmaschine.
H ENRY M ILL erhalt
J OSEPH M ARIE J ACQUARD erfindet die Lochkarte und
¨
steuert Webstuhle
damit.
C HARLES B ABBAGE stellt der Royal Astronomical Society
eine programmierbare mechanische Rechenmaschine vor, die
jedoch keinen wirtschaftlichen Erfolg hat. Er denkt auch an
das Spielen von Schach oder Tic-tac-toe auf Maschinen.
S AMUEL F INLEY B REEZE M ORSE entwickelt einen aus zwei
Zeichen plus Pausen bestehenden Telegrafencode, der die
¨
Buchstaben entsprechend ihrer Haufigkeit
codiert.
G EORGE B OOLE entwickelt die symbolische Logik.
J OHANN P HILIPP R EIS erfindet das Telephon.
E LIPHALET R EMINGTON and Sons, NY, stellen außer Gewehren
313
314
1876
1877
1885
1890
1894
1895
1896
1898
1900
1910
1918
1924
1930
1932
1937
1938
1939
1941
1942
1943
G Zeittafel
¨
und Nahmaschinen
auch Schreibmaschinen her. 1886 trennen sie sich
¨
vom Schreibmaschinenbereich, der spater
den Namen Remington Rand
¨
¨
und noch spater
den Namen Sperry Rand tragt.
¨ ein Patent auf sein Telefon.
A LEXANDER G RAHAM B ELL erhalt
¨
Grundung
der Bell Telephone Company.
Aus Bell Telephone Co. wird American Telephone + Telegraph Co.
H ERMAN H OLLERITH erfindet die Lochkartenmaschine und
¨
setzt sie bei einer Volkszahlung
in den USA ein. Das ist der
Anfang von IBM.
¨
O TTO L UEGERs Lexikon der gesamten Technik fuhrt
unter dem Stichwort Elektrizitat
¨ als Halbleiter Aether,
Alkohol, Holz und Papier auf.
¨
Erste Ubertragung
mittels Radio (wer, wo?).
¨
¨
Grundung
der Tabulating Machine Company, der spateren
IBM.
VALDEMAR P OULSEN erfindet die magnetische Aufzeichnung
von T¨onen (Telegraphon).
¨
01. Januar 1900 00:00:00 GMT Nullpunkt der gegenwartigen
¨ (eine NTP-Ara
¨ umfaßt 136 Jahre).
NTP-Ara
¨
Grundung
der Deutschen Hollerith Maschinen GmbH, Berlin,
¨
der Vorlauferin
der IBM Deutschland.
¨
Das Enigma-Verschlusselungsverfahren
entwickelt.
Aus der Tabulating Machine Company von H ERMAN H OLLERITH,
¨
spater
in Computing-Tabulating-Recording Company umbenannt,
wird die International Business Machines (IBM).
E UGEN N ESPER schreibt in seinem Buch Der Radio-Amateur,
jeder schlechte Kontakt habe gleichrichtende Eigenschaften,
ein Golddraht auf einem Siliziumkristall sei aber besonders gut
als Kristalldetektor geeignet.
E DWIN L INK baut – anstatt Pianos und Orgeln wie sein Vater –
¨
¨ Ubungs¨
einen mechanischen Flugsimulator fur
und Vergnugungszwecke
¨ ein Patent darauf. Der Link-Trainer erlangt Verbreitung.
und erhalt
¨ mit dem Namen Magnetophon.
Die Firma AEG baut das erste Tonbandgerat
¨
Die Bander
dazu liefert die BASF.
A LAN T URING ver¨offentlicht sein Computermodell.
K ONRAD Z USE stellt den programmgesteuerten Rechner Z 1 fertig.
¨ Addiermaschine von J OHN V INCENT A TANASOFF
Elektronische binare
und C LIFFORD B ERRY, Iowa State University, zur L¨osung linearer
Gleichungssysteme.
K ONRAD Z USE stellt die Z 2 fertig.
¨
Grundung
der Firma Hewlett-Packard, Palo Alto, Kalifornien
durch W ILLIAM H EWLETT und D AVID PACKARD. Ihr erstes
¨ Tonfrequenzen (Meßtechnik).
Produkt ist ein Oszillator fur
K ONRAD Z USE stellt die Z3 fertig.
Die Purdue University beginnt mit der Halbleiterforschung und
untersucht Germaniumkristalle.
Der Computer Colossus, Bletchley Park/Buckinghamshire UK,
315
1944
1945
1946
1948
1949
1952
1953
1954
1955
1956
1957
1958
¨
¨
entschlusselt
deutsche Militarnachrichten
(Enigma).
Die Zuse Z4 wird fertig (2200 Relais, mechanischer Speicher).
Sie arbeitet von 1950 bis 1960 in der Schweiz.
An der Harvard University bauen H OWARD A IKEN und G RACE H OPPER
¨
die Mark I in Relaistechnik. Die Maschine lauft
bis 1959.
¨ die erste h¨ohere
K ONRAD Z USE entwickelt den Plankalkul,
Programmiersprache. W ILLIAM B RADFORD S HOCKLEY startet
ein Forschungsprojekt zur Halbleiterphysik in den Bell-Labs.
VANNEVAR B USH entwickelt ein System zur Informationsspeicherung
und -suche, das auf Mikrofilmen beruht.
J OHN VON N EUMANN ver¨offentlicht sein Computerkonzept.
J OHN P RESPER E CKERT und J OHN W ILLIAM M AUCHLY bauen in
den USA die ENIAC (Electronic Numerical Integrator and
¨ 18000 Vakuumr¨ohren,
Calculator). Die ENIAC rechnet dezimal, enthalt
¨ eine Addition
wiegt 30 t, ist 5,5 m hoch und 24 m lang, braucht fur
0,2 ms, ist an der Entwicklung der Wasserstoffbombe beteiligt und
arbeitet bis 1955. Sie ist der Urahne der UNIVAC.
¨
C LAUDE E LWOOD S HANNON begrundet
die Informationstheorie.
J OHN B ARDEEN, WALTER H OUSER B RATTAIN und
W ILLIAM B RADFORD S HOCKLEY entwickeln in den Bell-Labs
¨
den Transistor, der 10 Jahre spater
die Vakuumr¨ohre abl¨ost.
Erster Schachcomputer: Manchester MADM. Das Wort Bit kreiert.
IBM bringt ihre erste elektronische Datenverarbeitungsanlage, die IBM 701, heraus.
IBM baut die erste Magnetbandmaschine zur Datenspeicherung (726).
Remington-Rand bringt die erste UNIVAC heraus, IBM die 650.
¨
Silizium beginnt, das Germanium zu verdrangen.
IBM entwickelt die erste h¨ohere Programmiersprache, die
Verbreitung erlangt: FORTRAN (Formula Translator) und verwendet
Transistoren in ihren Computern.
K ONRAD Z USE baut die Z 22. Sie kommt 1958 auf den
¨ verkauft. B ARDEEN,
Markt. Bis 1961 werden 50 Stuck
¨ Physik.
B RATTAIN und S HOCKLEY erhalten den Nobelpreis fur
¨ den
IBM stellt die erste Festplatte vor (IBM 350 Disk File fur
¨ 5 MByte, groß wie ein Schrank,
Computer RAMAC 305), Kapazitat
Gewicht 1 to, bestehend aus 50 Scheiben zu 24 Zoll, 50.000 US-$.
¨ eine Multiplikation 0,12 ms.
Die IBM 709 braucht fur
Weltweit arbeiten rund 1300 Computer.
¨
Seminar von Prof. J OHANNES W EISSINGER uber
Programmgesteuerte Rechenmaschinen im SS 1957 der TH Karlsruhe.
¨ den Begriff Informatik.
K ARL S TEINBUCH (Firma SEL) pragt
Erster Satellit (Sputnik, Sowjetunion) kreist um die Erde.
¨
Als eine Reaktion auf den Sputnik grundet
das us-amerikanische
Verteidigungsministerium (DoD) die Denkfabrik Advanced Research
¨
Projects Agency (ARPA), die spater
das ARPA-Net aufbaut.
¨ den Begriff Artificial Intelligence.
M ARVIN L EE M INSKY pragt
316
1959
1960
1961
1962
1963
1964
1965
G Zeittafel
¨ ihren ersten Computer, eine ZUSE Z 22.
Die TH Karlsruhe erhalt
Die Maschine verwendet 400 Vakuumr¨ohren und wiegt 1 t. Der
Arbeitsspeicher faßt 16 W¨orter zu 38 Bits, d. h. 76 Byte. Der
Massenspeicher, eine Magnettrommel, faßt rund 40 KByte. Eine
Gleitkommaoperation dauert 70 ms. Das System versteht nur
¨
Maschinensprache (Freiburger Code). Es lauft
bis 1972.
¨ Priv.-Doz. K ARL N ICKEL (Institut fur
¨ Angew.
Im SS 1958 halt
Mathematik) eine Vorlesung Programmieren mathematischer und
technischer Probleme fur
¨ die elektronische Rechenmaschine Z 22.
Die Programmiersprache ALGOL 58 kommt heraus.
Bei Texas Instruments baut J ACK S T. C LAIR K ILBY den ersten IC;
¨ er dafur
¨ den Nobelpreis fur
¨ Physik.
im Jahr 2000 erhalt
¨ Priv.-Doz. K ARL N ICKEL erstmals die
Im SS 1959 halt
Vorlesung Programmieren I, im WS 1959/60 die Vorlesung
Programmieren II. Erstes Werk von Hewlett-Packard in
Deutschland. Siemens baut die Siemens 2002.
Programmieren steht noch in keinem Studienplan, sondern
¨
ist freiwillig. Die Karlsruher Z 22 lauft
Tag und Nacht. Die
Programmiersprache COBOL wird ver¨offentlicht. Ein Computer¨
spiel namens Spacewar lauft
auf einer DEC PDP-1 im MIT.
A LAN S HUGART entwickelt ein Verfahren zur Aufzeichnung von
Daten auf einer magnetisch beschichteten Scheibe.
¨ eine Zuse Z23, die mit
Die TH Karlsruhe erhalt
2400 Transistoren arbeitet. Ihr Hauptspeicher faßt 240 W¨orter
zu 40 Bits. Eine Gleitkommaoperation dauert 15 ms. Außer
Maschinensprache versteht sie ALGOL. Weltweit arbeiten etwa
7300 Computer.
¨ eine(n) SEL ER 56, die (der) bis 1968 lauft.
¨
Die TH Karlsruhe erhalt
¨ fur
¨ Informatik
An der Purdue University wird die erste Fakultat
¨
(Department of Computer Science) gegrundet.
Texas Instruments
und Fairchild nehmen die Serienproduktion von ICs (Chips) auf.
J OSEPH C ARL R OBNETT L ICKLIDER hat zwei Visionen: den interaktiven
Computer und das galaktische Netz (wenn schon, denn schon). Er wird
Direktor in der ARPA und geht an die Verwirklichung seiner Visionen.
Weltweit arbeiten etwa 16.500 Computer.
¨
Erster geostationarer
Satellit (Syncom).
I VAN E. S UTHERLAND entwickelt in seiner Doktorarbeit am MIT
das Sketchpad, einen grafischen Bildschirm mit Lichtgriffel, und
wird damit zum Vater der Computergrafik.
Die Programmiersprache BASIC erscheint.
D OUGLAS C ARL E NGELBART erfindet am Stanford Research Institute
die Maus und die Fenstertechnik.
IBM legt das Byte zu 8 Bits fest (IBM 360).
¨ auf 0,5 cm2 10 Transistoren.
Ein Chip enthalt
Beginn des Betriebssystems MULTICS bei MIT, Bell und
General Electric.
317
1966
1967
1968
1969
1970
1971
1972
1973
¨ eine Electrologica X 8, die bis
Die TH Karlsruhe erhalt
¨
1973 betrieben wird. Grundung
des Karlsruher Rechenzentrums.
Hewlett-Packard steigt in die Computerei ein (HP 2116 A).
Erster elektronischer Taschenrechner (Texas Instruments).
¨ wissenschaftliche Forschung wird
Beim Bundesministerium fur
¨ Datenverarbeitung gebildet.
ein Fachbeirat fur
I VAN E. S UTHERLAND entwickelt an der Harvard University einen
Helm mit binokularem Display und bringt damit die Virtual Reality
¨ voran.
ein gutes Stuck
Am 26. Februar entscheiden sich maßgebende Vertreter der
Computerwissenschaft im deutschsprachigen Raum im Anschluss an
¨ die Bezeichnung
ein internationales Kolloquium in Dresden fur
Informatik nach franz¨osischem Beispiel.
Die Programmiersprache PASCAL kommt heraus. Die Firma Intel
¨
gegrundet.
Hewlett-Packard baut den ersten wissenschaftlichen
programmierbaren Tischrechner (HP 9100 A).
¨ Informatik
In Karlsruhe wird am 1. Januar das Institut fur
¨
gegrundet,
Direktor K ARL N ICKEL. Im WS 1969/70 beginnt in
Karlsruhe die Informatik als Vollstudium mit 91 Erstsemestern.
¨
¨ Informatik (GI) in Bonn.
Grundung
der Gesellschaft fur
In den Bell Labs UNIX in Assembler auf einer DEC PDP 7.
Beginn des ARPANET-Projektes und der TCP/IP-Protokolle,
erste Teilnehmer U. of California at Los Angeles, Stanford Research
Institute, U. of California at Santa Barbara und U. of Utah,
allesamt mit DEC PDP-10 Maschinen.
RFC 0001: Host Software, von S TEVE C ROCKER.
¨ Karlsruhe erhalt
¨ eine UNIVAC 1108,
Die Universitat
¨
die bis 1987 lauft
und damit den hiesigen Rekord an Betriebsjahren
¨ Preis 23 MDM, 3 Zentraleinheiten, 256 Kilo-W¨orter zu
halt.
je 36 Bits Arbeitsspeicher, 20 Bildschirme.
¨ fur
¨ Informatik wird gegrundet.
¨
Die Karlsruher Fakultat
Am 01. Januar 1970 00:00:00 GMT beginnt die UNIX-Uhr zu laufen.
UNIX auf C umgeschrieben, erster Mikroprozessor (Intel 4004).
A LAN S HUGART entwickelt bei IBM die Floppy Disk.
Die Internet-Protokolle ftp (RFC 114) und telnet (RFC 137) werden
vorgeschlagen und diskutiert.
IBM entwickelt das Konzept des virtuellen Speichers und
stellt die 8-Zoll-Floppy-Disk vor. Xerox (R OBERT M ETCALFE),
DEC und Intel entwickeln den Ethernet-Standard.
¨
Das ARPANET wird der Offentlichkeit
vorgestellt.
Ein Student namens S TEPHAN G. W OZNIAK l¨otet sich einen
¨
Computer zusammen, der den Smoke-Test nicht ubersteht.
In der Bundesrepublik arbeiten rund 8.200 Computer.
Erster wissenschaftlicher Taschenrechner (Hewlett-Packard 35).
Erste internationale Teilnehmer am ARPANET: NORSAR
(Norwegian Seismic Array), Norwegen und U. College of London.
318
1974
1975
1976
1977
1978
1979
1980
1981
1982
G Zeittafel
Der erste programmierbare Taschenrechner kommt auf den
Markt (Hewlett-Packard 65), Preis 2500 DM.
UNIX wird ver¨offentlicht (Version 6), Beginn der BSD-Entwicklung.
¨
Die Zeitschrift Byte wird gegrundet.
¨
Erste, maßig
erfolgreiche Personal Computer (Xerox, Altair).
¨
Die Firma Microsoft gegrundet.
¨
S TEVEN P. J OBS und S TEPHAN G. W OZNIAK grunden
die Firma Apple und bauen den Apple I. Er kostet 666,66 Dollar.
A LAN S HUGART stellt die 5,25-Zoll-Diskette vor.
Die nichtprozedurale Datenbanksprache SQL – entwickelt von
E DGAR F. C ODD bei IBM – wird ver¨offentlicht.
R OBERT K AHN und V INTON G. C ERF ver¨offentlichen das
Konzept von TCP/IP, anfangs Kahn-Cerf-Protokolle genannt.
In der Bundesrepublik arbeiten rund 170.000 Computer.
¨
Der Commodore PET 2001 – ein Vorlaufer
des C64 – kommt heraus,
4 bis 32 kbyte Arbeitsspeicher, Bildschirm 25 Zeilen zu 40 Zeichen.
¨ den Apple II,
Erste Tabellenkalkulation: Visicalc, fur
von D AN B RICKLIN und B OB F RANKSTON, Harvard.
Erste Fassung von TeX (D ONALD E RVIN K NUTH) ver¨offentlicht.
Das Network Time Protocol (NTP) wird in Gebrauch genommen.
¨
Faxdienst in Deutschland eingefuhrt.
Beginn des Usenet in der Duke University und der University of
North Carolina auf der Basis von uucp-Verbindungen.
¨
Die Zusammenarbeit von Apple mit Rank Xerox fuhrt
zur Apple
¨ den Macintosh.
Lisa, ein Mißerfolg, aber der Wegbereiter fur
¨
Plattenherstellerfirma Seagate gegrundet.
¨
Grundung der Satelliten-Kommunikations-Firma Inmarsat.
B JARNE S TROUSTRUP beginnt mit der Entwicklung von C++.
Programmiersprache Ada ver¨offentlicht.
¨ Intel 8086/8088 von Fa. Seattle Computer
Betriebssystem DOS fur
¨
Products entwickelt, spater
von Microsoft erworben.
Erster Jugendprogrammier-Wettbewerb der GI.
¨ rund 500 DM.
Erster Home-Computer: Sinclair ZX-80, fur
¨
Sony fuhrt
die 3,5-Zoll-Diskette ein. In den Folgejahren entwickeln
andere Firmen auch Disketten mit Durchmessern von 3 bis 4 Zoll.
¨ PCs, heraus.
Microsoft bringt Xenix, ein UNIX fur
¨ Karlsruhe erhalt
¨ eine Siemens 7881 als
Die Universitat
zentralen Rechner. IBM bringt in den USA den IBM-PC heraus
mit MS-DOS (PC-DOS 1.0) als wichtigstem Betriebssystem.
¨
In Berlin wird der Chaos Computer Club gegrundet.
¨
Xanadu-Projekt von T ED N ELSON, ein Vorlaufer
des WWW.
¨
¨
Die Firma SUN Microsystems wird gegrundet,
entscheidet sich fur
UNIX und baut die ersten Workstations.
¨
J IM C LARK grundet
Silicon Graphics, Inc.
Beginn des EuNETs, einer der ersten deutschen Internet-Provider,
¨ Dortmund.
an der Universitat
319
1983
1984
1985
1986
1987
1988
¨ das Wort Cyberspace.
W ILLIAM G IBSON pragt
¨
¨ MotorradM ORTON H EILIG prasentiert
einen Spielautomaten fur
¨
¨
und Auto-Simulationen mit Stereotonfilm, Geblase,
Geruchen
und
vibrierenden Sitzen, echt multimedial, aber erfolglos, da zu teuer.
¨ Karlsruhe erhalt
¨ einen Vektorrechner Cyber 205
Die Universitat
und eine Siemens 7865. Die Cyber leistet 400 Mio. Flops.
Beginn des Lokalen Informatiknetzes Karlsruhe (LINK), seit 1984
¨ fur
¨ Informatik der Universitat
¨ Karlsruhe.
Xlink, in der Fakultat
IBM bringt den PC auf den deutschen Markt.
UNIX kommt als System V von AT&T in den Handel,
die erste Ausgabe der Zeitschrift Computertechnik (c’t) erscheint
¨
(Nr. 12/83 vom Oktober 1983), Grundung
der X/Open-Gruppe.
MS-DOS 2.0 (PC-DOS 2.0) und Novell Netware kommen heraus.
¨
Microsoft Windows wird angekundigt.
Das ARPAnet wechselt von NCP auf TCP/IP.
Der erste Apple Macintosh (128K) und der Hewlett-Packard Thinkjet,
der erste Tintenstrahldrucker, kommen auf den Markt.
¨
GNU-Projekt von R ICHARD M ATTHEW S TALLMAN gegrundet.
Der IBM PC/AT mit Prozessor Intel 80 286 und MS-DOS 3.0
kommen heraus. Siemens steigt in UNIX ein.
¨ Karlsruhe wird Email-Relay fur
¨ Deutschland
Die Universitat
zum Computer Science Net (CSNet) in den USA. Als erste Mail
¨ Prof. Z ORN, U. Karlsruhe, einen Gruß vom CSNet.
erhalt
Entwicklung des X Window Systems am MIT.
MS-Windows 1.0, IBM 3090 und IBM Token Ring Netz.
¨ Karlsruhe stellt als erstes deutsches
XLink an der Universitat
Netz eine Verbindung zum nordamerikanischen ARPA-Net her.
Hewlett-Packard bringt den ersten Laserjet-Drucker heraus.
Weltweit etwa eine halbe Million UNIX-Systeme und
3000 o¨ ffentliche Datenbanken.
Mit dem Computer-Investitionsprogramm des Bundes und der
¨
Lander
(CIP) kommen mehrere HP 9000/550 unter UNIX an
¨ Karlsruhe.
die Universitat
¨ den IBM PC/AT
Microsoft XENIX (ein UNIX) fur
IBM bringt die PS/2-Reihe unter MS-OS/2 heraus.
Weltweit mehr als 5 Millionen Apple Computer und etwa
100 Millionen PCs nach Vorbild von IBM.
Das MIT ver¨offentlicht das X Window System Version 11 (X11).
In Berkeley wird die RAID-Technologie entwickelt.
¨
Beginn des baden-wurttembergischen
BelWue-Netzes.
J ARKKO O IKARINEN, Finnland, entwickelt den IRC.
Das Karlsruher Campusnetz KARLA wird durch das Glasfasernetz
KLICK ersetzt. VBN-Strecke Karlsruhe - Stuttgart im BelWue-Netz.
Frankreich geht ans Internet (INRIA, Rocquencourt bei Paris).
¨
Grundung
der Open Software Foundation (OSF) und der UNIX
¨ PCs.
International Inc. MS-DOS 4.0 fur
320
1989
1990
1991
1992
1993
1994
1995
G Zeittafel
Ein Internet-Wurm namens Morris geht auf die Reise, darauf
¨
hin Grundung
des Computer Emergency Response Teams (CERT).
Erster Hoax (2400-baud-Modem-Hoax) im Internet, siehe CIAC.
¨ Datenfunk (Inmarsat-C).
Erstes landmobiles Satellitensystem fur
Das NFSNET l¨ost das ARPAnet als Backbone des Internet ab.
UNIX System V Release 4 vereinheitlicht System V, BSD und Xenix.
Im Rechenzentrum Karlsruhe l¨ost die IBM 3090 die
¨
Siemens 7881 ab. ISDN in Deutschland eingefuhrt.
Erster deutscher Internet-Direktanschluss via Xlink, Karlsruhe.
Zunehmende Vernetzung, Anschluß an weltweite Netze.
¨
Die Internet Society (ISOC) schatzt
das Internet auf 500.000 Knoten.
Computer-Kommunikation mittels E-Mail, Btx und Fax vom
Arbeitsplatz aus. Optische Speichermedien (CD-ROM, WORM).
WWW, HTTP und HTML von T IM B ERNERS -L EE und
R OBERT C AILLIAU am CERN in Genf entwickelt.
UNIX System V Version 4. Die mittlere Computerdichte in technisch
orientierten Instituten und Familien erreicht 1 pro Mitglied.
Das UNIX-System OSF/1 mit dem Mach-Kernel der Carnegie¨ kommt heraus.
Mellon-Universitat
17. Sep.: Anfang von LINUX (L INUS B ENEDICT T ORVALDS).
Erster WWW-Server in den USA: Stanford Linear Accelerator Center.
Der Vektorrechner im RZ Karlsruhe wird erweitert auf Typ S600/20.
¨ PCs. Anfange
¨
MS-DOS 5.0 fur
von Microsoft Windows NT.
IBM, Apple und Motorola kooperieren mit dem Ziel, einen
Power PC zu entwickeln.
¨ Karlsruhe nimmt den massiv parallelen
Die Universitat
Computer MasPar 1216A mit 16000 Prozessoren in Betrieb.
¨
¨
Novell ubernimmt
von AT&T die UNIX-Aktivitaten
(USL).
FORTRAN 90 verabschiedet. Eine Million Knoten im Internet.
Weltweit etwa 50 WWW-Server. Erster deutscher WWW-Server,
am DESY, Hamburg.
¨
MS-DOS Version 6.0. Microsoft kundigt
Windows-NT an.
DEC stellt PC mit Alpha-Prozessor vor, 150 MHz, 14.000 DM.
Novell tritt das Warenzeichen UNIX an die X/Open-Gruppe ab.
¨ das
M ARC A NDREESSEN, NCSA, schreibt einen WWW-Browser fur
X Window System mit der M¨oglichkeit, farbige Bilder darzustellen.
¨
I AN M URDOCK, Student an der Purdue University, grundet
das
Debian-Projekt. Gegen Jahresende Debian GNU/Linux Version 0.90.
Weltweit etwa 250 WWW-Server.
¨ Karlsruhe.
Das DE-NIC kommt ans Rechenzentrum der Universitat
Weltweit 10 Mio. installierte UNIX-Systeme prognostiziert.
Linux 1.0 ver¨offentlicht.
Das Internet umfaßt etwa 4 Mio. Knoten und 20 Mio. Benutzer.
Erste Spam-Mail (Canter + Siegel). Erste Banner-Werbung (Wired).
¨
M ARC A NDREESEN und J IM C LARK grunden
die Firma Netscape.
Kommerzielle Netze l¨osen in den USA das NFSNET als Backbone ab.
321
1996
1997
1998
1999
2000
¨
¨ Systeme
Die X/Open-Gruppe fuhrt
die Bezeichnung UNIX 95 fur
¨
ein, die der Single UNIX Specification genugen.
¨ Karlsruhe erm¨oglicht in Zusammenarbeit
Die Universitat
mit dem Oberschulamt nordbadischen Schulen den Zugang zum
¨
Internet. Ahnliche
Projekte werden auch an einigen anderen
¨
Hoch- und Fachhochschulen durchgefuhrt.
Weltweit etwa 50000 WWW-Server.
Die Programmiersprache JAVA wird von SUN ver¨offentlicht.
Erste Gedanken zum Gigabit-Ethernet.
Die Massen und Medien entdecken das Internet.
Debian GNU/Linux Version 1.1 (buzz) wird ver¨offentlicht, zum Jahresende
folgt Version 1.2 (rex).
FORTRAN 95 – eine revidierte Fassung von FORTRAN 90 – verabschiedet.
Die Open Software Foundation (OSF) und X/Open schließen sich zur
Open Group zusammen.
¨
100-Ethernet ist erschwinglich geworden, uber
das Gigabit-Ethernet
wird geredet. In Deutschland gibt es rund 20 Mio. PCs und
¨
1 Mio. Internetanschlusse
(Quelle: Fachverband Informationstechnik).
Debian GNU/Linux Version 1.3 (bo) wird freigegeben, rund 1000 Pakete.
Single UNIX Specification Version 2 im WWW ver¨offentlicht.
HTML 4.0 freigegeben.
¨
Compaq ubernimmt
die Digital Equipment Corporation (DEC).
¨
IBM bringt DOS 2000 heraus, Microsoft kundigt
Windows 2000 an.
Debian GNU/Linux Version 2.0 (hamm) wird freigegeben, 1500 Pakete.
KDE 1.0 ver¨offentlicht. 9-GB-Festplatten kosten 500 DM.
Gigabit-Ethernet-Standard IEEE 802.3z verabschiedet.
J ONATHAN B. P OSTEL, einer der Apostel des Internet und Autor
vieler RFCs, gestorben. Siehe RFC 2441: Working with Jon und
RFC 2468: I Remember IANA.
¨
¨
Das Y2K-Problem – die Jahrtausendwende – beschaftigt
die Gemuter,
¨
weil die Programmierer fruherer
Jahrzehnte mit den Bits knauserten.
Der RFC 2550 l¨ost auch gleich das Y10K-Problem.
Debian GNU/Linux Version 2.1 (slink) kommt heraus.
¨
Betreiber großer Suchmaschinen schatzen
die Anzahl der
WWW-Seiten weltweit auf 1 Milliarde.
¨ Stockholm.
L INUS B ENEDICT T ORVALDS wird Ehrendoktor der Universitat
Das Y2K-Problem hat sich praktisch nicht ausgewirkt.
¨
Den 29. Februar 2000 haben wir auch gut uberstanden,
einen Schalttag
nach einer Regel, die nur alle 400 Jahre angewendet wird.
Das W3-Consortium ver¨offentlicht das XForms Data Model.
Debian GNU/Linux Version 2.2 (potato) kommt heraus, 6500 Pakete.
¨
Microsoft Windows 2000 ist erhaltlich.
Ein Macro-Virus namens
¨ Aufregung – außerhalb der UNIX-Welt.
Love Letter sorgt fur
Der Intel Pentium kommt bei einer Taktfrequenz von 1,5 GHz an.
Zum Jahresende 2 Mio. Internet-Hosts in Deutschland (RIPE).
Es wird viel von Electronic Commerce geredet, aber die meisten Firmen
322
2001
2002
2004
2005
G Zeittafel
¨
sind damit uberfordert.
Oft reicht es nicht einmal zu einer
ordentlichen Webseite.
C LAUDE E LWOOD S HANNON verstorben, gilt als Erfinder des Bits.
¨
¨
¨
Die Einfuhrung
der Euro-Wahrung
fuhrt
zu einem neuen Zeichen
¨
in internationalen Zeichensatzen.
Debian GNU/Linux Version 3.0 (woody) wird als stabil freigegeben.
Die Distribution umfasst 8700 Pakete.
PCs werden zunehmend ohne Floppy-Laufwerk ausgeliefert.
Debian GNU/Linux Version 3.1 (sarge) wird als stabil freigegeben.
H
Zum Weiterlesen
¨ Werke, die wir noch lesen wollen, schon
Die Auswahl ist subjektiv und enthalt
gelesen haben oder sogar oft benutzen.
¨
1. Lexika, Glossare, W¨orterbucher
– Newsgruppen:
news.answers
de.etc.lists
news.lists
– RFC 1392 (FYI 18): Internet Users’ Glossary
ftp://ftp.nic.de/pub/rfc/rfc1392.txt
1993, 53 S.
– Duden Informatik
Dudenverlag, Mannheim, 1993, 800 S.
¨
Nachschlagewerk, sorgfaltig
gemacht, theorielastig,
Begriffe wie Ethernet, LAN, SQL, Internet fehlen.
¨
– Fachausdrucke
der Informationsverarbeitung Englisch – Deutsch,
Deutsch – Englisch
IBM Deutschland, Form-Nr. Q12-1044, 1698 S.
W¨orterbuch und Glossar
– IBM Terminology
http://www-3.ibm.com/ibm/terminology/
¨
W. Alex Abkurzungs-Liste
ABKLEX (Informatik, Telekommunikation)
http://www.ciw.uni-karlsruhe.de/abklex.html
http://www.ciw.uni-karlsruhe.de/abklex.pdf
¨
Rund 9000 Abkurzungen
aus Informatik und Telekommunikation
M. Broy, O. Spaniol Lexikon Informatik und Kommunikationstechnik
Springer, Berlin + Heidelberg, 1999, 863 S.
E. Kajan Information Technology Encyclopedia and Acronyms
Springer, Berlin + Heidelberg, 2002, 720 S.
E. S. Raymond The New Hacker’s Dictionary
The MIT Press, Cambridge, 1996, 547 S.
Siehe auch http://www.ciw.uni-karlsruhe.de/kopien/jargon/
Begriffe aus dem Netz, die nicht im Duden stehen
2. Informatik
– Newsgruppen:
comp.* (alles, was mit Computer Science zu tun hat, mehrere
hundert Untergruppen)
de.comp.* (dito, deutschsprachig)
alt.comp.*
323
324
H Zum Weiterlesen
W. Coy Aufbau und Arbeitsweise von Rechenanlagen
Vieweg, Braunschweig, 1992, 367 S.
Digitale Schaltungen, Rechnerarchitektur, Betriebssysteme am
Beispiel von UNIX
T. Flik, H. Liebig Mikroprozessortechnik
Springer, Berlin + Heidelberg, 1998, 585 S.
CISC, RISC, Systemaufbau, Assembler und C
W. K. Giloi Rechnerarchitektur
Springer, Berlin + Heidelberg, 1999, 488 S.
¨
G. Goos Vorlesungen uber
Informatik
Band 1: Grundlagen und funktionales Programmieren,
Springer, Berlin + Heidelberg, 1997, 394 S.
Band 2: Objektorientiertes Programmieren und Algorithmen,
Springer, Berlin + Heidelberg, 1999, 396 S.
Band 3: Berechenbarkeit, formale Sprachen, Spezifikationen,
Springer, Berlin + Heidelberg, 1997, 284 S.
Band 4: Paralleles Rechnen und nicht-analytische L¨osungsverfahren,
Springer, Berlin + Heidelberg, 1998, 292 S.
i44www.info.uni-karlsruhe.de/˜i44www/goos-buch.html
¨
D. E. Knuth The Art of Computer Programming, 3 Bande
Addison-Wesley, Boston,
¨
Klassiker, stellenweise mathematisch, 7 Bande
geplant,
Band 4 soll 2004 fertig sein, Band 5 im Jahr 2009, Homepage
des Meisters: www-cs-staff.stanford.edu/˜uno/index.html
W. Schiffmann, R. Schmitz Technische Informatik
Springer, Berlin + Heidelberg, 1993/94, 1. Teil Grundlagen der
digitalen Elektronik, 282 S.; 2. Teil Grundlagen der
Computertechnik, 283 S.
¨
K. W. Wagner Einfuhrung
in die Theoretische Informatik
Springer, Berlin + Heidelberg, 1994, 238 S.
¨ B OOLEsche
Grundlagen, Berechenbarkeit, Komplexitat,
Funktionen, Automaten, Grammatiken, Formale Sprachen
3. Algorithmen, Numerische Mathematik
– Newsgruppen:
sci.math.*
J. L. Bentley Programming Pearls
Addison-Wesley, Boston, 1999, 256 S.
Pfiffige Algorithmen und Programmierideen
¨
G. Engeln-Mullges,
F. Reutter Formelsammlung zur
Numerischen Mathematik mit C-Programmen
BI-Wissenschaftsverlag, Mannheim, 1990, 744 S.
Algorithmen und Formeln der Numerischen Mathematik
samt C-Programmen.
¨
G. Engeln-Mullges,
F. Uhlig Numerical Algorithms with C
Springer, Berlin + Heidelberg, 1996, 596 S.
325
D. E. Knuth Algorithmen
¨
(deutsche Ubersetzung
von Fundamental Algorithms)
Springer, Berlin + Heidelberg, 2004, 700 S.
K. Loudon Mastering Algorithms in C
O’Reilly, Sebastopol, 1999, 560 S.
T. Ottmann, P. Widmayer Algorithmen und Datenstrukturen
BI-Wissenschafts-Verlag, Mannheim, 1993, 755 S.
W. H. Press u. a. Numerical Recipes in C
Cambridge University Press, 1993, 994 S.
H. R. Schwarz Numerische Mathematik
Teubner, Stuttgart, 1993, 575 S.
R. Sedgewick Algorithmen in C
Addison-Wesley, Bonn, 1992, 742 S.
¨
¨
Erklarung
gebrauchlicher
Algorithmen und Umsetzung in C
R. Sedgewick Algorithmen in C++
Addison-Wesley, Bonn, 1992, 742 S.
J. Stoer, R. Bulirsch Numerische Mathematik
Springer, Berlin + Heidelberg, 1. Teil 1999, 378 S.,
2. Teil 2000, 375 S.
4. Betriebssysteme
– Newsgruppen:
comp.os.*
de.comp.os.*
L. Bic, A. C. Shaw Betriebssysteme
¨
Hanser, Munchen,
1990, 420 S.
Allgemeiner als Tanenbaum + Woodhull
A. S. Tanenbaum, A. S. Woodhull Operating Systems,
Design and Implementation
Prentice-Hall, London, 1997, 939 S.
¨
Einfuhrung
in Betriebssysteme am Beispiel von UNIX
A. S. Tanenbaum Modern Operating Systems
Prentice-Hall, London, 1992, 728 S.
Allgemeiner und moderner als vorstehendes Buch;
¨
erlautert
MS-DOS, UNIX, MACH und Amoeba
A. S. Tanenbaum Distributed Operating Systems
Prentice-Hall, London, 1994, 648 S.
H. Wettstein Systemarchitektur
¨
Hanser, Munchen,
1993, 514 S.
Grundlagen, kein bestimmtes Betriebssystem
5. Linux/UNIX allgemein
326
H Zum Weiterlesen
– Newsgruppen:
comp.unix.*
comp.sources.unix
comp.std.unix
de.comp.os.unix
alt.unix.wizards
M. J. Bach Design of the UNIX Operating System
Prentice-Hall, London, 1987, 512 S.
Dateisystem und Prozesse, wenig zur Shell
S. R. Bourne Das UNIX System V (The UNIX V Environment)
Addison-Wesley, Bonn, 1988, 464 S.
¨
Einfuhrung
in UNIX und die Bourne-Shell
P. H. Ganten, W. Alex Debian GNU/Linux
Springer, Berlin + Heidelberg, 2004, 970 S.
Einrichtung, Konfiguration und Betrieb von Debian GNU/Linux
J. Gulbins, K. Obermayr, Snoopy Linux
Springer, Berlin + Heidelberg, 2003, 900 S.
Benutzung von Linux/UNIX, geht in Einzelheiten der Kommandos
H. Hahn A Student’s Guide to UNIX
McGraw-Hill, New York, 1993, 633 S.
¨
Einfuhrendes
Lehrbuch, mit Internet-Diensten
B. W. Kernighan, R. Pike Der UNIX-Werkzeugkasten
¨
Hanser, Munchen,
1986, 402 S.
Gebrauch vieler UNIX-Kommandos
M. Kofler Linux – Installation, Konfiguration, Anwendung
Addison-Wesley, Bonn, 2000, 1108 S.
¨ das Buch.
5. Auflage, spricht fur
D. G. Korn, M. I. Bolsky The Kornshell, Command and
Programming Language
¨
deutsch: Die KornShell, Hanser, Munchen,
1991
¨
Einfuhrung
in UNIX und die Korn-Shell
A. Robbins UNIX in a Nutshell
O’Reilly, Sebastopol, 2000, 632 S.
Nachschlagewerk zu den meisten UNIX-Kommandos,
im UNIX CD Bookshelf enthalten. Auch auf Englisch.
M. J. Rochkind Advanced UNIX Programming
Addison-Wesley, Boston, 2004, 719 S.
Beschreibung der wichtigsten UNIX System Calls
K. Rosen u. a. UNIX: The Complete Reference
Osborne/McGraw-Hill, Berkeley, 1999, 1302 S.
¨
Fast wurfelf¨
ormiges Nachschlagewerk, insbesondere
zu Linux, Solaris und HP-UX; breites Themenspektrum
E. Siever et al. LINUX in a Nutshell
O’Reilly, Sebastopol, 2001, 880 S.
Nachschlagewerk zu den meisten LINUX-Kommandos
327
W. R. Stevens Advanced Programming in the UNIX Environment
Addison-Wesley, Boston, 1992, 744 S.
¨
Ahnlich
wie Rochkind
6. Linux/UNIX Verwaltung
Æ. Frisch Essential System Administration
O’Reilly, Sebastopol, 1995, 760 S.
¨
¨ Benutzer auf dem Weg zum Sysadmin.
Ubersicht
fur
K. Heuer, R. Sippel UNIX-Systemadministration
Springer, Berlin + Heidelberg, 2004, 800 S.
E. Nemeth, G. Snyder, S. Seebass, T. R. Hein UNIX System
Administration Handbook
Prentice-Hall, Englewood-Cliffs, 2001, 835 S.
¨ Sysadmins,
Auf den neuesten Stand gebrachte Hilfe fur
viel Stoff.
R. U. Rehman HP Certified – HP-UX System Administration
Prentice Hall PTR, Upper Saddle River, 2000, 800 S.
¨
Begleitbuch zu einem Kurs, Einfuhrung
in und Verwaltung
von HP-UX
M. Welsh, M. K. Dalheimer, L. Kaufmann Running Linux
O’Reilly, Sebastopol, 1999, 750 S.
Einrichtung und Betrieb eines LINUX-PCs
7. Linux/UNIX Einzelthemen
– Newsgruppen:
comp.unix.*
A. V. Aho, B. W. Kernighan, P. J. Weinberger The AWK
Programming Language
Addison-Wesley, Boston, 1988, 210 S.
Standardwerk zum AWK
D. Cameron, B. Rosenblatt Learning GNU Emacs
O’Reilly, Sebastopol, 1991, 442 S.
D. Dougherty, A. Robbins sed & awk
O’Reilly, Sebastopol, 1997, 407 S.
H. Herold Linux Unix Profitools: awk, sed, lex, yacc und make
¨
Addison-Wesley, Munchen,
1998, 890 S.
L. Lamb, A. Robbins Textbearbeitung mit dem vi-Editor
O’Reilly, K¨oln, 1999, 333 S.
A. Oram, S. Talbott Managing Projects with make
O’Reilly, Sebastopol, 1993, 149 S.
L. Wall, T. Christiansen, J. Orwant Programming Perl
O’Reilly, Sebastopol, 2000, 1067 S.
8. X Window System (X11), Motif, Gnome, KDE
328
H Zum Weiterlesen
– Newsgruppen:
comp.windows.x.*
– OSF/Motif Users’s Guide
OSF/Motif Programmer’s Guide
OSF/Motif Programmer’s Reference
Prentice-Hall, Englewood Cliffs, 1990
F. Culwin An X/Motif Programmer’s Primer
Prentice-Hall, New York, 1994, 344 S.
T. + M. K. Dalheimer KDE Anwendung und Programmierung
O’Reilly, Sebastopol, 1999, 321 S.
K. Gottheil u. a. X und Motif
Springer, Berlin + Heidelberg, 1992, 694 S.
N. Mansfield The Joy of X
Addison-Wesley, Boston, 1993, 368 S.
¨ Anwender geeignet.
Als Einstieg fur
A. Nye XLib Programming Manual
O’Reilly, Sebastopol, 1990, 635 S.
¨
Einfuhrung
in X11 und den Gebrauch der XLib
V. Quercia, T. O’Reilly X Window System Users Guide
O’Reilly, Sebastopol, 1990, 749 S.
¨
¨ Anwender
Einfuhrung
in X11 fur
R. J. Rost X and Motif Quick Reference Guide
Digital Press, Bedford, 1993, 400 S.
9. Textverarbeitung mit LaTeX
K. Braune, J. Lammarsch, M. Lammarsch LaTeX
Springer, Berlin + Heidelberg, 2004, 700 S.
M. K. Dalheimer LaTeX kurz & gut
O’Reilly, K¨oln, 2000, 72 S.
¨
H. Kopka LaTeX, 3 Bande
¨
Band 1: Einfuhrung
Addison-Wesley, Bonn, 2000, 520 S.
¨
Band 2: Erganzungen
Addison-Wesley, Bonn, 1997, 456 S.
Band 3: Erweiterungen
Addison-Wesley, Bonn, 1996, 512 S.
Standardwerk im deutschen Sprachraum
L. Lamport Das LaTeX-Handbuch
Addison-Wesley, Bonn, 1995, 360 S.
H. Partl u. a. LaTeX-Kurzbeschreibung
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/latex/lkurz.ps.gz
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/latex/lkurz.tar.gz
1990, 46 S., Postscript und LaTeX-Quellen
¨
Einfuhrung,
mit deutschsprachigen Besonderheiten (Umlaute)
329
10. Multimedia (Grafik, Sound)
– Newsgruppen:
comp.graphics.*
alt.graphics.*
J. D. Foley Computer Graphics – Principles and Practice
Addison-Wesley, Boston, 1992, 1200 S.
Standardwerk zur Computer-Raster-Grafik
R. F. Ferraro Programmer’s Guide to the EGA and VGA Cards
Addison-Wesley, Boston, 1990, 1040 S.
¨
Viele Grundlagen, die uber
EGA und VGA hinausgehen
K. Kylander, O. S. Kylander GIMP
MITP-Verlag, Bonn, 1999, 700 S.
Benutzerhandbuch zum GNU Image Manipulation Program
11. Programmieren allgemein
– Newsgruppen:
comp.programming
comp.unix.programmer
comp.lang.*
comp.software.*
comp.software-eng
comp.compilers
de.comp.lang.*
A. V. Aho u. a. Compilers, Principles, Techniques and Tools
Addison-Wesley, Boston, 1986, 796 S.
B. Beizer Software Testing Techniques
Van Nostrand-Reinhold, 1990, 503 S.
F. P. Brooks jr. The Mythical Man-Month
Addison-Wesley, Boston, 1995, 322 S.
Organisation großer Software-Projekte
M. K. Dalheimer Linux – Wegweiser zu Programmierung + Entwicklung
O’Reilly, Sebastopol, 1997, 580 S.
Software-Entwicklung unter LINUX, Werkzeuge
N. Ford Programmer’s Guide
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/misc/pguide.txt
1989, 31 S., ASCII
allgemeine Programmierhinweise, Shareware-Konzept
T. Grams Denkfallen und Programmierfehler
Springer, Berlin + Heidelberg, 1990, 159 S.
¨ C-Programme
PASCAL-Beispiele, gelten aber auch fur
D. Gries The Science of Programming
Springer, Berlin + Heidelberg, 1981, 366 S.
¨
¨
Grundsatzliches
zu Programmen und ihrer Prufung,
mit praktischer Bedeutung.
330
H Zum Weiterlesen
¨
¨
R. H. Guting,
M. Erwig Ubersetzerbau
Springer, Berlin + Heidelberg, 1999, 368 S.
M. Marcotty, H. Ledgard The World of Programming Languages
Springer, Berlin + Heidelberg, 1987, 360 S.
S. Pfleeger Software Engineering: The Production of Quality
Software
Macmillan, 1991, 480 S.
I. W. Ricketts Managing Your Software Project –
A Student’s Guide
Springer, London, 1998, 103 S.
¨
Detaillierte Anweisung an Studenten zur Planung, Durchfuhrung
¨
und Uberwachung von Projekten.
R. W. Sebesta Concepts of Programming Languages
Benjamin/Cummings, Redwood City, 1993, 560 S.
I. Sommerville Software Engineering
Addison-Wesley, Boston, 1992, 688 S.
Wie man ein Programmierprojekt organisiert;
¨
Werkzeuge, Methoden; sprachenunabhangig
N. Wirth Systematisches Programmieren
Teubner, Stuttgart, 1993, 160 S.
¨
Allgemeine Einfuhrung
ins Programmieren, PASCAL-nahe
12. Programmieren in C/C++/Objective C
– Newsgruppen:
comp.lang.c
comp.std.c
comp.lang.object
comp.lang.c++
comp.lang.objective-c
comp.std.c++
de.comp.lang.c
de.comp.lang.c++
G. Booch Object-Oriented Analysis and Design with Applications
Benjamin + Cummings, Redwood City, 1994, 590 S.
U. Breymann Designing Components with the C++ STL
Addison-Wesley, Boston, 2000, 320 S.
B. J. Cox, A. J. Novobilski Object-Oriented Programming
Addison-Wesley, Boston, 1991, 270 S.
Objective C
P. A. Darnell, P. E. Margolis C: A Software Engineering Approach
Springer, Berlin + Heidelberg, 1996, 500 S.
H. M. Deitel, P. J. Deitel C How to Program
Prentice Hall, Englewood Cliffs, 1994, 926 S.
¨ auch C++. Ausgepragtes
¨
Enthalt
Lehrbuch.
331
J. Hanly, E. Koffman Problem Solving and Program Design in C
Addison-Wesley, Boston, 1999, 276 S.
J. Hanly, E. Koffman C Program Design for Engineers
Addison-Wesley, Boston, 2001, 679 S.
S. P. Harbison, G. L. Steele C – A Reference Manual
Prentice Hall, Englewood Cliffs, 1995, 470 S.
Vielfach empfohlenes Nachschlagewerk, K+R und ANSI/ISO.
T. Jensen A Tutorial on Pointers and Arrays in C
http://www.netcom.com/ tjensen/ptr/pointers.htm
N. M. Josuttis The C++ Standard Library – A Tutorial and Reference
Addison-Wesley, Boston, 1999, 832 S.
http://www.josuttis.de/libbook/
B. W. Kernighan, D. M. Ritchie The C Programming Language
¨
Deutsche Ubersetzung:
Programmieren in C
Zweite Ausgabe, ANSI C
¨
Hanser Verlag, Munchen,
1990, 283 S.
Standardwerk zur Programmiersprache C, Lehrbuch
R. Klatte u. a. C-XSC
Springer, Berlin + Heidelberg, 1993, 269 S.
¨ wissenschaftliches Rechnen
C++-Klassenbibliothek fur
A. Koenig Accelerated C++: Practical Programming by Example
Addison-Wesley, Boston, 2000, 352 S.
S. Kuhlins, M. Schader Die C++-Standardbibliothek
Springer, Berlin + Heidelberg, 2002, 421 S.
¨
Einfuhrung
in die C++ Standard Library einschl. der STL
D. Lewine POSIX Programmer’s Guide
O’Reilly, Sebastopol, 1991, 634 S.
Mit Referenz der ANSI-C- und der POSIX-Funktionen
D. Libes Obfuscated C and Other Mysteries
Wiley, New York, 1993, 413 S.
S. Lippman, J. Lajoie C++ Primer
Addison-Wesley, Boston, 3. Aufl. 1998, 1296 S.
¨ Anfanger,
¨
¨ auch ANSI-C
Verbreitetes Lehrbuch fur
enthalt
N. Matthew, R. Stones Beginning Linux Programming
Wrox Press, Chicago, 1999, 950 S.
N. Matthew, R. Stones Professional Linux Programming
Wrox Press, Chicago, 2000, 1155 S.
Betriebssystemnahe Fragen der Programmierung in C/C++
T. Misfeldt et al. The Elements of C++ Style
Cambridge University Press, 2004, 182 S.
¨ gute C++-Programme
Regeln fur
S. Oualline Practical C Programming
O’Reilly, Sebastopol, 1997, 451 S.
332
H Zum Weiterlesen
S. Oualline Practical C++ Programming
O’Reilly, Sebastopol, 1995, 581 S.
P. J. Plauger, J. Brodie Referenzhandbuch Standard C
Vieweg, Braunschweig, 1990, 236 S.
P. J. Plauger The Standard C Library
Prentice-Hall, Englewood Cliffs, 1991, 498 S.
Die Funktionen der C-Standardbibliothek nach ANSI
P. J. Plauger The Draft Standard C++ Library
Prentice-Hall, Englewood Cliffs, 1994, 590 S.
Die Funktionen der C++-Standardbibliothek nach ANSI
R. Robson Using the STL
Springer, Berlin + Heidelberg, 1998, 421 S.
M. Schader, S. Kuhlins Programmieren in C++
Springer, Berlin + Heidelberg, 1998, 386 S.
¨
Lehrbuch und Nachschlagewerk, mit Ubungsaufgaben
K. Schmaranz Softwareentwicklung in C
Springer, Berlin + Heidelberg, 2002, 400 S.
K. Schmaranz Softwareentwicklung in C++
Springer, Berlin + Heidelberg, 2003, 570 S.
B. Stroustrup The C++ Programming Language
bzw. Die C++ Programmiersprache
Addison-Wesley, Boston/Bonn, 2000, 1024 S.
¨ Fortgeschrittene, der Klassiker fur
¨ C++
Lehrbuch fur
13. Netze allgemein (Internet, OSI)
– Newsgruppen:
comp.infosystems.*
comp.internet.*
comp.protocols.*
alt.best.of.internet
alt.bbs.internet
alt.internet.*
de.comm.internet
de.comp.infosystems
– EFF’s Guide to the Internet
http://www.eff.org/pub/Publications/EFF\_Net\_Guide/
¨
Einfuhrung
in die Dienste des Internet
S. Carl-Mitchell, J. S. Quarterman Practical Internetworking
with TCP/IP and UNIX
Addison-Wesley, Boston, 1993, 432 S.
¨
D. E. Comer Internetworking with TCP/IP (4 Bande)
Prentice-Hall, Englewood Cliffs, I. Band 1991, 550 S.
II. Band 1991, 530 S., 88 DM; IIIa. Band (BSD) 1993, 500 S.
IIIb. Band (AT&T) 1994, 510 S.
Prinzipien, Protokolle und Architektur des Internet
333
H. Hahn, R. Stout The Internet Complete Reference
Osborne MacGraw-Hill, Berkeley, 1994, 818 S.
Das Netz und seine Dienste von Mail bis WWW; Lehrbuch
¨ Benutzer des Internet
und Nachschlagewerk fur
C. Hunt TCP/IP Netzwerk-Administration
O’Reilly, Sebastopol, 1998, 632 S.
B. P. Kehoe Zen and the Art of the Internet
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/net/general/zen.ps.gz
1992, 100 S., Postscript
¨
Einfuhrung
in die Dienste des Internet
O. Kirch, T. Dawson Linux Network Administrator’s Guide
O’Reilly, Sebastopol, 2000, 500 S.
E. Krol The Hitchhikers Guide to the Internet
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/net/general/hitchhg.txt
1987, 16 S., ASCII
¨
Erklarung
einiger Begriffe aus dem Internet
E. Krol The Whole Internet
O’Reilly, Sebastopol, 1992, 376 S.
J. F. Kurose, K. W. Ross Computer Networking
Addison-Wesley, Boston, 2003, 784 S.
M. Scheller u. a. Internet: Werkzeuge und Dienste
Springer, Berlin + Heidelberg, 1994, 280 S.
http://www.ask.uni-karlsruhe.de/books/inetwd.html
A. S. Tanenbaum Computer Networks
Prentice-Hall, London, 1996, 848 S.
¨
Einfuhrung
in Netze mit Schwerpunkt auf dem OSI-Modell
14. Netzdienste Einzelthemen
– Newsgruppen:
comp.theory.info-retrieval
comp.databases.*
P. Albitz, C. Liu DNS and BIND
O’Reilly, Sebastopol, 1998, 482 S.
Internet-Adressen und -Namen, Name-Server
B. Costales, E. Allman sendmail
O’Reilly, Sebastopol, 1997, 1021 S.
¨
Das wichtigste netzseitige Email-Programm (MTA) ausfuhrlich
dargestellt, keine leichte Kost, aber unentbehrlich
J. E. Hellbusch Barrierefreies Webdesign
KnowWare, www.knowware.de/, 2001, 86 S.
Hinweise zur Gestaltung von Webseiten, kompakt und
¨
verstandlich
P. J. Lynch, S. Horton Web Style Guide
Yale University Press, New Haven, 1999, 165 S.
Gestaltung und Organisation von Webseiten, wenig Technik
334
H Zum Weiterlesen
C. Meinel, H. Sack WWW
Springer, Berlin + Heidelberg, 2004, 1200 S.
Internet-Grundlagen, HTTP, HTML, CSS, XML, CGI
¨
S. Munz,
W. Nefzger HTML 4.0 Handbuch
¨
Franzis, Munchen,
1999, 992 S.
Deutsches Standardwerk zum Schreiben von Webseiten,
abgewandelt auch unter dem Titel Selfhtml an
¨
mehreren Stellen im Netz verfugbar.
J. Niederst Web Design in a Nutshell
O’Reilly, Sebastopol, 1999, 560 S.
Das gesamte Web zum Nachschlagen, viel Technik
A. Schwartz Managing Mailing Lists
O’Reilly, Sebastopol, 1998, 320 S.
Majordomo, Listserv, List Processor und Smartlist
S. Spainhour, R. Eckstein Webmaster in a Nutshell
O’Reilly, Sebastopol, 1999, 523 S.
HTML, CSS, XML, JavaScript, CGI und Perl, PHP, HTTP, Apache
W. R. Stevens UNIX Network Programming
Vol. 1: Networking APIs: Sockets and XTI
Prentice Hall, Englewood Cliffs, 1998, 1009 S.
Vol. 2: Interprocess Communication
Prentice Hall, Englewood Cliffs, 1999, 592 S.
¨ Clients und Server der Netzdienste
C-Programme fur
15. Sicherheit
– Newsgruppen:
comp.security.*
comp.virus
sci.crypt
alt.security.*
alt.comp.virus
de.comp.security
– RFC 1244 (FYI 8): Site Security Handbook
ftp://ftp.nic.de/pub/rfc/rfc1244.txt
1991, 101 S., ASCII
¨ Internet-Benutzer
Sicherheits-Ratgeber fur
– Department of Defense Trusted Computer Systems
Evaluation Criteria (Orange Book)
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/net/secur/orange-book.gz
1985, 120 S., ASCII. Abgel¨ost durch:
Federal Criteria for Information Technology Security
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/net/secur/fcvol1.ps.gz
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/net/secur/fcvol2.ps.gz
¨
1992, 2 Bande
mit zusammen 500 S., Postscript
Die amtlichen amerikanischen Sicherheitsvorschriften
– Linux Hacker’s Guide
¨
Markt + Technik, Munchen,
1999, 816 S.
335
F. L. Bauer Kryptologie
Springer, Berlin + Heidelberg, 1994, 369 S.
R. L. Brand Coping with the Threat of Computer Security Incidents
A Primer from Prevention through Recovery
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/net/secur/primer.ps.gz
1990, 44 S., Postscript
D. A. Curry Improving the Security of Your UNIX System
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/net/secur/secdoc.ps.gz
1990, 50 S., Postscript
¨ UNIX-System-Verwalter, mit Checkliste
Hilfe fur
S. Garfinkel, G. Spafford Practical Unix + Internet Security
O’Reilly, Sebastopol, 1996, 971 S.
¨
¨
Breit angelegte, verstandliche
Einfuhrung
in Sicherheitsthemen
B. Schneier Angewandte Kryptographie
Addison-Wesley, Bonn, 1996, 844 S.
M. Schumacher, U. Roedig, M.-L. Moschgath Hacker Contest
Springer, Berlin + Heidelberg, 2003, 300 S.
16. Computerrecht
– Newsgruppen:
comp.society.privacy
comp.privacy
comp.patents
alt.privacy
de.soc.recht
de.soc.datenschutz
– World Intellectual Property Organization (WIPO)
http://www/wipo.int/
¨
– Juristisches Internetprojekt Saarbrucken
http://www.jura.uni-sb.de/
¨ Munster)
¨
– Netlaw Library (Universitat
http://www.jura.uni-muenster.de/netlaw/
– Online-Recht http://www.online-recht.de/
– Computerrecht (Beck-Texte)
¨
Beck, Munchen,
1994
U. Dammann, S. Simitis Bundesdatenschutzgesetz
Nomos Verlag, Baden-Baden, 1993, 606 S.
BDSG mit Landesdatenschutzgesetzen und Internationalen
Vorschriften; Texte, kein Kommentar
G. v. Gravenreuth Computerrecht von A – Z (Beck Rechtsberater)
¨
Beck, Munchen,
1992
H. Hubmann, M. Rehbinder Urheber- und Verlagsrecht
¨
Beck, Munchen,
1991, 319 S.
336
H Zum Weiterlesen
A. Junker Computerrecht. Gewerblicher Rechtsschutz,
¨
Mangelhaftung,
Arbeitsrecht. Reihe Recht und Praxis
Nomos Verlag, Baden-Baden, 1988, 267 S.
F. Koch Handbuch Software- und Datenbank-Recht
Springer, Berlin + Heidelberg, 2003, 1000 S.
¨
D. Kroger,
M. A. Gimmy Handbuch zum Internetrecht
Springer, Berlin + Heidelberg, 2. Auflage 2002, 1000 S.
17. Geschichte der Informatik
– Newsgruppen:
comp.society.folklore
alt.folklore.computers
de.alt.folklore.computer
– Kleine Chronik der IBM Deutschland
1910 – 1979, Form-Nr. D12-0017, 138 S.
1980 – 1991, Form-Nr. D12-0046, 82 S.
¨
Reihe: Uber
das Unternehmen, IBM Deutschland
– Die Geschichte der maschinellen Datenverarbeitung Band 1
¨
Reihe: Enzyklopadie
der Informationsverarbeitung
IBM Deutschland, 228 S., Form-Nr. D12-0028
– 100 Jahre Datenverarbeitung Band 2
¨
Reihe: Uber
die Informationsverarbeitung
IBM Deutschland, 262 S., Form-Nr. D12-0040
– Open Source
O’Reilly, K¨oln, 1999, 70 S.
P. E. Ceruzzi A History of Modern Computing
MIT Press, Cambridge/USA, 1998, 400 S.
Computergeschichte seit 1945 aus nordamerikanischer Sicht
O. A. W. Dilke Mathematik, Maße und Gewichte in
der Antike (Universalbibliothek Nr. 8687 [2])
Reclam, Stuttgart, 1991, 135 S.
M. Hauben, R. Hauben Netizens – On the History and
Impact of Usenet and the Internet
IEEE Computer Society Press, Los Alamitos, 1997, 345 S.
www.columbia.edu/˜hauben/netbook/
A. Hodges Alan Turing, Enigma
Kammerer & Unverzagt, Berlin, 1989, 680 S.
D. M. Lehmann Der EDV-Pionier Nikolaus Joachim Lehmann
¨
Dr. Hansel-Hohenhausen,
Frankfurt (M), 2002,
S. Levy Hackers – Heroes of the Computer Revolution
Penguin Books, London, 1994, 455 S.
R. Oberliesen Information, Daten und Signale
Deutsches Museum, rororo Sachbuch Nr. 7709 (vergriffen)
337
D. Shasha, C. Lazere Out of Their Minds
Springer, Berlin + Heidelberg, 1995, 295 S.
¨
Biografien beruhmter
Computerpioniere
D. Siefkes u. a. Pioniere der Informatik
Springer, Berlin + Heidelberg, 1998, 160 S.
¨ europaischen
¨
Interviews mit funf
Computerpionieren
B. Sterling A short history of the Internet
ftp://ftp.ciw.uni-karlsruhe.de/pub/docs/history/origins
1993, 6 S., ASCII
K. Zuse Der Computer - Mein Lebenswerk
Springer, Berlin + Heidelberg, 3. Aufl. 1993, 220 S.
Autobiografie Konrad Zuses
18. Allgemeinwissen und Philosophie
– Newsgruppen:
comp.ai.philosophy
sci.philosophy.tech
alt.fan.hofstadter
E. Dyson Release 2.1 – A Design for Living in the Digital Age
Petersen, Hamburg, 2000, 370 S.
D. R. Hofstadter G¨odel, Escher, Bach - ein Endloses
Geflochtenes Band
¨
dtv/Klett-Cotta, Munchen,
1992, 844 S.
J. Ladd Computer, Informationen und Verantwortung
in: Wissenschaft und Ethik, herausgegeben von H. Lenk
Reclam-Band 8698, Ph. Reclam, Stuttgart
H. Lenk Chancen und Probleme der Mikroelektronik, und:
K¨onnen Informationssysteme moralisch verantwortlich sein?
in: Hans Lenk, Macht und Machbarkeit der Technik
Reclam-Band 8989, Ph. Reclam, Stuttgart, 1994, 152 S.
P. Schefe u. a. Informatik und Philosophie
BI Wissenschaftsverlag, Mannheim, 1993, 326 S.
¨
18 Aufsatze
verschiedener Themen und Meinungen
K. Steinbuch Die desinformierte Gesellschaft
Busse + Seewald, Herford, 1989, 269 S. (vergriffen)
J. Weizenbaum Die Macht der Computer und die Ohnmacht
der Vernunft (Computer Power and Human Reason.
From Judgement to Calculation)
Suhrkamp Taschenbuch Wissenschaft 274, Frankfurt (Main),
1990, 369 S.
H. Zemanek Das geistige Umfeld der Informationstechnik
Springer, Berlin + Heidelberg, 1992, 303 S.
¨
Zehn Vorlesungen uber
Technik, Geschichte und Philosophie
des Computers, von einem der Pioniere
19. Zeitschriften
338
H Zum Weiterlesen
– c’t
¨
Verlag Heinz Heise, Hannover, vierzehntagig,
¨ alle Fragen der Computerei, technisch.
fur
http://www.ix.de/
– IX
Verlag Heinz Heise, Hannover, monatlich,
¨ Anwender von Multi-User-Systemen, technisch.
fur
http://www.ix.de/
– The C/C++ Users Journal
Miller Freeman Inc., USA, monatlich,
http://www.cuj.com/
– Dr. Dobb’s Journal
Miller Freeman Inc., USA, monatlich,
http://www.ddj.com/
Software Tools for the Professional Programmer; viel C und C++
Und noch einige Verlage:
• Addison-Wesley, Bonn,
http://www.addison-wesley.de/
• Addison Wesley Longman, USA,
http://www.awl.com/
• Computer- und Literaturverlag, Vaterstetten,
http://www.cul.de/
¨
• Carl Hanser Verlag, Munchen,
http://www.hanser.de/
• Verlag Heinz Heise, Hannover,
http://www.heise.de/
• International Thomson Publishing, Stamford,
http://www.thomson.com/
• Klett-Verlag, Stuttgart,
http://www.klett.de/
• MITP-Verlag, Bonn,
http://www.mitp.de/
¨
• R. Oldenbourg Verlag, Munchen,
http://www.oldenbourg.de/
• O’Reilly, Deutschland,
http://www.ora.de/
• O’Reilly, Frankreich,
http://www.editions-oreilly.fr/
• O’Reilly, USA,
http://www.ora.com/
339
• Osborne McGraw-Hill, USA,
http://www.osborne.com/
• Prentice-Hall, USA,
http://www.prenhall.com/
• Sams Publishing (Macmillan Computer Publishing), USA,
http://www.mcp.com/
• Springer-Verlag, Berlin, Heidelberg, New York usw.,
http://www.springer.de/
• Wrox Press, Chicago, Birmingham, Paris,
http://www.wrox.com/
¨
Und uber
allem, mein Sohn, laß dich warnen;
¨
denn des vielen Buchermachens
ist kein Ende,
¨
und viel Studieren macht den Leib mude.
Prediger 12, 12
340
H Zum Weiterlesen
Sach- und Namensverzeichnis
¨
Einige Begriffe finden sich unter ihren Oberbegriffen, beispielsweise GerateDatei unter Datei. Verweise (s. ...) zeigen entweder auf ein bevorzugtes Syn¨
onym, auf einen Oberbegriff oder auf die deutsche Ubersetzung
eines engli¨
schen oder franz¨osischen Fachwortes. Die im Buch vorkommenden Abkurzun¨
gen sind ebenfalls aufgefuhrt.
Fett hervorgehobene Seitenzahlen verweisen
¨
¨
auf eine ausfuhrliche
Erlauterung
des Begriffes.
/lib/libc.a 152
/usr/include/limits.h 82
/usr/lib/libcurses.a 155
:-) s. Grinsling
#define 196, 289
#ifdef 199
#ifndef 199
#include 197, 289
#undef 197
$? 120
$Header$ (RCS) 55
$Id$ (RCS) 55
$Log$ (RCS) 55
& (C) 103
&& (C) 103
64-Bit-Maschine 84
ALGOL 28, 252
Algorithmus 258
Alias-Anweisung (FORTRAN) 65, 162
Allgemeinheit 258
Andreessen, M. 313
anmausen s. klicken
Anmeldung 11
Anonymous FTP 9
ANSI-C 28
Anweisung
Alias-A. (FORTRAN) 65, 162
C-A. 113, 206
Compiler-A. 65, 131, 162
define-A. 196
include-A. 197
Kontrollanweisung 113
leere A. (C) 113
¨
Praprozessor-A.
195
Shell-A. s. Kommando
Anwendungsprogramm 6, 7
AOL s. America Online
Appel syst`eme s. Systemaufruf
Application s. Anwendungsprogramm
apropos(1) 14
ar(1) 51, 157
ar(4) 51
Archiv (Datei) 51
Archiv (File) 150
argc 66, 135, 164
Argument (Kommando) 12
Argumentvektor 135
¨
Argumentzahler
135
argv 66, 135, 164
Arobace s. Klammeraffe
Arobase s. Klammeraffe
Array
a.out(4) 43, 75
¨
Abhangigkeit
17
Ablaufkontrolle s. Kontrollanweisung
Abstrakter Datentyp 170
Access s. Zugriff
access(2) 67, 164
ACL s. Access Control List
action (HTML) 244
Adaptor 179
adb(1) 48
admin(1) 60
Administrator s. Verwalter
¨
Adressubergabe
125
Adresskonstante 93
Adressvariable s. Pointer
¨
AGB s. Allgemeine Geschaftsbedingungen
Aiken, H. 313
¨
Akronym s. Abkurzung
341
342
A. of characters 88
A. von Funktionspointern 124, 226
Array 87
Index 87
linearisieren 88
mehrdimensionales A. 88
Name 88
Subarray 183
Teilfeld s. Subarray
Typ (C) s. Typ
Zeiger s. Index
ASCII
German-ASCII 270
Steuerzeichen 271
Zeichensatz 259
Assembler 21, 25, 26, 32, 144
¨ 111
Assoziativitat
Atanasoff, J. V. 313
ATM s. Asynchronous Transfer Mode
Attachement s. Anhang (Email)
Ausdruck
Ausdruck (C) 101
¨
ausfuhrbar
32
Ausgabe 108, 186
Ausgang (Schleife) 115
Ausgangswert s. Defaultwert
Auslagerungsdatei s. Datei
Auswahl (C) 114
auto (C) 99
Automat 3
Autorensystem 10
B ABBAGE , C. 2
Babbage, C. 313
Babel s. Babbilard e´ lectronique
Babillard e´ lectronique s. Bulletin
Board
Back tick s. Back quote
Background s. Prozess
B ACKUS, J. 78
Backus-Naur-Form 78
Bardeen, J. 313
bash(1) s. Shell
BASIC 7, 27
Batchfile s. Shell
B AUER , F. L. 2
BCD-System 259
Beautifier 44
Bedingte Bewertung 105
Sach- und Namensverzeichnis
Bedingte Kompilation 199
Bedingung (C) 114
Befehl s. Anweisung
Befehl (Shell) s. Kommando
Befehlszeilenschalter s. Option
Bereit-Zeichen s. Prompt
bereitstellen s. mounten
Berners-Lee, T. 313
Berry, C. 313
Besitzer s. Datei, Liste, Prozess
Betriebssystem 6, 7
Bezug 129
Bezugszahl s. Flag
Bibliothek 51, 150
Bidouilleur s. Hacker
Big Blue s. IBM
Bildlauf s. scrollen
Bildpunkt s. Pixel
Bildschirm
Bildschirm 5
Screen saver s. Schoner
¨
binar-kompatibel
32
¨
Binardarstellung
4
Binary 32
BIND s. Berkeley Internet Name Domain
Binder s. Linker
Bindung, dynamische 33
Bindung, statische 33
Binette s. Grinsling
Bit 4
bit (Maßeinheit) 4
Bixie s. ASCII-Grafik
Blechbregen 1
Block 206
Bookmark s. Lesezeichen
Boole, G. 313
booten 11
booter s. booten
Botschaft (C++) 170
Bottom-up-Entwurf 38
Boule de pointage s. Trackball
Brattain, W. H. 313
break (C) 114, 118
Bricklin, D. 313
Briefkasten s. Mailbox
Browser s. Brauser
BSD s. Berkeley Software Distribution
Bubblesort 54
Sach- und Namensverzeichnis
¨
Bucherei
s. Bibliothek
Buffer s. Puffer
Bug s. Fehler
Builder 44
Bulletin Board 9
bye 12
Byte 4
C
C 7, 28
C++ 24, 29
Obfuscated C. 249
Objective C 30
C++ 24, 29
C-XSC 30, 181
C9X 28
CA s. Certification Authority
Cache s. Speicher
CAD s. Computer Aided Design
Cahier de charge s. Pflichtenheft
Cailliau, R. 313
¨
Call by reference s. Adressubergabe
¨
Call by value s. Wertubergabe
calloc(3) 232
Carriage return s. Zeilenwechsel
CASE s. Computer Aided Software Engineering
case (C) 114
cast-Operator 110
cb(1) 34, 44, 76
CC(1) 32
cc(1) 32, 43
CCC s. Chaos Computer Club
ccom(1) 32
cdecl 83
Centronics s. Schnittstelle
Cerf, V. G. 313
CERT s. Computer Emergency Response Team
Cert s. Zertifikat
cflow(1) 53, 76
cgi s. Common Gateway Interface
Chaine de caract`eres s. String
Chaos Computer Club 313
char (C) 85
Character set s. Zeichensatz
Chat s. Internet Relay Chat
chatr(1) 71, 168
chmod(2) 76
343
ci(1) (RCS) 55
CIAC s. Computer Incident Advisory
Capability
Clark, J. 313
Clich´e s. Dump
cliquer s. klicken
close(2) 67, 108, 165
CM s. Configuration Management
co(1) (RCS) 55
COBOL 7, 27
Codd, E. F. 313
Codierung (Programm) 31, 35
col(1) 14
Collection s. Container
Common Gateway Interface 243
comp.society.folklore 12
compact (Speichermodell) 157
Compiler 20, 31, 42
Compiler-Treiber 32
Compilerbau 23
compress(1) 204
Computador 1
Computer
Aufgaben 1
Herkunft des Wortes 1
Home C. s. Heim-C.
PC s. Personal C.
Computer Aided Software Engineering
61
Computer Science 2
Concurrent Versions System 60
Configuration Management 61
configure (make) 47
const (C) 82
Constructor 170
Container 179
continue (C) 116, 118
Contra vermes 49
Coquille s. Shell
core(4) 75
Courrier e´ lectronique s. Email
CPU s. Prozessor
creat(2) 76
Crocker, S. 313
Cross-Compiler 32
csh(1) s. Shell
ctime(3) 64, 162
CUPS s. Common Unix Printing System
344
curses(3) 155, 211
curses.h 156, 211
Curseur s. Cursor
CVS s. Concurrent Versions System
cxref(1) 54, 76
Cybernaute s. Netizen
d´efiler s. scrollen
DAT s. Digital Audio Tape
Data code s. Zeichensatz
Data Glove s. Steuerhandschuh
Datei
Auslagerungsdatei s. Swap-D.
Definitonsdatei s. Include-D.
¨
Eigentumer
s. Besitzer
EOF s. Ende
Handle s. Deskriptor
Header-Datei s. Include-D.
Include-D. 288
mtime 44
Owner s. Besitzer
Pfad s. absoluter Name
¨ D. s. gew¨ohnliche D.
regulare
Daten 1
Datenaustausch 38
Datensicherung s. Backup
Datenstruktur 38, 82
Datentabelle s. Array
Dator 1
¨
Debit s. Ubertragungsgeschwindigkeit
Debugger
absoluter D. 48
Hochsprachen-D. s. symbolischer
D.
symbolischer D. 48
default (C) 114
d´efiler s. scrollen
Definition 81
Definitonsdatei s. Datei
Deklaration 81
dekrementieren 102, 107
delta(1) 60
D´epannage s. Fehlersuche
dereferenzieren 92, 107
DES s. Data Encryption Standard
¨
Device s. Gerat
DFN s. Deutsches Forschungsnetz
Dialog 11
Diener s. Server
Sach- und Namensverzeichnis
DIN 66230 203
Directive s. Anweisung
Directory s. Verzeichnis
Disassembler 33
Diskette
Diskette 6
Display s. Bildschirm
DNS s. Domain Name Service
do-while-Schleife (C) 115
Dokumentation 202
Dotprecision 184
double (C) 85
Doxygen 204
Dreckball s. Trackball
Drive s. Laufwerk
Droit d’acc`es s. Zugriffsrecht
Drucker
Drucker 6
DTD s. Document Type Definition
Dualsystem 4, 259
dynamische Bindung 33
dynamische Speicherverwaltung 232
¨
ECDL s. Fuhrerschein
Echappement s. Escape
Eckert, J. P. 313
Ecran s. Bildschirm
Editeur s. Editor
Editor
emacs(1) 42
nedit(1) 42
vi(1) 42
effacer s. l¨oschen
¨
Eigentumer
s. Datei
Einarbeitung 16
Eindeutigkeit 258
Eingabe 108, 186
Eingabe-Taste 11
Eingabeaufforderung s. Prompt
Eingang (Schleife) 115
¨
einhangen
s. mounten
¨
Einhangepunkt
s. Mounting Point
einloggen s. Anmeldung
Eintragsdienst s. Anmeldemaschine
Einzelverarbeitung s. Single-Tasking
Electronic Information 8, 9
Electronic Mail 9
Elektronengehirn 1
Elektrotechnik 2
Sach- und Namensverzeichnis
else s. if
Email s. Electronic Mail
Embedded System 1
En-tˆete s. Header
end 12
Endlichkeit 258
Engelbart, D. C. 313
Engin de recherche s. Suchmaschine
Enter-Taste s. Return-Taste
Entscheidbarkeit 258
entwerten s. quoten
enum (C) 91
Environment s. Umgebung
Environnement s. Umgebung
envp 66, 164
EOF s. Datei
EOL s. Zeilenwechsel
Ersatzzeichen s. Jokerzeichen
esac s. case
Escargot s. Klammeraffe, Snail
Esperlu`ete s. Et-Zeichen
Exabyte 4
exit 12
exit (Shell) 12
exit(2) 118
¨
Exit-Code s. Ruckgabewert
Exponent 85
¨
Expression r´eguli`ere s. Regularer
Ausdruck
Extended Scientific Computing 181
extern (C) 99, 100, 251
¨
Fuhrerschein
8
f77(1) 43
f90(1) 43
Faden (News) s. Thread
Fallunterscheidung s. case, switch
FAQ s. Frequently Asked Questions
Fassung s. Programm
Favorit s. Lesezeichen
fclose(3) 109
fcntl.h 67, 165
FDDI s. Fiber Distributed Data Interface
Fehler
Denkfehler 48
Fehlerfreiheit 33, 209
Fehlermeldung 48
Grammatik-F. 47
345
Laufzeit-F. 48
logischer F. 48
Modell-F. 48
semantischer F. 48
Syntax-F. 47
Zaunpfahl-F. 118
Feld
Feld (Typ) s. Typ
Feldgruppe s. Array
Fenˆetre s. Fenster
Fenster
¨
Schaltflache
s. Button
Title bar s. Kopfleiste
Festplatte
Festplatte 6
Fibonacci 313
Fichier s. Datei
FIFO s. Named Pipe
File s. Datei
Deskriptor 108
File 206
Include-F. 197
Kennung 32
Mode 71, 168
Pointer 109
Strukturtyp 89
System 251
Flag (Option) 12
Flag (Variable) 237
Flicken (Programm) s. Patch
Fließband s. Pipe
float (C) 85
Floppy Disk s. Diskette
Flussdiagramm 39
Foire Aux Questions s. FAQ
Folder s. Verzeichnis
Fonction syst`eme s. Systemaufruf
Footer s. Signatur
fopen(3) 109
for-Schleife (C) 116
Foreground s. Prozess
fork(2) 71, 168
FORM-Element 244
Format
Landscape s. Querformat
Portrait s. Hochformat
Formatstring 140
Formfeed s. Zeichen
FORTRAN 7, 26, 81
346
Fortsetzungszeile (C) 77
Forum s. Newsgruppe
fprintf(3) 76
fputs(3) 109
FQDN s. Fully Qualified Domain Name
Fragen 10
Frankston, B. 313
free(3) 232
Freiburger Code 26
Frequently Asked Questions 9
FSF s. Free Software Foundation
FSP s. File Service Protocol
FTP s. File Transfer Protocol
ftp.ciw.uni-karlsruhe.de 323
Funktion
Stringfunktion 152
Funktion (C)
Array von Funktionspointern 124
Bibliothek 51, 150
Definition 123
Einsprungadresse 93
Funktion 123, 206
grafische F. 155
Input/Output-F. 152
mathematische F. 154
Pointer auf F. 124
Prototyp 123
Speicherklasse 99
Standardfunktion 14, 62, 152, 159,
283
virtuelle F. 172
Xlib-F. 237
Fureteur s. Brauser
FYI s. For Your Information
Garde-barri`ere s. Firewall
Gast-Konto 11
gcc(1) 44
gdb(1) 48
¨
Gegenschragstrich
s. Zeichen
Geltungsbereich 100
get (HTML) 244
get(1) 60
gets(3) 152
getut(3) 76
Gibson, W. 313
gif s. Graphics Interchange Format
Gigabyte 4
GKS s. Graphical Kernel System
Sach- und Namensverzeichnis
Gleichung 102
Globbing s. Jokerzeichen
gmtime(3) 14, 63, 160
gnats(1) 61
GNOME s. GNU Network Object Model Environment
GNU Free Documentation License 305
GNU General Public License 298
GNU-Projekt 47
goto (C) 118
GPL s. General Public License
gprof(1) 49
Grafik 226
Gratuiciel s. Freeware
Grimace s. Grinsling
Groupe s. Gruppe
Gruppe s. Newsgruppe
guest s. Gast-Konto
gzip(1) 204
Hackbrett s. Tastatur
Handheld s. Laptop
Handle s. Datei
Handle (Internet) s. Nickname
Hard Link s. Link
Harddisk s. Festplatte
Hardware 6, 7
Hashmark s. Zeichen
HASKELL 24
Header (Email) s. Kopfzeile
Heilig, M. 313
¨
¨
Heinzelmannchen
s. Damon
Hewlett, W. 313
Hexadezimalsystem 4, 259
¨
Hexparchen
4
Hilfesystem s. man-Seite
Hintergrund s. Prozess
hochfahren s. booten
Hollerith, H. 313
Home Computer s. Computer
Home-Verzeichnis s. Verzeichnis
Homepage s. Startseite
H OPPER , G. M. 27
Hopper, G. 313
Hˆote s. Host
HP SoftBench 61
HPDPS s. HP Distributed Print System
HTML s. Hypertext Markup Language
Sach- und Namensverzeichnis
HTTP s. Hypertext Transfer Protocol
huge (Speichermodell) 158
Hypercycloid s. Klammeraffe
Hyperlien s. Hyperlink
Hypertext 10
IANA s. Internet Assigned Numbers
Authority
ICANN s. Internet Corporation for Assigned Names and Numbers
ICP s. Internet Cache Protocol
IDE s. Integrated development environment
Identifier s. Name
IEEE s. Institute of Electrical and
Electronics Engineers
IEEE Std 1063-1987 203
if (C) 114
if - else (C) 114
IFS s. Internal Field Separator
Implementation s. Codierung
IMPP s. Instant Messaging and Presence Protocol
include (C) s. #include
Include-File 197
Index (Array) s. Array
Index Node s. Inode
info(1) 205
Informatik
Angewandte I. 3
Herkunft 2
L¨otkolben-I. 3
Technische I. 3
Theoretische I. 3
Information 1
Informationsmenge 4
Informatique 2
Inhaltsverzeichnis s. Verzeichnis
Initialisierung 81, 251
inkrementieren 102, 107
Inode
Informationen aus der I. 67, 164
Instruktion s. Anweisung
int (C) 84
Integer s. Zahl
Integred development environment s.
Programmierumgebung
interaktiv 11
Interface s. Schnittstelle
347
Interface (Sprachen) 66, 163
Internaute s. Netizen
Internet 154
Interpreter 31
Invite s. Prompt
IP s. Internet Protocol
IPC s. Interprozess-Kommunikation
IRC s. Internet Relay Chat
ISC s. Internet Software Consortium
ISDN s. Integrated Services Digital
Network
ISO s. International Organization for
Standardization
ISO/IEC 14882 29
ISO/IEC 9899 28
Iteration 140
Iterator 179
Jacquard, J. M. 313
JAVA 7, 24, 30
Job s. Auftrag
Jobs, S. P. 313
Jokerzeichen s. Zeichen
jpeg s. Joint Photographic Experts
Group Format
Jukebox s. Plattenwechsler
K&R-C 28
Kahn, R. 313
Karlsruhe
Beginn der Informatik in K. 313
Informatikstudium in K. 313
¨ K.
Rechenzentrum der Universitat
313
ZUSE Z 22 313
Karlsruher Test 290
Katalog s. Verzeichnis
KDE s. K Desktop Environment
K EMENY, J. 27
Kern s. UNIX
Kernel s. Kern
K ERNIGHAN, B. W. 326
K ERNIGHAN, B. 28, 37
Kernschnittstellenfunktion s. Systemaufruf
Keyboard s. Tastatur
Kilby, J. St. C. 313
Kilobyte 4
Klammer (C) 111
Klasse (C++) 170
348
Klasse, abstrakte 172
K NUTH , D. E. 324
Knuth, D. E. 313
Kode s. Code
Komma-Operator 110, 116, 117
Kommando
UNIX-K. 12
Kommandoprozedur s. Shell
Kommandozeile 135
Kommentar
C 77, 79, 195, 202, 206
C++ 80, 169
make 44
Konstante
Konstante 77
Literal 82
symbolische K. 82, 196
Konto s. Account, 11
Kontrollanweisung 113
Kreuzreferenz 54
ksh(1) s. Shell
Kurs 8
K URTZ , T. 27
l-Wert 102
Label (C) 118
L AMPORT, L. 328
LAN s. Local Area Network
Landscape s. Format
Langage de programmation s. Programmiersprache
Langzahl-Arithmetik 185
large (Speichermodell) 157
¨
Laufvariable s. Schleifenzahler
Laufwerk 6
Layer s. Schicht
Layout s. Aufmachung
ld(1) 43
Lebensdauer
Operand 81, 99, 101
Leerzeichen s. Space
L EHMANN, N. J. 2
Lehrbuch 8, 323
L EIBNIZ , G. W. 2
Leibniz, G. W. 313
Lernprogramm 8, 10
libQt 189
Library s. Bibliothek
Licklider, J. C. R. 313
Sach- und Namensverzeichnis
Lien s. Link, Verbindung
Ligne s. Zeile
Line feed s. Zeilenwechsel
Line spacing s. Zeilenabstand
Linguistik 2
Link
direkter L. s. harter L.
Hard L. s. harter L.
indirekter L. s. weicher L.
Pointer s. weicher L.
Soft L. s. weicher L.
symbolischer L. s. weicher L.
Symlink s. weicher L.
Link, E. 313
linken (Programme) 42, 150
Linker 22, 32
lint(1) 44, 74
LISP 24
Liste
Verteiler-L. s. Mailing-L.
Liste de diffusion s. Mailing-Liste
Literal s. Konstante, 77
Lizenz s. Nutzungsrecht
Loader s. Linker
Logiciel 3
logoff 12
logout 12
long (C) 84
long double (C) 85
ls(1) 76
LSB s. Linux Standard Base
lseek(2) 67, 165
Magic Number 67, 165
magic(4) 67, 165
magic.h 67, 165
main() 66, 135, 136, 164, 206
Maˆıtre ou`ebe s. Webmaster
Maˆıtre poste s. Postmaster
make(1) 44, 75, 230
Makefile 44
Makro
C 124, 196
make 44
Shell s. Shell
malloc(3) 232
man(1) 14, 204
man-Seite 13, 14, 204
MANPATH 204
Sach- und Namensverzeichnis
Mantisse 85
Mapper s. Linker
Marke (C) s. Label
Marke (Fenster) s. Cursor
Maschinencode 31, 32
Maschinensprache 22
Maschinenwort 5, 84, 90
maskieren s. quoten
Masterspace s. Klammeraffe
Mat´eriel s. Hardware
math.h 154
Mathematik 2
Mauchly, J. W. 313
Medium s. Speicher
medium (Speichermodell) 157
Megabyte 4
Member Access Specifier 170
M´emoire centrale s. Arbeitsspeicher
M´emoire secondaire s. Massenspeicher
M´emoire vive s. Arbeitsspeicher
Memory s. Speicher
Message queue s. Nachrichtenschlange
Meta Object Compiler 189
Metcalfe, R. 313
method (HTML) 244
Methode (C++) 170
¨
MEZ s. Mitteleuropaische
Zeit
Mill, H. 313
MIME s. Multipurpose Internet Mail
Extensions
Minsky, M. L. 313
¨
Minus, unares
249
Miroir s. Spiegel
Mirror s. Spiegel
MIT s. Massachusetts Institute of
Technology
mknod(2) 71, 168
moc 189
Modul 42
MODULA 28
modulo s. Modulus
Modulus 102, 215
Monitor s. Bildschirm
monitor(3) 50
montieren s. mounten
more(1) 14
Morse, S. F. B. 313
Mot de passe s. Passwort
Moteur de recherche s. Suchmaschine
349
Motif 156
MTA s. Mail Transfer Agent
MTBF s. Mean Time Between Failure
MUA s. Mail User Agent
Murdock, I. 313
mv(1) 14
Nachricht 1
Nachrichten s. News
Nachschlagewerk 8
NAG-Bibliothek 156
Name
Benutzer-N. 11
Name (C) 77, 80, 251
Operanden-N. 81
Programm-N. 205
Napier, J. 313
N ASSI , I. 40
Nassi-Shneiderman-Diagramm 40
N AUR , P. 78
Navigateur s. Brauser
Nebenwirkung 120
Negation 249
N ELSON, T. 10
Nelson, T. 313
Nesper, E. 313
Netnews 9, 10
Network s. Netz
Network File System s. Netz-DateiSystem
Netz
Rechnernetz 6
Neumann, J. von 313
newline s. Zeilenwechsel
News (Internet) s. Netnews
News (Unix) s. news(1)
Newton-Verfahren 187
NFS s. Network File System
NIC s. Network Information Center
Nickel, K. 313
NIS s. Network Information Service
nm(1) 76
Noeud s. Knoten
Nouvelles s. News
Noyau s. Kern
nroff(1) 204
Nukleus s. Kern
NULL 93, 219
Nullpointer 93, 216, 219, 251
350
Number sign s. Doppelkreuz
num´eriser s. scannen
Num´ero IP s. IP-Adresse
Obfuscated C 249
Objective C 30
Objekt (C++) 170
Objekt (Variable) 81
Objektcode 22, 32
Octett s. Byte
Oikarinen, J. 313
Oktalsystem 4, 259
Oktett 4
On-line-Manual s. man(1)
Op s. Operator
open(2) 67, 108, 152, 165
Operand 81
Operating System s. Betriebssystem
Operation
arithmetische O. 102
Bit-O. 106, 251
Grund-O. 38
logische O. 103
Modulo-O. 84
Pointer-O. 107
Relations-O. 105
¨
zulassige
O. 82
Operator (Zeichen) 77, 101, 282
Optimierung 209
Option 12
Ordenador 1
Ordinateur 1
Ordner s. Verzeichnis
OSF s. Open Software Foundation
Outil s. Werkzeug
Owner s. Besitzer
Packard, D. 313
Page d’accueil s. Startseite
Pager 14
Parameter
¨
Ubergabe
124
aktueller P. 124
formaler P. 124
P. (Option) 12
Partagiciel s. Shareware
PASCAL 7, 28
Pascal, B. 313
Passage de param`etres s. Parameter¨
ubergabe
Sach- und Namensverzeichnis
Passerelle s. Gateway
Passphrase s. Passwort
Passwort 11
Patch 33
Pattern s. Muster
PC s. Computer
pc(1) 43
Peripherie 6
Permission s. Zugriffsrecht
Petabyte 4
Pfad s. Datei
Pfeiltaste s. Cursor
Pflichtenheft 36
Physiologie 2
PID s. Prozess-ID
Pile s. Stapel
Pilote s. Treiber
Pirate s. Cracker
Pisa, L. von 313
Pitch s. Schrift
Plattform s. System
Platzhalter 124
P LAUGER , P. J. 37
png s. Portable Network Graphics
Point size s. Schrift
Pointer
dangling P. 219
Darstellung 251
far P. 158
huge P. 158
near P. 158
Nullpointer 93, 219, 251
P. auf Funktion 124, 226
P. auf void 87, 220
P.-Arithmetik 93
Pointer 81, 91, 107, 219
Pointer (Fenster) s. Cursor
Pointeur s. Pointer
POP s. Post Office Protocol
portieren 250
Portrait s. Format
POSIX 62, 159
post (HTML) 244
Postel, J. B. 313
Poulsen, W. 313
¨
¨
Prasenz
s. Internet-Prasenz
¨
Praprozessor
(C) 20, 32, 77, 195, 289
Preference s. Vorrang
Primzahl 193, 222
Sach- und Namensverzeichnis
printf(3) 109, 112, 152, 287
Private Member 170
Pro nescia 49
Problem Management 61
Processus s. Prozess
prof(1) 50
Profiler 49
Programm
¨
andern
33
Anwendungsprogramm 6, 7
Aufgabenstellung 35, 36
benutzerfreundliches P. 34
Bottom-up-Entwurf 38
Codierung 31, 35, 37
Dokumentation 202
Effizienz 34
Entwurf 35
Fassung s. Version
fehlerfreies P. 33
Grund-Operation 38
Hauptprogramm 206
Patch 33
Pflege 35
Programm 3, 206
programmiererfreundliches P. 34
Prototyp 38
robustes P. 33
Struktur 37, 38
Test 35
Top-down-Entwurf 37
Version 33
Programmiersprache
ALGOL 28
algorithmische P. 23
Assembler 25, 26
BASIC 27
C 28
C++ 24, 29
COBOL 27
deklarative P. 24
FORTRAN 26
Freiburger Code 26
funktionale P. 24
HASKELL 24
imperative P. 23
JAVA 24
LISP 24
logische P. 24
maschinenorientierte P. 25
351
Maschinensprache 25
Mischen von P. 125
MODULA 28
objektorientierte P. 23
Paradigma 24
PASCAL 28
¨
pradikative
P. 24
problemorientierte P. 25
Programmiersprache 7
PROLOG 24
prozedurale P. 23
SCHEME 24
SMALLTALK 24
Sprachenfamilie 23
SQL 24
Programmierstil 34
Programmiertechnik 35
Programmierumgebung 61
Programmquelle 20
PROLOG 24
Prompt 11
Propri´etaire s. Besitzer
Prozess
Background s. Hintergrund
Foreground s. Vordergrund
Prozessor
CPU s. Zentralprozessor
Zentralprozessor 5
Public Member 170
Puffer s. Speicher
QIC s. Quarter Inch Cartridge
Qt-Toolkit 189
Qualifier s. Typ
¨
Qualitatsgewinn
15
Quantor s. Jokerzeichen
Quellcode 31
Quine 250
quit 12
r-Wert 102
¨
Ruckschritt
s. Backspace
Racine s. root
RAID s. Redundant Array of Independent Disks
RAM s. Speicher
rand(3C) 215
Random Access s. Zugriff, wahlfreier
Random Access Memory s. Speicher
random(3M) 215
352
ranlib(1) 51
RCS s. Revision Control System
read(2) 67, 108, 152, 165
realloc(3) 232
Realtime-System s. Echtzeit-S.
Rechenzentrum 3
Rechner 1
Rechtevektor s. Zugriffsrecht
Redirection s. Umlenkung
Redirektion s. Umlenkung
Referenz s. Pointer
Referenz-Handbuch 8, 13
Referenzebene 97
referenzieren 92, 107
Register s. Speicher
register (C) 99
¨ Datei s. Datei
Regulare
¨
Regularer
Ausdruck s. Ausdruck
Reis, J. P. 313
Rekursion 142
relozierbar 32
Remington, E. 313
R´epertoire s. Verzeichnis
R´epertoire courant s. Arbeitsverz.
R´epertoire de travail s. Arbeitsverz.
R´epertoire principal s. Home-Verz.
Request s. Druckauftrag
R´eseau s. Netz
R´eseau local s. Local Area Network
reserviertes Wort 81
Rest der Welt s. Menge der sonstigen
Benutzer
return (C) 120
¨
Returnwert s. Ruckgabewert
Revision Control System 54
RFC s. Request For Comments
Richtlinien (C) 34
Rienne-Vaplus, H¨ohle von R. 47
R ITCHIE , D. 28
rlog(1) (RCS) 55
RMS s. S TALLMAN, R. M.
robust 33
Rollkugel s. Trackball
ROM s. Speicher
Rootard s. Superuser
Routine s. Unterprogramm
RPC s. Remote Procedure Call
¨
Ruckgabewert
120, 125, 206
Rundungsfehler 85
Sach- und Namensverzeichnis
scanf(3) 109, 152, 287
SCCS s. Source Code Control System
Schalter (Option) 12
Schaltvariable s. Flag
SCHEME 24
Schickard, W. 313
¨
Schlusselwort
61, 77, 81, 159, 280
Schlappscheibe s. Diskette
Schleife (C) 115
Schleife, abweisende 115
Schleife, nichtabweisende 115
¨
Schleifenzahler
118
Schnittstelle
Centronics-S. s. parallele S.
Schnittstelle 6
Schrift
Pitch s. Weite
Point size s. Grad
Treatment s. Schnitt
Typeface s. Art
SCM s. Software Configuration Management
Scope s. Geltungsbereich
Screen s. Bildschirm
SCSI s. Small Computer Systems Interface
sdb(1) 48
Search engine s. Suchmaschine
Seed 216
Seiteneffekt s. Nebenwirkung
Seitenwechsel s. Paging
Sektion 13
Separator s. Trennzeichen
Sequenz 114
Serveur s. Server
Session s. Sitzung
SET s. Secure Electronic Transactions
SGML s. Structured Generalized
Markup Language
sh(1) s. Shell
S HANNON, C. E. 4
Shannon, C. E. 313
Shared Library 42
Shell
Batchfile s. Shellscript
Kommandoprozedur s. Shellscript
Makro s. Shellscript
Stapeldatei s. Shellscript
shift (C) 106
Sach- und Namensverzeichnis
S HNEIDERMAN, B. 40
Shockley, W. B. 313
short (C) 84
Shugart, A. 313
Sicherungskopie s. Backup
Sichtbarkeitsbereich s. Geltungsbereich
Signal (Qt) 189
Simsen s. Short Message Service
Single UNIX Specification 205
Sinnbild s. Icon
Site s. Host
Sitzung 11
size(1) 76
sizeof-Operator 111
Skalarprodukt 184
Slot 189
small (Speichermodell) 157
SMALLTALK 24, 30, 81
Smiley s. Grinsling
SMS s. Short Message Service
SMTP s. Simple Mail Transfer Protocol
Soft Link s. Link
Software 7
Software Configuration Management
61
Software Engineering 35
Solidus s. Zeichen
Sonderzeichen (Shell) s. Metazeichen
Source Code Control System 60
Source-Befehl (Shell) s. Punktscript
Sourcecode s. Quellcode
Souriard s. Grinsling
Souris s. Maus
Speicher
Arbeitsspeicher 5
¨
Datentrager
6
Diskette s. dort
dynamische Verwaltung 232
Festplatte s. dort
Hauptspeicher s. Arbeitsspeicher
Massenspeicher 6
¨
Medium s. Datentrager
Memory s. Arbeitsspeicher
MO-Disk s. dort
RAM s. Random Access Memory
Register 99
ROM s. Read Only Memory
Segmentierung 157
353
Speichermodell 43, 157
Stack s. Stapel
WORM s. dort
Zwischenspeicher s. Cache
Speicherbedarf 82
Speicherklasse (C)
auto 99, 101
extern 99
register 99
static 99, 101
Speicherplatz (C) 81
sperren s. quoten
splint 44
Sprung (C) 118
srand(3C) 215
srandom(3M) 215
SSI s. Server Side Include
Stack s. Speicher
Stallman, R. M. 313
Standard Template Library 179
Standard-C-Bibliothek 152
Standard-Mathematik-Bibliothek 154
Standardbibliothek 151, 157
Stapel-System s. Batch-System
Stapeldatei s. Shell
Stapelverarbeitung s. Batch-Betrieb
stat(2) 67, 164
static (C) 99, 216
statische Bindung 33
stdio.h 152, 197, 215
stdlib.h 215
Steilschiet s. Stylesheet
S TEINBUCH , K. 2, 337
Steinbuch, K. 313
STL s. Standard Template Library
stop 12
String 88, 94, 231
string(3) 67, 164
String-Deskriptor 64, 162
string.h 152
Stringfunktion 152
strings(1) 54, 76
strip(1) 76
strncmp(3) 67, 164
S TROUSTRUP, B. 29, 332
Stroustrup, B. 313
struct (C) 89
Structured Query Language 24
Struktur
354
Programmstruktur 37
Datenstruktur 38, 82
Kontrollstruktur s. Kontrollanweisung
Programmstruktur 38
Struktur (C) s. Typ
Strukturverweis (C) 107
Subarray 183
Subroutine s. Unterprogramm
Superutilisateur s. Superuser
Sutherland, I. E. 313
SVID s. System V Interface Definition
Switch s. Schalter
switch (C) 114
Symbol (Fenster) s. Icon
¨
Symbol (Wort) s. Schlusselwort
symbolischer Debugger s. Debugger
symbolischer Link s. Link
Synopsis 13
Syntax-Diagramm 78
¨
Syntax-Prufer
44
sys/stat.h 67, 164
Sysop s. Operator (System-O.)
Syst`eme d’exploitation s. Betriebssystem
System 7
Embedded S. 1
System call s. Systemaufruf
System primitive s. Systemaufruf
System, dyadisches s. Dualsystem
System-Manager s. Verwalter
System-Verwalter 11
Systemanfrage s. Prompt
Systemaufruf 61, 152, 159, 278
Systembefehl s. Shell-Kommando
Tableau s. Array
TAI s. Temps Atomique International
Tampon s. Puffer
T ANENBAUM , A. S. 325, 333
Target (make) 44
Task s. Prozess
Tastatur 5
TCP s. Transport Control Protocol
tcsh(1) s. Shell
Teilfeld s. Array
Tel e´ cran – tel e´ crit s. WYSIWYG
Template 180
Term s. Ausdruck
Sach- und Namensverzeichnis
Terminal
Terminal 5
terminfo(4) 211
Texinfo 205
Textfile 77
TFTP s. Trivial File Transfer Protocol
T HOMPSON, K. 28
T ICHY, W. F. 54
Tietokone 1
tiff s. Tag Image File Format
time(1) 49, 76
time(2) 63, 160, 215
time.h 215
times(2) 50
tiny (Speichermodell) 157
TLD s. Top Level Domain
Token 77
Tool s. Werkzeug
Top-down-Entwurf 37
Torvalds, L. B. 313
Treatment s. Schrift
Treiber
Compilertreiber 43
Trennzeichen (C) 77
Trombine s. Grinsling
Tube s. Pipe
Turing, A. 313
Typ
abstrakter Datentyp 170
alphanumerischer T. 85
Array 87
Attribut 82
¨
Aufzahlungstyp
91
Bitfeld 90, 251
boolescher T. 87
cdotprecision 184
char 85
character 251
cidotprecision 184
cimatrix 182
cinterval 181
civector 182
cmatrix 182
complex 181
const 82
cvector 182
dotprecision 184
double 85
einfacher Typ 83
Sach- und Namensverzeichnis
¨
erklaren
(cdecl) 83
externer T. 100
Feld s. Array
float 85
ganze Zahl 84
Gleitkommazahl 85
idotprecision 184
imatrix 182
int 84
interval 181
ivector 182
leerer T. s. void
long 84
long double 85
Pointer 91
Qualifier s. Attribut
real 181
Record s. Struktur
rmatrix 182
rvector 182
short 84
skalarer T. s. einfacher T.
starker T. s. System-Manager
Struktur 89
strukturierter T. s. zusammengesetzter T.
T. eines Operanden 81, 82
Typumwandlung 101, 110, 210
Union 90
unsigned 84
Variante s. Union
Vektor s. Array
Verbund s. Struktur
Vereinigung s. Union
void 87
volatile 82
Zeichentyp s. alphanumerischer T.
Zeiger s. Pointer
zusammengesetzter T. 87
typedef (C) 97
Typeface s. Schrift
types.h 67, 164
¨
Uberladung
103
¨
Ubersetzer
s. Compiler
¨
Ubersichtlichkeit
33, 196, 209
¨
Ubertragen
s. portieren
Uhr 63, 160
Umgehung 33
355
Union s. Typ
union (C) 90
UNIX
Editor s. vi(1)
Kommando 12
unsigned (C) 84
Unterprogramm 14, 62, 159
URI s. Universal Resource Identifier
URL s. Uniform Resource Locator
URN s. Uniform Resource Name
USB s. Universal Serial Bus
Usenet s. Netnews
User s. Benutzer
UTC s. Universal Time Coordinated
Utilisateur s. Benutzer
Utilitaire s. Dienstprogramm
Utility s. Dienstprogramm
utime(2) 76
utmp(4) 76
UTP s. Unshielded Twisted Pair
Valeur par d´efaut s. Defaultwert
Value s. Wert
varargs(5) 137
Variable
globale V. 99
lokale V. 99
register-V. 99
Variante s. Typ
Vektor (Typ) s. Typ
Verantwortung 16
Vereinbarung 81
Vereinigung s. Typ
Vererbung (Klassen) 172
Vergleich 105
¨
Verknupfung
s. Link, weicher
Vermittlungsschicht s. Netzschicht
verschieblich s. relozierbar
Version 33
Versionskontrolle 54
Verteiler-Liste s. Liste
Verwalter
System-V. 11
Verzeichnis
Benutzer-V. s. Home-V.
Haus-V. s. Home-V.
Heimat-V. s. Home-V.
root-V. s. Wurzel-V.
Verzweigung (C) 114
356
Verzweigung (News) s. Thread
void (C) 87
volatile (C) 82
Vordergrund s. Prozess
Vorlesung 8
Vorrang (C) 111
W3 s. World Wide Web
WAN s. Wide Area Network
Waterfall approach 35
Weissinger, J. 313
Weiterbildung 16
Wert 81
¨
Wertubergabe
125
Wertebereich 82
while-Schleife (C) 115
who(1) 76
Widget 156, 189
Wildcard s. Jokerzeichen
Willensfreiheit 16
Window s. Fenster
Windows (Microsoft) 189
W IRTH , N. 28, 330
Wizard 10
Workaround s. Umgehung
Wort, reserviertes 81
Wortsymbol 81
Wozniak, S. G. 313
write(2) 108, 152
Wurzel s. root
WWW s. World Wide Web
X Window System 189
X11 s. X Window System
Xanadu 10
xdb(1) 48, 75
Xlib 156
XML s. Extensible Markup Language
xstr(1) 54
Xt 156
Yellow Pages s. Network Information
Service
YP s. Yellow Pages
Zahl
ganze Z. 84
Gleitkommazahl 85
Integer s. ganze Z.
komplexe Z. 30, 256
Sach- und Namensverzeichnis
Primzahl 193, 222
Pseudo-Zufallszahl 218
Zufallszahl 215
Zahlensystem 259
Zeichen
aktives Z. s. Metazeichen
ampersand s. et-Zeichen
commercial at s. Klammeraffe
Formfeed s. Seitenvorschub
¨
Gegenschragstrich
s. Backslash
Hashmark s. Doppelkreuz
Linefeed s. Zeilenvorschub
¨
Solidus s. Schragstrich
Zwischenraum s. Space
Zeichenkette s. String
Zeichensatz
ASCII 265
EBCDIC 265
IBM-PC 265
Latin-1 272
ROMAN8 265
Zeiger (Array) s. Array
Zeiger (Marke) s. Cursor
Zeiger (Typ) s. Typ
Zeilenende s. Zeilenwechsel
Zeilenkommentar (C++) 80
¨
Zeituberschreitungsfehler
s. Timeout
Zeitersparnis 15
Zeitschrift 8, 337
Zeitstempel s. Datei
Z EMANEK , H. 15, 337
Zentraleinheit s. Prozessor
Zettabyte 4
Ziel (make) 44
Zirkeldefinition 142
Zirkelschluß 142
zitieren s. quoten
Zufallszahl 215
Zugangsberechtigung s. Account
Zugriff
Zugriffsrecht s. Datei
Zugriffssteuerungsliste s. Access Control List
¨
Zurucksetzen
s. Reset
Z USE , K. 337
Zuse, K. 313
ZUSE Z22 26
ZUSE Z 22 313
Zuweisung 101, 113
Sach- und Namensverzeichnis
Zweierkomplement 249
Zweiersystem s. Dualsystem
Zwischenraum s. Space
357
Was this manual useful for you? yes no
Thank you for your participation!

* Your assessment is very important for improving the work of artificial intelligence, which forms the content of this project

Download PDF

advertisement