Erfolgreich Programmieren mit Ada: Unter Berücksichtigung des objektorientierten Standards

440 Pages·1994·9.68 MB·German

by  Prof. Dr. Diana Schmidt (auth.)

Diana Schmidt
Erfolgreich
Programmieren
mitAda
Unter Berücksichtigung
des objektorientierten Standards
Springer-Verlag Berlin Heidelberg GmbH
Prof. Dr. Diana Schmidt
Studiengang Medizinische Informatik
der Universität HeidelberglFH Heilbronn
Fachhochschule Heilbronn
Max-Planck-Straße 39
D-7408l Heilbronn
Die Deutsche Bibliothek - CIP-Einheitsaufnahme
Schmidt, Diana: Erfolgreich progranunieren mit Ada: unter Berücksichtigung des objektorientierten
Standards 1 Diana Schmidt. -Berlin; Heidelberg; New York; London; Paris; Tokyo; Hong Kong;
Barcelona; Budapest: Springer, 1994
ISBN 978-3-642-63407-9 ISBN 978-3-642-57935-6 (eBook)
DOI 10.1007/978-3-642-57935-6
Dieses Werk ist urheberrechtlich geschützt. Die dadurch begründeten Rechte, insbesondere die der
Übersetzung, des Nachdrucks, des Vortrags, der Entnahme von Abbildungen und Tabellen, der
Funksendung, der Mikroverfilmung oder der VervieWiltigung auf anderen Wegen und der Speiche
rung in Datenverarbeitungsanlagen, bleiben, auch bei nur auszugs weiser Verwertung, vorbehalten.
Eine Vervielfaltigung dieses Werkes oder von Teilen dieses Werkes ist auch im Einzelfall nur in den
Grenzen der gesetzlichen Bestimmungen des Urheberrechts gesetzes der Bundesrepublik Deutsch
land vom 9. September 1965 in der jeweils geltenden Fassung zulässig. Sie ist grundsätzlich
vergütungspflichtig. Zuwiderhandlungen unterliegen den Strafbestimmungen des Urheberrechts
gesetzes.
© Springer-Verlag Berlin Heidelberg 1994
Ursprünglich erschienen bei Springer-Verlag Berlin Heidelberg New York 1994
Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk
berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, daß solche Namen im Sinne
der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wären und daher von
jedermann benutzt werden dürften.
Umschlaggestaltung: Konzept & Design, lIvesheim
SPIN 10059695 45/3140 - 5 4 3 2 I 0 - Gedruckt auf säurefreiem Papier
Vorwort
Als Ada 1983 auf den Markt kam, war es die einzige standar
disierte Sprache, die in gro:Bem Umfang anerkannte Prinzipien
des Software Engineering unterstutzte. Die Skepsis war gro:B, ob
durch Anwendung dieser Prinzipien mit Ada wirklich transpa
rente, zuverHissige und wartbare Softwaresysteme piinktlich fer
tiggestellt werden konnen. Zwischen Anspruch und Wirklichkeit
klafft ja nur allzu oft eine gro:Be Lucke.
Heute konnen wir auf elf Jahre Erfahrung mit Ada zuruck
blicken. Es hat sich gezeigt, da:B das Codieren und Ubersetzen
einer gro:Beren Anwendung in Ada etwas Hinger dauern kann als in
manchen anderen Sprachen, dafiir aber die Anzahl der nach der
Ubersetzung verbliebenen Fehler und der Aufwand, sie zu lokali
sieren, auf einen Bruchteil reduziert wird. Insgesamt bringt Ada
also schon bis zum Ende der Testphase eine erhebliche Kostener
sparnis - vorausgesetzt, man wendet die Programmierprinzipien
an, die Ada unterstutzt. In der Wartungsphase (also bei Feh
lerbehebung, funktionalen Anderungen und Portierungen), die
bei gro:Ben Programmsystemen typischerweise mehr kostet als
die Hardware und die Programmerstellung zusammengenommen,
zeigt Ada genauso gro:Be Vorteile wie in der Testphase.
Die Erfahrung der fruhen Jahre, da:B man den Einsatz von
Ada mit ineffizientem Code bezahlen mu:B, gilt auch Hingst nicht
mehr. Wer also heute ein gro:Beres Programm entwickelt, hat al
len Grund, es in Ada zu schreiben. Dieses Buch solI die notigen
Kenntnisse der Sprache und der dazugehorigen Methoden vermit
teln. Es behandelt dabei auch objektorientierte Methoden und
ihren Einsatz in der unmittelbar bevorstehenden neuen Version
der Sprache.
An der Entstehung dieses Buches waren viele Menschen betei
ligt, denen ich danken mochte. Das Buch ist aus Ada-Schulungen
VI Vorwort
entstanden, die ich seit 1986 entwickle und halte und immer wie
der aufgrund der Reaktionen der Schulungsteilnehmer verbes
sert und ausgebaut habe; ihre Aufierungen und VorschHige ha
ben also wesentlich dazu beigetragen. Georg Winterstein regte
mich dazu an, das Buch zu schreiben; seinen Hinweisen verdanke
ich wert voile Erkenntnisse, die in dieses Buch eingefiossen sind.
Von meinen ehemaligen Koilegen bei Alsys GmbH habe ich sehr
viel iiber Methoden und Prinzipien erfolgreichen Programmierens
und iiber Ada gelernt. Sie haben die Compiler gebaut, die aile
Programmbeispiele und Musterlosungen in diesem Buch iiber
setzt haben, und sie waren immer gerne bereit, ihr Konnen ein
zusetzen und mir mit Rat und auch praktischer Hilfe beizuste
hen. Insbesondere haben Manfred Dausmann, Wolf-Dieter He
ker, Wolfgang Herzog und Erich Zimmermann durch kritisches
Lesen groBerer Teile des Manuskripts und Diskussionen iiber sei
nen Inhalt das Buch ganz entscheidend verbessert. Wolfgang
Herzog hat auBerdem mit groBer Geduld viele mehr oder weniger
kniffiige Ada-Fragen beantwortet. Hans Wossner und Barbara
Gangler vom Springer-Verlag verdanke ich viele Verbesserungen
im groBen und im kleinen, die die endgiiltige Form des Buches
wesentlich beeinfiufit haben.
Ganz besonders danke ich meiner Familie: Robin gestaltete
die Bilder, Martin lieferte den notigen Optimismus, Christopher
stand mir als PC-Experte zur Seite, und mein Mann Norbert
setzte sich immer iiberail ein, wo noch Hilfe notig war.
Karlsruhe, Juli 1994 Diana Schmidt
Inhalt sverzeichnis
1 Einleitung ....................................... 1
1.1 Die Terminologie ................................. 2
1.2 Die Programmbeispiele ..... . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Die Ubungsaufgaben ............................. 3
1.4 Ada 9X ................................... ........ 4
2 Der Werdegang von Ada ..................... 5
2.1 Die Software-Krise ............................... 5
2.2 Ein Weg aus der Krise ........................... 7
2.3 Die Suche nach einer Sprache .................... 8
2.4 Verbesserung und Standardisierung ............. 10
2.5 Chronologischer Uberblick ....................... 11
2.6 Was ist Validierung? ............................. 12
2.7 Die Entwicklungsumgebung ...................... 13
3 Erfolgreiches Programmieren und Ada ... 15
3.1 Abstraktion ....................................... 16
3.1.1 Abstraktion von Daten........................... 17
3.1.2 Abstraktion von Aktionen ....................... 18
3.2 Programmentwurf ...................... '" .. .. . . . 19
3.3 Lesbarkeit und Transparenz ..................... 22
3.4 Modularisierung und getrennte Ubersetzung .... 24
3.5 Spezifikation, Schnittstelle, Implementierung ... 24
3.6 Geheimnisprinzip ................................. 25
3.7 Arbeitsteilung .................................... 26
3.8 ZuverHissigkeit .................................... 27
3.8.1 Strenge Typisierung .............................. 28
3.8.2 Laufzeitfehlerkonzept. . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
VIII IrUrraltsverzeichIlls
3.9 Wiederverwendbarkeit ........................... 29
3.10 Wartbarkeit ...................................... 29
3.11 Portierbarkeit .................................... 30
3.12 Maschinennahes Programmieren ................. 30
3.13 Parallele Prozesse und Echtzeit .................. 31
3.14 Sprachiibersicht ............................... " . 31
4 Ein einfaches Ada-Programm ............... 33
4.1 Bemerkungen zur Syntax 35
5 Anweisungen ................................... 39
5.1 Einfache Anweisungen ........................... 40
5.2 Bedingte Anweisungen ........................... 42
5.2.1 Die IF-Anweisung ................................ 42
5.2.2 Die CASE-Anweisung ............................ 45
5.3 LOOP-Anweisungen .............................. 47
5.4 Blockanweisungen ................................ 52
5.5 Ubung 1: Anweisungen .......................... 54
6 Unterprogramme . ......... .................... 57
6.1 Unterprogramme und ihre Schnittstellen ........ 59
6.2 Die Implementierung eines Unterprogramms .... 61
6.3 Lokale Unterprogramme ......................... 62
6.4 Stummel und Untereinheiten .................... 67
6.5 Explizite Unterprogrammvereinbarungen ........ 70
6.6 Verdecken und Uberladen ........................ 72
6.7 Bibliotheksunterprogramme .. . . . . . . . . . . . . . . . . . . . . 75
6.8 Unterprogramme und das Geheimnisprinzip .... 78
6.9 Spezifikation des Vokabel-Trainers ............... 78
6.9.1 Funktionaler Uberblick ........................... 79
6.9.2 Funktionale Beschreibung ........................ 79
6.10 Ubung 2: Entwurf eines Ada-Programms ....... 80
6.10.1 Objekte, Aktionen und Eigenschaften ........... 81
6.10.2 Was bezieht sich auf welches Objekt? ........... 83
6.10.3 Formulierung in Ada ............................. 84
6.11 Losung zur Entwurfsiibung ...................... 85
Inhaltsverzeichnis IX
6.11.1 Objekte, Aktionen und Eigenschaften ........... 85
6.11.2 Ada-Darstellung der Objekte .................... 86
6.11.3 Ada-Darstellung der Aktionen/Eigenschaften ... 87
6.12 Ubung 3: Aufruf von Unterprogrammen ........ 89
7 Daten: Typen und Objekte ................. 93
7.1 Aufzahlungstypen ................................ 95
7.2 Operatoren ....................................... 101
7.3 Der Typ boolean................................. 102
7.4 ARRAY-Typen ................................... 104
7.4.1 Uneingeschrankte ARRAY-Typen ............... 108
7.4.2 Aggregate und Ausschnitte ...................... 110
7.4.3 Mehrdimensionale ARRAYs ..................... 113
7.4.4 Attribute und Operatoren ....................... 115
7.5 RECORD-Typen ................................. 116
7.5.1 RECORDs mit Variantenteil .................... 118
7.5.2 Mehr RECORD-Typen mit Diskriminanten .... 121
7.5.3 Diskriminanten mit Vorbesetzung ............... 125
7.6 ACCESS-Typen .................................. 126
7.7 Verkettete Strukturen ............................ 130
7.8 Numerische Typen ............................... 133
7.8.1 Gleitpunkttypen .................................. 137
7.8.2 Festpunkttypen ................................... 141
7.9 Abgeleitete Typen, Typkonvertierung ........... 143
7.10 Ubung 4: Typen und Unterprogramme ......... 147
8 Pakete ........................................... 149
8.1 Ein einfaches Paket .............................. 150
8.2 Die USE-Klausel ................................. 151
8.3 Der Aufbau eines Pakets ......................... 156
8.4 Ein Paket mit Implementierungsdetails ......... 158
8.4.1 Anwendung des Pakets ........................... 161
8.4.2 Der Paketrumpf .................................. 162
8.5 Ein weiteres Paketbeispiel ....................... 164
8.6 Private Typen .................................... 169
8.7 LIMITED PRIVATE Typen ..................... 172
8.8 PACKAGE liste mit privatem Typ .............. 175
8.9 Paket mit Anweisungen .......................... 178
8.10 Ubung 5: Anwendung eines Pakets .............. 179
x
Inhaltsverzeichnis
9 Getrennte Ubersetzung ...................... 183
9.1 Die Bibliothek .................................... 183
9.2 Ubersetzungseinheiten ........................... 184
9.3 Abhangigkeiten zwischen Einheiten ............. 185
9.4 Ein Beispiel.. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 187
9.4.1 Eine Alternativstruktur .......................... 190
9.5 Modulare Struktur eines Ada-Programms ....... 191
9.6 Ubung 6: Sichtbarkeit im Ada-Programm ....... 192
9.7 Ubung 7: Struktur des Vokabel-Trainers ........ 193
9.8 Lasung zu Ubung 6 .............................. 194
9.9 Lasung zu Ubung 7 .............................. 195
10 Abarbeitung .................................... 199
10.1 Lokale Abarbeitungsfehler ....................... 201
10.2 Abarbeitung von Bibliothekseinheiten ........... 203
10.3 PRAGMA elaborate ............................. 206
11 Ein-/ Ausgabe .................................. 211
11.1 Textausgabe ...................................... 212
11.2 Textausgabe von Zahlen und Aufzahlungswerten 215
11.3 Portable benutzerdefinierte Ein-/ Ausgabe ...... 220
11.4 Texteingabe ...................................... 222
11.5 Texteingabe von Zahlen und Aufzahlungswerten 225
11.6 Ubung 8: Text-Ein-/ Ausgabe .................... 227
11.7 Umgang mit Dateien ............................. 228
11.8 Ubung 9: Ein-/ Ausgabe im internen Format .... 231
12 Schablonen ..................................... 237
12.1 Eine einfache generische Prozedur ............... 240
12.2 Auspragungen als Bibliothekseinheiten .......... 243
12.3 Die Ubersetzungsreihenfolge bei Schablonen .... 245
12.4 PACKAGE liste als Schablone ................... 246
12.5 Ein generisches Mengenpaket .................... 248
12.6 Eine generische formale Prozedur ................ 253
12.7 Eine generische formale Funktion ................ 257
12.8 Ubung 10: Schablonen ........................... 263
Inhaltsverzeichnis XI
13 Fehler ............................................ 269
13.1 Ausnahmen ....................................... 269
13.2 Das Auslosen von Ausnahmen ................... 271
13.3 Primitive Ausnahmebehandler ................... 273
13.4 Ausnahmen behandeln und weiterreichen ....... 276
13.5 Wiederholungsversuche .......................... 278
13.6 Weiterreichen von Ausnahmen ................... 281
13.7 Ubung 11: Ausnahmebehandlung ............... 283
13.8 Ubung 12: Ausnahmebehandlung ............... 283
13.9 Ubung 13: Programmerweiterung ............... 283
13.10 Fehler, die das Ada-System nicht erkennt ....... 284
13.10.1 Erroneous execution .............................. 284
13.10.2 Incorrect order dependences ..................... 286
14 Parallele Prozesse............................. 291
14.1 Einleitung ........................................ 291
14.2 Rendezvous ....................................... 292
14.2.1 Variant en des ENTRY-Aufrufs .................. 293
14.2.2 Variant en der ACCEPT-Anweisung ............. 294
14.3 Vergabe knapper Ressourcen .................... 294
14.4 Identische TASKs ................................ 296
14.5 Aktivierung von TASKs .......................... 298
14.6 Beendigung von TASKs .......................... 299
14.7 Beispiele .......................................... 300
14.7.1 Beispiel: Privatparkplatz ........................ 300
14.7.2 Beispiel: Parkplatzgebiihren ..................... 303
14.7.3 Beispiel: Viele Autos ............................. 307
14.7.4 Beispiel: Verschiedenartige Autofahrer .......... 311
14.7.5 Beispiel: Taglicher Feierabend ................... 318
14.7.6 Beispiel: Mehrklassen-Parkhaus ................. 323
14.8 Attribute fiir TASKing ........................... 327
14.9 Ausnahmen in TASKs ........................... 328
14.10 Gemeinsam benutzte Variablen .................. 329
14.11 Ein-/ Ausgabe in Programmen mit TASKs 331
15 Systemnahes Programmieren ............... 333
15.1 Zugriffe auf systemabhangige GraBen ........... 334
15.1.1 PACKAGE system............................... 334
15.1.2 Darstellungsattribute ............................ 336
15.2 Festlegen der internen Darstellung .............. 338