Table Of Content

Karl 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