Table Of ContentKarl Kurbel
Programmierstil
in Pascal, Cobol, Fortran, Basic, PL/I
Mit 52 Abbildungen
Springer-Verlag
Berlin Heidelberg New York Tokyo
Prof. Dr. Karl Kurbel
Universität Dortmund
Fachbereich Wirtschafts-
und Sozialwissenschaften
Lehrstuhl für Betriebsinformatik
Postfach 500500
4600 Dortmund 50
ISBN-13 :978-3-642-70248-8 e-ISBN-13 :978-3-642-70247-1
DOI: 10.1007/978-3-642-70247-1
CIP-Kurztitelaufnahme der Deutschen Bibliothek
Kurbel, Kar!:
Programmierstil in Pascal, Cobol, Fortran, Basic, PLiI / Karl Kurbel. -Berlin; Heidelberg;
New York; Tokyo: Springer, 1985.
(Springer Compass)
ISBN-13:978-3-642-70248-8
Das Werk ist urheberrechtlich geschützt. Die dadurch begründeten Rechte, insbesondere die
der Übersetzung, des Nachdruckes, der Entnahme von Abbildungen, der Funksendung, der
Wiedergabe auf photomechanischem oder ähnlichem Wege und der Speicherung in
Datenverarbeitungsanlagen bleiben, auch bei nur auszugsweiser Verwertung, vorbehalten.
Die Vergütungsansprüche des § 54, Abs.2 UrhG werden durch die "Verwertungsgesellschaft
Wort", München, wahrgenommen.
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.
© Springer-Verlag Berlin Heidelberg 1985
Softcover reprint of the hardcover 1st edition 1985
Gesamtherstellung: Appl, Wemding
2145/3140-543210
SPRINGER COMPASS
Herausgegeben von
G. R. Kofer P. Schnupp H. Strunz
Vorwort des Herausgebers
Moderne Programmierung wird meist in modernen Sprachen vorgeführt, in Pascal,
Modula, Ada. Natürlich ist dies naheliegend und sinnvoll. Moderne Programmie
rung ist der problemgerechte Umgang mit Daten-und Kontrollstrukturen, und die
modernen Sprachen wurden so entworfen, daß sie diese problemnahen Programm
strukturen nahelegen und optimal unterstützen.
Bloß - die meisten Softwareentwickler in der Praxis programmieren nicht in ih
nen. Dafür haben sie gute Gründe:
- Die Sprachen sind auf der vorhandenen Hardware nicht verfügbar. ,.
- Der Auftraggeber wünscht eine "klassische" Programmiersprache, auf Grund in-
terner Normen, der Vorkenntnisse seines Wartungspersonals, der Verträglichkeit
mit bereits vorhandenen Softwarekomponenten ...
- Notwendige Basis- und Hilfssoftware, wie ein Datenbanksystem oder ein
Taskmonitor, sind häufig nur aus COBOL oder FORTRAN heraus benutzbar.
- Die eingeführten und bewährten Projektstandards und Programmierwerkzeuge
existieren nur für eine bestimmte Sprache.
Jeder Praktiker kann aus seiner Erfahrung diese Liste nahezu beliebig verlän
gern. Und er weiß, daß es oft sinnlos ist, gegen eine "alte, unstrukturierte" Sprache
zu argumentieren.
"If you can't beat them, join them" sagen die anerkannt praktischen Amerika
ner. Wenn wir die unmodernen Sprachen schon nicht aus dem Felde schlagen kön
nen, dann sollten wir in ihnen erst recht modem programmieren. Daß, und wie das
geht, das zeigt dieses Buch.
Gute Software ist immer noch das Verdienst des Programmierers, nicht das der
Programmiersprache. Und vielleicht stellt sich auch bei Ihnen beim Lesen dieses
Buches zuweilen die Assoziation ein, die mich überkam: eigentlich klingen die
Goldberg-Variationen auf einem Cembalo viel besser als auf einem Flügel.
Womit ich nichts gegen einen modernen Ada-Flügel gesagt haben will ...
München, im Mai 1985 Peter Schnupp
Vorwort
Gegenstand dieses Buches ist der sinnvolle Umgang mit klassischen Programmier
sprachen. Darunter werden die in der Praxis verbreiteten prozeduralen Sprachen
verstanden, deren bekannteste Vertreter Fortran, Cobol, PLII, Basic und Pascal
sind.
Die Idee, dieses Buch zu schreiben, entstand angesichts der unbefriedigenden
Situation auf dem Gebiet der Programmiersprachen. Obwohl die Informatikfor
schung in den letzten zehn bis fünfzehn Jahren zahlreiche Sprachen hervorgebracht
hat, die hervorragend aufgebaut sind und über durchgängige und klare Sprachkon
zepte verfügen, werden nach wie vor in der Praxis hauptsächlich Programmierspra
chen eingesetzt, die vor dieser Zeit entstanden sind und nach heutiger Einschätzung
entscheidende Mängel aufweisen.
Es erscheint fraglich, ob die neue Generation von Programmiersprachen jemals
die "alteingesessenen" Sprachen verdrängen kann, zumal die Flexibilität der Betrie
be in dieser Hinsicht nicht besonders groß ist: viele betriebliche EDV-Anwender
befinden sich noch heute im Stadium der Assembler-Programmierung, und häufig
gilt es bereits als enormer Fortschritt, wenn überhaupt der Übergang zu Cobol oder
einer anderen höheren Programmiersprache vollzogen wird.
Die Entstehung des Software Engineering und die Weiterentwicklung der Soft
waretechnologie in den letzten ein bis zwei Jahrzehnten trugen dazu bei, daß wichti
ge Sprachelemente für den sinnvollen Aufbau von Programmen und Programmsy
sternen in die neuentwickelten Sprachen bereits aufgenommen wurden.
Dagegen bleibt der Anwender älterer Sprachen mit Schlagwörtern wie "struktu
rierte Programmierung", "schrittweise Verfeinerung", "Modularisierung", "Infor
mation Hiding" u. a. zunächst alleingelassen. In seiner Programmiersprache findet
er keine oder nur wenige Ausdrucksmittel, die auf diese Konzepte unmittelbar zu
geschnitten sind.
Angesichts der Verbreitung klassischer Programmiersprachen in der betriebli
chen Praxis erscheint es daher dringend geboten, den Anwender bei der Umsetzung
fundamentaler Konzepte in seine Sprache zu unterstützen. Dies ist das zentrale An
liegen des Buches. Dem Studierenden, der eine Programmiersprache erlernt, und
dem Anwender, der mit einer Sprache umzugehen hat, soll eine Hilfestellung für die
systematische Gestaltung von Programmen gegeben werden.
Programme sind Texte in einer künstlichen Sprache. Die Gestaltung eines Texts
ist, abgesehen vom materiellen Inhalt, eine Frage des Stils. In diesem Sinne werden
die Aspekte des Aufbaus und der Darstellung von Programmen als Elemente des
Programmierstils betrachtet. Sie erstrecken sich von der inhaltlichen Strukturierung
bis hin zur optischen Aufbereitung des Programmtexts.
Vorwort VII
Dieses Buch wendet sich nicht an den Programmierneuling. Der Leser sollte zu
mindest über Grundkenntnisse und gewisse Erfahrungen in einer beliebigen höhe
ren Programmiersprache verfügen. Dies ist zum Verständnis der Sprachkonzepte
und zur Beurteilung der Stilelemente erforderlich.
Das Buch hat im wesentlichen vier Zielrichtungen. Erstens soll es einen Über
blick über Aufbau und Sprachkonzepte der wichtigsten in der Praxis verbreiteten
Programmiersprachen geben. Behandelt werden die Sprachen Fortran, Cobol, Ba
sic, PLII und Pascal. Zweitens sollen zentrale Elemente des Programmierstils erör
tert werden. Dabei wird gezeigt, wie diese mit den Ausdrucksmitteln der klassischen
Sprachen zu realisieren sind. Ein drittes Anliegen geht dahin, den Leser, der bereits
eine Programmiersprache beherrscht, beim Erlernen anderer Sprachen zu unter
stützen und ihm die Realisierung wichtiger Programmkonstrukte vor Augen zu füh
ren. Schließlich soll der Anwender in der Praxis eine Hilfestellung erhalten, die es
ihm ermöglicht, mit seiner Sprache sinnvoll umzugehen und neuere Programmier
techniken auszunutzen.
Das Buch ist jedoch nicht als Ersatz für ein Nachschlagewerk oder ein lehr
buch zu einer bestimmten Programmiersprache gedacht. Vielmehr geht es hier um
grundlegende Konzepte und Strukturen. Die Details einer Sprache können und sol
len nicht umfassend dargestellt werden. Dazu sei der Leser auf die einschlägigen
Sprachbeschreibungen verwiesen.
Die skizzierten Anliegen werden in sieben Kapiteln behandelt. Kapitell gibt zu
nächst einen Überblick über qualitative Aspekte von Programmen und Program
miersprachen. Davon ausgehend werden in Kapitel2 Anforderungen formuliert,
die an eine gute Programmiersprache zu richten sind. Auf der Grundlage dieser
"Wunschliste" werden in den späteren Kapiteln die Elemente des Programmierstils
erörtert.
Kapitel3 enthält eine Zusammenstellung der wichtigsten Sprachkonzepte von
Fortran, Cobol, Basic, PLII und Pascal, die aus ihrer historischen Entwicklung her
aus erläutert werden. Die Bewertung der Sprachkonzepte und insbesondere die sy
stematische Verwendung der Sprachelemente sind Gegenstand von Kapitel 4. Wäh
rend hier die zentralen Elemente des Programmierstils sprachspezifisch behandelt
werden, befaßt sich Kapitel 5 mit verschiedenen Aspekten, die unabhängig von ei
ner bestimmten Programmiersprache sind. Kapitel 6 beschließt die Ausführungen
mit einer Zusammenfassung und einem Ausblick auf neuere Programmierspra
chen.
Die Erläuterungen werden durchweg mit Hilfe von Beispielen veranschaulicht.
Die Tragweite der zahlreichen Einzelaspekte, die bei der systematischen Pro
grammgestaltung zusammenwirken, wird jedoch nur deutlich, wenn man ein voll
ständiges und einigermaßen typisches Programm betrachtet. In Kapitel7ist deshalb
ein größeres Programmbeispiel beschrieben. Ausgehend von einer einheitlichen
Problemstellung werden dort die zur Lösung entwickelten Programme in Fortran,
Cobol, Basic, PLiI und Pascal wiedergegeben. Zum einen kann so der Leser Ver
gleiche zwischen den fünf Programmiersprachen anstellen. Zum andern können die
Programme zum besseren Verständnis und zum Nachschlagen bei der Lektüre der
Kapitel 3 und 4 herangezogen werden.
Beim Entwickeln und Testen der Musterprogramme im Anhang war Herr
Dipl.-Kfm. Hans Hermann Soll behilflich. Dafür sei ihm herzlich gedankt. Beson-
VIII Vorwort
derer Dank gebührt auch Frau Karin Wüstenbecker, die die mühselige Arbeit der
Manuskripterstellung mit bewundernswerter Ausdauer bewältigte.
Dortmund, Mai 1985 Karl Kurbel
Inhaltsverzeichnis
1 Programme und Programmiersprachen . . . . . . . . . . . . . . . . . 1
1.1 Aufgabe und Zweck einer Programmiersprache . . . . . . . . . . . . 1
1.2 Qualitätsanforderungen an Programme ........ . . . . . 3
1.3 Zur Qualität von Programmiersprachen . . . . . . . . . . . . . . . . . 6
2 Anforderungen an eine Programmiersprache ............... 11
2.1 Strukturierungshilfen.......................... 11
2.1.1 Zerlegungskonstrukte.......................... 11
2.1.2 Verfeinerungskonstrukte ........................ 13
2.1.3 Steuerkonstrukte . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 15
2.1.3.1 Sequenz ............ . . . . . . . . . . . . . . . . . . . 16
2.1.3.2 Selektion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 16
2.1.3.3 Repetition . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 17
2.2 Datenbeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . .. 19
2.2.1 Datentypen ................................ 19
2.2.1.1 Zum Begriff des Datentyps . . . . . . . . . . . . . . . . . . . . . . .. 19
2.2.1.2 Standarddatentypen . . . . . . . . . . . . . . . . . . . . . . . . . . .. 20
2.2.2 Datenstrukturen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 22
2.2.3 Neudefinierte Datentypen ........................ 24
2.3 Unterstützung der Selbstdokumentation . . . . . . . . . . . . . . . .. 27
2.3.1 Verbalisierung............ . . . . . . . . . . . . . . 27
2.3.2 Kommentierung........... . . . . . . . . . . . . . . 29
2.3.3 Programm-Layout.......... . . . . . . . . . . . . . . 30
2.4 Weitere Anforderungen . . . . . . . . . . . . . . . . . . . . . 30
3 Verbreitete Programmiersprachen . . . . 32
3.1 Fortran................................... 32
3.1.1 Entstehung von Fortran . . . . . . . . . . . . . . . . . . . . . . . . .. 32
3.1.2 Sprachkonzeptevon Fortran66 . . . . . . . . . . . . . . . . . . . . .. 34
3.1.2.1 Typ, Struktur und Vereinbarung von Daten. . . . . . . . . . . . . . .. 36
3.1.2.2 Anweisungen ............................... 38
3.1.3 Spracherweiterungen in Fortran 77 . . . . . . . . . . . . . . . . . . .. 41
X Inhaltsverzeichnis
3.2 Cobol.................................... 43
3.2.1 Entstehung von Cobol . . . . . . . . . . . . . . . . . . . . . . . . . .. 43
3.2.2 Sprachkonzepte von Cobol . . . . . . . . . . . . . . . . . . . . . . .. 46
3.2.2.1 Textgestaltung und statische Programmstruktur . . . . . . . . . . . .. 46
3.2.2.2 Datenbeschreibung . . . . . . . . . . . . . . . . . . . . . . . . . . .. 49
3.2.2.3 Weitere charakteristische Merkmale von Cobol . . . . . . . . . . . .. 56
3.3 Basic.................................... 67
3.3.1 Entstehung von Basic . . . . . . . . . . . . . . . . . . . . . . . . . .. 67
3.3.2 Sprachkonzeptevon Minimal Basic ................... 70
3.3.3 Erweiterungen von Minimal Basic . . . . . . . . . . . . . . . . . . .. 76
3.3.4 Einbettung in das Betriebssystem . . . . . . . . . . . . . . . . . . . .. 84
3.4 Plii.................................... 85
3.4.1 Entstehung von PLiI ........................... 85
3.4.2 Elementare Konzepte von PLlI. . . . . . . . . . . . . . . . . . . . .. 88
3.4.2.1 Daten, Attribute, Ausdrücke ....................... 90
3.4.2.2 Anweisungen ............................... 95
3.4.3 Höhere Sprachkonzepte . . . . . . . . . . . . . . . . . . . . . . . . .. 101
3.4.3.1 Programmstruktur . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 101
3.4.3.2 Behandlung von Programmunterbrechungen .............. 104
3.4.3.3 Weitere Sprachkonzepte . . . . . . . . . . . . . . . . . . . . . . . . .. 107
3.5 Pascal................................... 108
3.5.1 Entstehung von Pascal. . . . . . . . . . . . . . . . . . . . . . . . . .. 108
3.5.2 Sprachkonzepte von Pascal . . . . . . . . . . . . . . . . . . . . . . .. 110
3.5.2.1 Datentypen ................................ 110
3.5.2.2 Vereinbarungen . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 113
3.5.2.3 Anweisungen ............................... 116
3.5.2.4 Prozeduren und Funktionen ....................... 119
4 Programmierstil und Ausdrucksmittel der klassischen
Programmiersprachen . . . . . . . . . . . . . . . . . . 124
4.1 Vorbemerkung . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 124
4.1.1 Ausgewählte Elemente des Programmierstils . . . . . . . . . . . . . .. 124
4.1.2 Implementierung von Datenkapseln . . . . . . . . . . . . . . . . . .. 125
4.2 Stilelemente in Fortran .......................... 128
4.2.1 Zerlegung und Verfeinerung ....................... 128
4.2.2 Steuerkonstrukte . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 133
4.2.3 Vereinbarungen und Selbstdokumentation . . . . . . . . . . . . . . .. 142
4.2.4 Einschränkungen bei Fortran66 ..................... 146
4.2.4.1 Verschiedenes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 146
4.2.4.2 Einschränkungen bei Steuerkonstrukten . . . . . . . . . . . . . . . .. 148
4.2.4.3 Ersatzkonstruktion für sekundäre Eingangsstellen . . . . . . . . . . .. 150
4.3 Stilelemente in Cobol . . . . . . . . . . . . . . . . . . . . . . . . . .. 154
4.3.1 Sprachelemente zur Zerlegung . . . . . . . . . . . . . . . . . . . . .. 154
4.3.2 Sprachelemente zur Verfeinerung . . . . . . . . . . . . . . . : . . . .. 160
4.3.3 Steuerkonstrukte . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 163
4.3.4 Aspekte der Verbalisierung und Selbstdokumentation . . . . . . . . .. 171
Inhaltsverzeichnis XI
4.4 Stilelemente in Basic. . . . . . . . . . . . . . . . . . . . . . . . . . .. 178
4.4.1 Probleme der Zerlegung mit Basic-Sprachelementen .......... 178
4.4.2 .. Unterprogramme" als Verfeinerungskonstrukte ............ 183
4.4.3 Implementierung der Steuerkonstrukte . . . . . . . . . . . . . . . . .. 185
4.4.3.1 Steuerkonstrukte auf der Grundlage von Minimal Basic. . . . . . . .. 185
4.4.3.2 Ausblick: Erweiterungen von Minimal Basic. . . . . . . . . . . . . .. 189
4.4.4 Probleme der Lesbarkeit und Selbstdokumentation . . . . . . . . . .. 191
4.5 Stilelemente in PLiI . . . . . . . . . . . . . . . . . . . . . . . . . . .. 194
4.5.1 Zerlegung durch externe Prozeduren . . . . . . . . . . . . . . . . . .. 194
4.5.2 Verfeinerung durch interne Prozeduren. . . . . . . . . . . . . . . . .. 198
4.5.3 Steuerkonstrukte . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 200
4.5.3.1 Steuerkonstrukte auf Basis des ANS I-Standards . . . . . . . . . . . .. 200
4.5.3.2 Steuerkonstrukte auf Basis von Spracherweiterungen . . . . . . . . .. 204
4.5.4 Aspekte der Selbstdokumentation .................... 205
4.5.4.1 Hinweise zu Vereinbarungen . . . . . . . . . . . . . . . . . . . . . .. 206
4.5.4.2 Kommentierungsrichtlinien . . . . . . . . . . . . . . . . . . . . . . .. 207
4.5.5 Kritische Anmerkungen zu PLiI . . . . . . . . . . . . . . . . . . . .. 209
4.6 Stilelemente in Pascal . . . . . . . . . . . . . . . . . . . . . . . . . .. 210
4.6.1 Zerlegungund Verfeinerung ....................... 211
4.6.1.1 Prozeduren und Funktionen als Verfeinerungskonstrukte . . . . . . .. 213
4.6.1.2 Prozeduren und Funktionen als Zerlegungskonstrukte ......... 215
4.6.2 Steuerkonstrukte . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 221
4.6.3 Aspekte der Selbstdokumentation .................... 223
5 Sprachübergreifende Aspekte des Programmierstils . . . . . . . . . . .. 228
5.1 Kommentierung und Programm-Layout . . . . . . . . . . . . . . . .. 228
5.1.1 Die Rolle von Kommentaren ................ : . . . . .. 228
5.1.2 Zur Wirkung von Einrückungen und Leerzeilen . . . . . . . . . . . .. 231
5.2 Weitere Einflußfaktoren . . . . . . . . . . . . . . . . . . . . . . . . .. 232
5.2.1 Einige Aspekte des EfTlZienzstrebens . . . . . . . . . . . . . . . . . .. 232
5.2.2 Datenvereinbarungen . . . . . . . . . . . . . . . . . . . . . . . . . .. 236
5.2.3 Einzelaspekte ............................... 239
6 Zusammenfassung und Ausblick . . . . . . . . . . . . . . . 243
7 Musterprogramme . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 248
7.1 Beschreibung des Programmbeispiels .................. 248
7.1.1 AufgabensteIlung . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 248
7.1.2 Lösungsweg . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .. 249
7.2 Implementierung in Fortran. . . . . . . . . . . . . . . . . . . . . . .. 251
7.2.1 Fortran77 ................................. 251
7.2.2 Fortran 66 ................................. 262
7.3 Implementierung in Cobol ........................ 273
