Methoden der imperativen Programmierung: Mit Beispielen in MODULA-2 und EIFFEL

472 Pages·1993·32.713 MB·German

by  Dr. rer. nat. Hans-Georg Stork (auth.)

Leitfäden der angewandten Informatik
H.-G. Stork
Methoden der imperativen Programmierung
Leitfaden der angewandten Informatik
Herausgegeben von
Prof. Dr. Hans-Jürgen Appelrath, Oldenburg
Prof. Dr. Lutz Richter, Zürich
Prof. Dr. Wolffried Stucky, Karlsruhe
Die Bände dieser Reihe sind allen Methoden und Ergebnissen der Infor
matik gewidmet, die für die praktische Anwendung von Bedeutung sind.
Besonderer Wert wird dabei auf die Darstellung dieser Methoden und
Ergebnisse in einer allgemein verständlichen, dennoch exakten und präzi
sen Form gelegt. Die Reihe soll einerseits dem Fachmann eines anderen
Gebietes, der sich mit Problemen der Datenverarbeitung beschäftigen
muß, selbst aber keine Fachinformatik-Ausbildung besitzt, das für seine
Praxis relevante Informatikwissen vermitteln; andererseits soll dem Infor
matiker, der auf einem dieser Anwendungsgebiete tätig werden will, ein
Überblick über die Anwendungen der Informatikmethoden in diesem
Gebiet gegeben werden. Für Praktiker, wie Programmierer, Systemanaly
tiker, Organisatoren und andere, stellen die Bände Hilfsmittel zur Lösung
von Problemen der täglichen Praxis bereit; darüber hinaus sind die Ver
öffentlichungen zur Weiterbildung gedacht.
Methoden der
imperativen Programmierung
Mit Beispielen in MODULA-2 und EIFFEL
Von Dr. rer. nat. Hans-Georg Stork, Luxemburg
EI3
B. G. Teubner Stuttgart 1993
Dr. rer. nato Hans-Georg Stork
1947 in Frankfurt a.M. geboren. Von 1966 bis 1971 Studium der Mathematik, Physik
und Computer Science an den Universitäten Frankfurt a.M. und Iowa City, Iowa, USA.
Von 1972 bis 1976 Wissenschaftlicher Mitarbeiter im Fachbereich Informatik der TH
Darmstadt. Von 1976 bis 1978 Wissenschaftlicher Assistent an der Universität Stuttgart,
Fakultät für Informatik. Von 1978 bis 1983 Industrietätigkeit (AEG-Telefunken und
SESA Deutschland GmbH). Von 1983 bis 1990 Wissenschaftlicher Mitarbeiter (AT)
und Lehrbeauftragter am Institut für Angewandte Informatik und Formale Beschrei
bungsverfahren der Universität Karlsruhe. Seit 1990 Angestellter der EG Kommission
in Ispra (Italien) und Luxemburg.
Die Deutsche Bibliothek - CIP-Einheitsaufnahme
Stork, Hans-Georg:
Methoden der imperativen Programmierung: mit Beispielen in
MODULA-2 und EIFFEL I von Hans-Georg Stork. -
Stuttgart : Teubner, 1993
(Leitfäden der angewandten Informatik)
ISBN 978-3-519-02416-3 ISBN 978-3-322-94660-7 (eBook)
DOI 10.1007/978-3-322-94660-7
Das Werk 'einschließlich aller seiner Teile ist urheberrechtlich geschützt. Jede Verwertung außer
halb der engen Grenzen des Urheberrechtsgesetzes ist ohne Zustimmung des Verlages unzulässig
und strafbar. Das gilt besonders für Vervielfältigungen, Übersetzungen, Mikroverfilmungen und die
Einspeicherung und Verarbeitung in elektronischen Systemen.
© B. G. Teubner Stuttgart 1993
Gesamtherstellung: Zechnersche Buchdruckerei GmbH, Speyer
Umschlaggestaltung: Tabea und Martin Koch, OstfildernlStuttgart
Karl Stork
(1907 - 1992)
zum Gedächtnis
Vorwort
Seit Anfang der siebziger Jahre gibt es an der Universität Karlsruhe die Möglich
keit, das Fach "Wirtschaftsingenieurwesen" mit dem Schwerpunkt Informatik zu
studieren. Studenten, die sich für diesen Schwerpunkt entscheiden, wird - ne
ben einführenden Vorlesungen über Mathematik und aus dem Bereich der Wirt
schaftswissenschaften - eine breite Grundausbildung in Informatik angeboten.
Deren Kern ist ein viersemestriger Kurs, welcher die wichtigsten Kenntnisse
zum Verständnis des Aufbaus, des Betriebs und der Anwendung von Rechnern
vermittelt. Zur Befriedigung eines eher "akademischen" Erkenntnisinteresses
wird dabei - und dies gilt durchaus für den gesamten Studiengang - ganz bewußt
der Nutzen hinzukalkuliert, den ein solches Wissen und die damit verbundenen
Fertigkeiten für die berufliche Qualifikation der Absolventen haben sollten.
Dieses praktische Interesse ist sicher eine der stärksten Motivationen dafür,
daß immer häufiger Themen für abschließende Diplomarbeiten angeboten und
gewählt wurden, welche die Spezifikation, den Entwurf und die Implementierung
größerer Programme beinhalteten, mitunter auch als Teile umfangreicher und
länger laufender Projekte. Bei der Anfertigung und Betreuung solcher Arbeiten
wurde für Lernende und Lehrende nicht selten ein Mangel erkennbar, der offen
bar auf eine Lücke im Lehrangebot zurückzuführen war: Vielen Studenten fehl
te ein hinreichend klares Bewußtsein für das, was die Qualität eines Software
Produktes ausmacht, ganz zu schweigen von einem guten Verständnis der Mög
lichkeiten, diese Qualität zu erzielen. Die während des ersten Semesters geüb
te Programmierung beschränkte sich in der Regel auf kleine, isolierte Beispiele,
auf Illustrationen zum Begriff des Algorithmus, und für eine ausführliche Darle
gung relativ einfacher Tips zur Programmgestaltung oder gar von Verfahren zur
systematischen Herleitung der Gliederung und Feinstruktur größerer Programme
gab es einfach nicht genug Zeit.
Abhilfe wurde zu Beginn der achtZiger Jahre geschaffen: Durch Bereicherung
des Curriculums um eine Vorlesung mit zugeordnetem Praktikum unter dem
Titel "Programmier-Methodik". Den Studenten wurde damit eine Gelegenheit
gegeben, die (potentiell lange) "programmierfreie Zeit" zu unterbrechen und -
begleitet von den öffentlichen {und privaten} Ratschlägen des Dozenten - ge
meinsam mit Kommilitonen im "Teamwork" ein Semesterprojekt zu bearbeiten.
Dessen Ergebnis, ein (hoffentlich) lauffähiges Programm und die Dokumentati
on seiner Entwicklung, konnte dann einen willkommenen Beitrag zur Aufbesse
rung der Vordiplom-Note leisten.
Damit sind der Grund und die Entstehungsgeschichte dieses Buches im wesent
lichen schon fast erklärt. Während meiner Zeit als Mitarbeiter und Lehrbeauf
tragter am Institut für Angewandte Informatik und Formale Beschreibungsver
fahren der Universität Karlsruhe in den Jahren von 1983 bis 1990 nämlich, hatte
VII
ich mehrere Male das Vergnügen, jene Vorlesung über "Programmier-Methodik"
zu halten und das zugehörige Praktikum zu organisieren. Und manche Studenten
waren von der Arbeit unmittelbar am Rechner 1 so begeistert und von den dabei
erfahrenen Erfolgs- oder Mißerfolgserlebnissen so angespornt, daß sie es nicht
versäumten, auch meine ergänzende und weiterführende Vorlesung "Software
Engineering" zu besuchen.
Das vorliegende Buch enthält also eine Auswahl und Synthese von Themen, die
in diesen Vorlesungen zur Sprache kamen. (Stellenweise ist die Darstellung
etwas detaillierter und stellenweise ist sie etwas breiter, als sie den Hörern
erinnerlich sein mag.) Ursprünglich angeregt wurde es von Hans-Werner Six,
der - einem Ruf an die Fernuniversität Hagen gefolgt - mir den Vorschlag mach
te, die Vorlesungen zu einem Korrespondenzkurs umzuarbeiten. Obwohl dieser
Vorschlag nicht in die Tat umgesetzt wurde, gab er doch zunächst Anlaß zur
Niederschrift einiger Abschnitte, die immerhin soweit gedieh, daß Wolffried
Stucky, mein Institutschef und Mitherausgeber der "Leitfaden", mich dazu be
wog, an einer langen Geschichte weiterzuschreiben und ihr die Form eines Bu
ches zu geben. Beiden Herren danke ich für die gründliche Lektüre früher Ver
sionen einzelner Kapitel und fur manchen wertvollen Fingerzeig.
Danksagungen müssen selbstverständlich ergehen an die vielen Autoren, welche
die Bausteine für ein Lehrbuch wie dieses geformt und geliefert haben. Zu nen
nen sind hier in erster Linie und stellvertretend fur manche andere: D. Gries,
J. V. Guttag, M. Jackson, B. W. Kernighan, H. F. Ledgard, B. Meyer, D. L. Par
nas, C. A. Petri, N. Wirth und D. Wood.
Einen speziellen Dank schulde ich freilich Hans-Jürgen Ehling, meinem Mentor
während meiner Zeit beim Software-Zentrum des damaligen AEG-Telefunken
Konzerns. Er war mir ein Meister des Programmierens, und er wird es mir hof
fentlich nachsehen, wenn er von der hohen Kunst, mit der er die von Warnier
und Orr begründete Klammerdiagramm-Technik weiterentwickelte, in diesem
Buch nur einen schwachen Abglanz entdeckt.
Die genannten Namen deuten schon an, daß sich die Auswahl des Stoffes flir
ein Buch wie dieses weitgehend an den Interessen und Vorlieben des Autors
orientieren wird, und natürlich auch an dem, was er fur hinreichend fundiert
und praktikabel zugleich hält. Dies mag manche Erwartungen enttäuschen. Doch
mir schien, daß es für unser Gebiet genügend Literatur von enzyklopädischem
Charakter gibt, um nicht noch ein weiteres Exemplar dieser Art hinzuzufugen.
Die Beschränkung des Gesichtskreises auf Methoden, welche üblicherweise
dem imperativen Paradigma des Programmierens (vgl. Kapitel 1) zugerechnet
werden, ergab sich übrigens ganz von selbst aus dem oben skizzierten Zweck
der Vorlesungen.
Zu erklären ist noch die Wahl von MODULA-2 als diejenige Programmierspra
che, in der wir erstens über "Stil" reden, und in die wir zweitens mehr oder
1 Der schaute in den frühen achtziger Jahren noch vergleichsweise imposant aus und
konnte seinem Beherrscher ein gewisses Gefühl des Stolzes geben.
VIII
weniger abstrakte Konzepte zur Gliederung von Programmen abbilden. Zunächst
einmal: Ohne die Bezugnahme auf eine konkrete Programmiersprache müßten
- insbesondere aus der Sicht des Lernenden - auch die besten Ideen über Soft
ware-Entwicklung "in der Luft" hängenbleiben; dem wird wohl jedermann zu
stimmen (mancher vielleicht nolens volens.) Warum aber MODULA-2? Die Ant
wort ist denkbar einfach: Es ist die Sprache, welche unsere Studenten als erste
lernen, mit der sie also am besten vertraut sein sollten. In der Tat ist dies eine
Grundvoraussetzung für die Beschäftigung mit diesem Buch, und es ist wichtig,
in aller Deutlichkeit auf sie hinzuweisen: Wir nehmen an, daß der Leser einige
Kenntnisse über MODULA-2 und möglichst auch etwas praktische Erfahrung
mit der Anwendung dieser Sprache besitzt. Er kann sich diese Kenntnisse im
Selbststudium erwerben (dafür hilfreiche Literatur sowie auf Personal Compu
tern laufende MODULA-2 Compiler gibt es ja in Hülle und Pülle) oder er kann
sich an der Universität Karlsruhe für den ersten Teil des oben erwähnten Grund
kurses in Informatik einschreiben.
Doch um der Wahrheit die Ehre zu geben: Irgendwann im Verlauf unserer Reise
durch die "Methodenlandschaft" wird das Gelände auch für ein ansonsten sehr
wendiges Vehikel wie MODULA-2 unwegsam werden, und wir müssen auf ein
stärkeres und vielseitigeres Gefährt umsteigen. Es wird EIFFEL sein, die von
B. Meyer konzipierte "objektorientierte" Sprache. Wir werden ihre Wahl an ge
eigneter Stelle begründen. Nur soviel vorweg: Eine Kenntnis dieser Program
miersprache setzen wir nicht voraus, doch hoffen wir, beim Leser soviel Inter
esse fur sie zu erwecken, daß er es für Wert hält, ihr ein intensiveres Studium
zu widmen.
Frühjahr 1993
Hans-Georg Stork
Inhaltsverzeichnis
1. Imperative Programmierung 1
1.1 Maschine und Sprache 2
1.2 Ziele und Wege 12
Literatur zu Kapitel 1 16
2. Qualität und Stil "im Kleinen" 17
2.1 Programm-Qualität 18
2.1.1 Korrektheit 19
2.1.2 Integrierbarkeit 24
2.1.3 Wartbarkeit 25
2.1.4 Effizienz 27
2.2 Programmierstil .................................. 30
2.2.1 Dokumentation und Selbstdokumentation ................ 30
2.2.2 Aspekte der strukturellen Komplexität ................ 42
2.3 Einfache Maßnahmen zur Verbesserung der Effizienz ................ 50
2.3.1 Allgemeine Überlegungen .................................. 51
2.3.2 Spezielle Regeln .................................. 52
Literatur zu Kapitel 2 ... ...... ... ....... ..... ... ... .... 61
3. Schrittweise Verfeinerung .................................. 63
3.1 Schrittweise Verfeinerung als Entwurfstechnik ................ 64
3.2 Zwei Beispiele .................................. 66
3.2.1 Folgedatum ........................ .......... 67
3.2.2 Acht Damen .................................. 80
3 .3 Diagramm-Techniken zur Unterstützung
"Schrittweiser Verfeinerung" 96
3.3.1 Nassi-Shneiderman-Diagramme 99
3.3.2 Klammerdiagramme 104
Literatur zu Kapitel 3 110
4. Programmieren durch Beweisen 111
4.1 Prädikate 112
4.1.1 Speicher und Variable 112
4.1.2 Operationen mit Prädikaten 114
4.1.3 Prädikate als Kommentare 120
4.2 Semantik 124
4.2.1 Schwächste Vorbedingungen 124
4.2.2 Zuweisungen und Sequenzen 129
4.2.3 Selektionen 131
4.2.4 Iterationen 135
x
4.3 Zielorientierte Programmentwicklung .................................. 1 44
4.3.1 Konstruktion von Selektions-Anweisungen ................ 145
4.3.2 Konstruktion von Iterations-Anweisungen ................ 148
4.3.3 Zur Auffindung von Schleifen-Invarianten ................ 157
Literatur zu Kapitel 4 .................................. 164
5. Datenstrukturierter Programm-Entwurf .................................. 165
5.1 Objektstruktur und Programmstruktur .................................. 169
5.1.1 Strukturbeschreibungen .................................. 169
5.1.2 Produktion von Datenobjekten .................................. 179
5.1.3 Analyse von Datenobjekten .................................. 185
5.2 Programm-Konstruktion aus Input und Output ................ 199
5.2.1 Das Verfahren in seiner einfachsten Form ................ 200
5.2.2 Verarbeitung mehrerer Input-Ströme .................................. 209
5.2.3 Strukturkonflikte und ihre Auflösung .................................. 222
Literatur zu Kapitel 5 .................................. 227
6. Aspekte der Programmierung im GroBen .................................. 228
6.1 Softwaresysteme .................................. 229
6.2 Qualität "im GroBen" und Software-Engineering ................ 234
6.2.1 Korrektheit und die Folgen .................................. 234
6.2.2 Integrierbarkeit und die Folgen .................................. 241
6.2.3 Wartbarkeit und die Folgen .................................. 245
6.2.4 Benutzungsfreundlichkeit .................................. 253
6.2.5 Software-Engineering .................................. 258
6.3 Systemanalyse und Systemspezifikation .................................. 262
6.3.1 Realwelt-Modelle fur die Software-Spezifikation ................ 264
6.3.2 Petrinetze .................................. 272
6.3.3 "Jackson System Development" .................................. 284
6.3.4 Hierarchische Systemmodelle .................................. 305
6.4 Systementwurf und Systemimplementierung .................................. 317
6.4.1 Ziele und Techniken .................................. 321
6.4.2 Modularisierung .................................. 330
6.4.3 Abstrakte Datentypen .................................. 357
6.4.4 Objekte, Klassen und Vererbung .................................. 379
6.4.5 Parallele Prozesse .................................. 424
Literatur zu Kapitel 6 .................................. 447
Stichwortverzeichnis 451