Object Pascal mit Delphi

Springer-Verlag Berlin Heidelberg GmbH

Richard Kaiser

Object Pascal mit Delphi Eine Einführung in die objektorientierte Windows-Programmierung

Mit zahlreichen Abbildungen und Tabellen

i Springer

Prof. Richard Kaiser Schwărzlocher StraBe 53 D-72070 Ttibingen

ISBN 978-3-540-60340-5

Die Deutsche Bibliothek - CIP-Einheitsaufnahme Kaiscr. Richard: Object Pascal mit Delphi: eine Einfiihrung in die objektorienticrte Windows-Programmierung / Richard Kaiser Berlin: Heidelberg; New York; Barcelona; Budapest; Hongkong: London: Mailand; Paris; Santa Clara; Singapur; Tokio: Springer. 1997 ISBN 978-3-540-60340-5 ISBN 978-3-642-59121-1 (eBook) DOI 10.1007/978-3-642-59121-1 Die.~e.~ Werk i.,t urheberrechtlich geschUlzL Die dadurch begrUndeten Rechte. insbeson­dere die der Oberselzung. des Nachdrucks. des Vortrags. der Entnahme von Abbildun­gen und Tabellen. der Funksendung. der Mikroverfilmung oder der Vervielfăltigung auf anderen Wegen und der Speicherung in Datenverarbeitungsanlagen. biei ben. auch bei nur auszugsweiser Verwertung. vorbe hal ten. Eine Vervielfăltigung dieses Werkes oder von Teilen dieses Werkes isI auch im Einzelfall nur in den Grenzen der gesetzlichen Bcstimmungen des Urheberrechtsgesetzes der Bundesrepublik Deutschland vom 9. Sep­tember 1965 in der jeweils geltenden Fassung zulăssig. Sie ist grundsătzlich vergiltungs­pflichtig. ZlIwiderhandlllngen lInterliegen den Stratbestimmllngen des Urheberrechts­gesetzes.

© Springer-Verlag Berlin Heidelberg 1997

Die Wiedcrgabe von Gebrauchsnamen. Handelsnamen. Warenbezeichnungen usw. in dicscm Werk berechtigt auch ohne besondere Kennzeichnung nicht Zll der Annahme. daLl solchc Namen im Sin~e de,· Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wăren und daher von jedermann benutzt werden dilrften.

Umschlagl110tiv mil freundlicher Genehmigung der Borland GmbH Umschlaggestaltllng: KUnkel + Lopka Werbeagelllllr. ilvesheim

Satz: Druckfertige Dateien vom Al;tor Belichlung: Text & Grafik, Heidelberg SPIN: 10794570 45/3111 - 5432 - Gedruckl auf săurefreiem Papier

Geleitwort

Mit Delphi ist es Borland gelungen, den Erfolg von Borland Pascal fortzuführen und eine kleine Revolution im Bereich der Entwicklungssysteme auszulösen. Die visuelle Entwicklungsumgebung ermöglicht eine einfache und schnelle Entwick­lung von Windows-Programmen.

Die visuellen Werkzeuge werden durch die leistungsfahige Programmiersprache Object Pascal ergänzt. Durch den optimierenden Native-Code-Compiler sind die mit Delphi entwickelten Programme schnell und wesentlich effizienter als inter­pretierte Programme.

Delphi unterstützt mit Object Pascal wichtige Konzepte des modernen Software Engineering: strukturierte, modulare und objektorientierte Programmierung. Damit ist Delphi außerordentlich gut für die Entwicklung von professionellen Windows-Programmen geeignet. Da alle diese Konzepte unter einer einfach zu bedienenden Entwicklungsumgebung verfügbar sind, ist Delphi auch ideal für die Vermittlung dieser Inhalte in der Lehre geeignet.

Dieses Buch stellt die Sprachelemente von Object Pascal umfassend dar und beschreibt die wichtigsten Techniken im Umgang mit diesen Sprachelementen. Schwerpunkte sind unter anderem das neue Objektmodell und das Exception­Handling. Dadurch ist dieses Buch ein wichtiges Nachschlagewerk, wenn es um die Grundlagen der Delphi-Programmierung geht. Durch den systematischen Aufbau ist es außerdem gut als Lehrbuch geeignet.

Andreas Fischer Technischer Produktmanager Delphi Borland Deutschland

Vorwort

Dieses Buch verbindet eine umfassende Darstellung von Object Pascal mit einer systematischen Einführung in die Programmierung. Dabei werden alle Sprach­konzepte von der strukturierten bis zur objektorientierten Programmierung be­handelt und an Beispielen illustriert.

Delphi ist eine Plattform, die sich sehr gut für eine Einführung in die Program­mierung eignet. Da Object Pascal sowohl alle herkömmlichen als auch die modernen, objektorientierten Sprachelemente enthält, können alle damit verbun­denen Konzepte in einer einheitlichen Umgebung gelehrt und geübt werden. Und ganz nebenbei entstehen dabei auch noch optisch ansprechende Windows­Programme.

Das Buch richtet sich aber nicht nur an diejenigen, die objektorientiertes Pro­grammieren lernen wollen, sondern genauso an Praktiker, die eine umfassende Darstellung von Object Pascal suchen.

Die ersten beiden Kapitel geben einen Überblick über die Entwicklungsumge­bung und die visuelle Programmierung mit Delphi. Hier wird gezeigt, wie man schon mit geringen Vorkenntnissen einfache Windows-Programme erstellen kann.

In den Kapiteln 3 bis 5 werden die Sprachelemente der strukturierten Program­mierung dargestellt. Mit den Ablaufstrukturen werden die Grundbegriffe der Programmierlogik und Programmverifikation behandelt. Dieser Teil entspricht damit einer klassischen Einführung in die Programmierung, wobei allerdings von Anfang an Windows-Programme entwickelt werden.

Kapitel 6 ist eine Einführung in die objektorientierte Programmierung. Nach der Vorstellung des Kiassenkonzepts von Object Pascal geht es vor allem um die systematische Konstruktion von Basisklassen. Solche Basisklassen können als Bausteine für wiederverwendbare und erweiterbare Algorithmen verwendet wer­den. Als Beispiele werden unter anderem Basisklassen für einige gängige Sortier­verfahren, die Klassenbibliothek von Delphi, tiefer gehende Klassenkonzepte und ihre Verbindung zu Windows sowie Sprachelemente für die visuelle Program­mierung vorgestellt.

viii

Im Rahmen eines kleinen Projekts wird in Kapitel 7 ein praxisnahes Windows­Programm entwickelt. Auch hier spielen Basisklassen eine zentrale Rolle: Sie stellen das grundlegende Verhalten von Formularen dar.

In Kapitel 8 werden vor allem anhand von Beispielen einige Themen behandelt, die nicht mehr im engeren Sinne zur Sprache Object Pascal gehören. Die zuge­hörigen Funktionen sind für viele Anwendungen nützlich und machen Delphi zu einem außerordentlich vielseitigen Entwicklungssystem, das viel mehr ist als nur ein Compiler für Object Pascal. Die dazu von Delphi zur Verfügung gestellten Klassen sind außerdem ein gutes Beispiel für die Architektur einer Klassenbiblio­thek.

Zahlreiche Übungsaufgaben geben dem Leser die Möglichkeit, die Inhalte prak­tisch anzuwenden und so zu vertiefen. Da man Programmieren nur lernt, indem man es tut, möchte ich ausdrücklich dazu ermuntern, zumindest einen Teil der Aufgaben zu lösen und sich dann selbst neue Aufgaben zu stellen. Der Schwie­rigkeitsgrad der Aufgaben reicht von einfachen Wiederholungen des Textes bis zu kleinen Programmieraufgaben, die ein gewisses Maß an selbständiger Arbeit erfordern. Die Lösungen der allermeisten Aufgaben findet man im letzten Kapitel.

Danksagung

Peter Schwalm, Stefan Kursawe und Christian Rosenkranz haben große Teile des Manuskripts gelesen und durch zahlreiche Vorschläge zu seiner Verbesserung beigetragen. Hilfreiche Tips bekam ich darüber hinaus von Sebastian Draese, Uwe Haury, Thomas Heuckeroth, Björn Hils, Björn Kelz und Dirk Scheffler.

Meine Söhne Daniel und Alexander haben mich auf jede nur erdenkliche Weise tatkräftig unterstützt. Alex hat mich beträchtlich entlastet, indem er sämtliche Reparaturen und Installationen an meinem PC in die Hand genommen und souverän gemeistert hat.

Die Unterstützung von Dr. Hans Wössner und seinem Team vom Springer­Verlag hätte nicht besser sein können. Er hat es immer wieder geschafft, den Eindruck zu erwecken, als ob er nur dieses Buch betreuen würde. "Meiner" Lek­torin Ruth Abraham verdankt dieses Buch eine in sich geschlossene Form, die ich allein nicht geschafft hätte. Die technische Herstellung war bei Gabi Fischer in erfahrenen guten Händen.

Ihnen allen gilt mein Dank, insbesondere auch der Borland GmbH für ihr Ein­verständnis zur Verwendung der Syntaxdiagramme und des Athena-Bitmaps auf der Titelseite.

Tübingen, im Oktober 1996 Richard Kaiser

Inhalt

1 Die Entwicklungsumgebung ................................................................. 1

1.1 Visuelle Programmierung: Ein erstes kleines Programm ........................ 2 1.2 Erste Schritte in Object Pascal ............................................................... 6 1.3 Projekte, Projektdateien und Projektoptionen ........................................ 10 1.4 Die On1ine-Hilfe ................................................................................... 12 1.5 Der Quelltexteditor ............................................................................... 14 1.6 Das lokale Menü ................................................................................... 17 1.7 Die Symbolleiste ................................................................................... 18 1.8 Weitere Optionen der Menüleiste .......................................................... 18

2 Die Komponentenpalette .................................................................... 21

2.1 Die Delphi-Hilfe zu den Komponenten ................................................. 21 2.2 Namen .................................................................................................. 25 2.3 Labels und Datentypen .......................................................................... 28 2.4 Methoden und Ereignisse am Beispiel der Komponente Edit ................. 33 2.5 Memos, ListBoxen, ComboBoxen und TStrings .................................... 37 2.6 Buttons und Ereignisse ........................................................................ .40 2.7 CheckBoxen, RadioButtons und einfache if-Abfragen ......................... ..44 2.8 Die Container GroupBox, Panel und RadioGroup ................................ .46 2.9 ScrollBar ............................................................................................. .49

2.10 Hauptmenüs und Popup-Menüs ............................................................. 51 2.11 Die Komponenten der Seite Dialoge ..................................................... 54 2.12 Der Aufruf von eigenen Formularen und modale Fenster ...................... 57 2.13 Einige weitere Komponenten ................................................................ 60 2.14 Einige Komponenten der Seite System .................................................. 65 2.15 Vordefinierte DialogBoxen ................................................................... 68 2.16 Formularschablonen .............................................................................. 70

x Inhalt

3 Variablen und vordefinierte Datentypen ............................................ 71

3.1 Programme, Units und Syntaxdiagramme ............................................. 71 3.2 Variablen .............................................................................................. 79 3.3 Ganzzahldatentypen .............................................................................. 83 3.4 Der integrierte Debugger ...................................................................... 96 3.5 Gleitkommadatentypen ....................................................................... 103 3.6 Der Datentyp Char und der ASCII- und ANSI-Zeichensatz ................. 118 3.7 Der Datentyp String ............................................................................ 122 3.8 Aufzählungstypen ............................................................................... 135 3.9 Boolesche Datentypen ......................................................................... 138

3.10 Unterbereichstypen ............................................................................. 143 3.11 Die Systematik der einfachen Datentypen ........................................... 145 3.12 Mengen .............................................................................................. 147 3.13 Der Konstantenvereinbarungsteil ........................................................ 153 3.14 Initialisierte Variablen ........................................................................ 155 3.15 Der Typvereinbarungsteil. ................................................................... 157 3.16 Gleichheit und Kompatibilität von Datentypen .................................... 158 3.17 Arrays ................................................................................................. 161 3.18 Ein wenig Graphik: TCanvas und TImage .......................................... 174 3.19 Pointer und dynamische Variablen ...................................................... 178 3.20 Kommentare ....................................................................................... 185 3.21 Compilerbefehle und bedingte Kompilation ........................................ 189

4 Anweisungen .................................................................................... 193

4.1 Wertzuweisungen und Ausdrücke ....................................................... 194 4.2 Ein wenig Programmierlogik: Symbolische Ausführung ..................... 203 4.3 Die Verbundanweisung ....................................................................... 211 4.4 Bedingte Anweisungen ....................................................................... 212 4.4.1 Die if-Anweisung ............................................................................ 212 4.4.2 Die case-Anweisung ....................................................................... 224 4.4.3 Ein wenig Programmierlogik für bedingte Anweisungen ................. 226

4.5 Wiederholungsanweisungen ................................................................ 233 4.5.1 Die repeat-Anweisung .................................................................... 234 4.5.2 Die while-Anweisung ...................................................................... 234 4.5.3 Diefor-Anweisung .......................................................................... 236 4.5.4 Endlosschleifen, Abbruchbedingungen und Windows ..................... 241 4.5.5 Ein wenig Programmierlogik für Schleifen ..................................... 244

4.6 Die Prozeduranweisung ...................................................................... 250 4.7 Die goto-Anweisung, Break und Continue .......................................... 252 4.8 Exception-Anweisungen ..................................................................... 257 4.8.1 Strukturierte Ausnahmebehandlung ................................................ 258 4.8.2 Die try-except-Anweisung ............................................................... 260 4.8.3 Exception-Handler und vordefinierte Exceptions ............................. 262

Inhalt xi

4.8.4 Das vordefinierte Exception-Handling von Delphi .......................... 270 4.8.5 Die Anweisung raise und selbstdefinierte Exceptions ...................... 272 4.8.6 Ressourcen-Schutzblöcke mit try-finally ......................................... 275

4.9 Die Systematik der Anweisungen ........................................................... 279

5 Prozeduren, Funktionen und die Blockstruktur von Pascal ............. 281

5.1 Die Vereinbarung und der Aufruf von Prozeduren .............................. 282 5.2 Die Verwaltung von Prozeduraufrufen über den Stack ........................ 286 5.3 Blockstruktur und Lokalität ................................................................ 289 5.4 Speichergrenzen für lokale und globale Variablen ............................... 294 5.5 Prozeduren mit Parametern ................................................................. 295 5.5.1 Werteparameter .............................................................................. 297 5.5.2 Variablenparameter ........................................................................ 299 5.5.3 Konstantenparameter ...................................................................... 302 5.5.4 Untypisierte Parameter .................................................................... 303 5.5.5 Offene Array-Parameter .................................................................. 304 5.5.6 Typvariante offene Array-Parameter ............................................... 305

5.6 Funktionen ......................................................................................... 306 5.7 Seiteneffekte und die Reihenfolge von Auswertungen ......................... 313 5.8 Schrittweise Verfeinerung als Entwurfstechnik ................................... 316 5.9 Etwas Programmierlogik und -stil für Prozeduren und Funktionen ..... 321

5.10 Prozedurtypen ..................................................................................... 325 5.11 Rekursion ........................................................................................... 329 5.12 Weitere Optionen für Funktionen und Prozeduren .............................. 343

6 Objektorientierte Programmierung ................................................. 345

6.1 Records und die witk-Anweisung ........................................................ 346 6.2 Records mit Varianten und typvariante Array-Parameter .................... 356 6.3 Abstrakte Datentypen - Teil 1 ............................................................. 365 6.4 Objekte und Methoden ........................................................................ 368 6.5 Vererbung ........................................................................................... 375 6.6 Virtuelle Methoden, späte Bindung und Polymorphie ......................... 380 6.7 Klassen ............................................................................................... 390 6.8 Delphi-Komponenten als Klassen und MDI-Programme .................... .400 6.9 Selbstdefinierte Komponenten und Methodenzeiger. .......................... .405

6.10 Abstrakte Datentypen mit Klassen ..................................................... .410 6.11 Units ................................................................................................... 411 6.12 Zugriffsrechte auf Klassenkomponenten ............................................. .419 6.13 Abstrakte Methoden, Basisklassen und Erweiterbarkeit... ................... .425 6.14 Programmbausteine und -gerüste ....................................................... .431 6.15 Typinformationen zur Laufzeit... ........................................................ .439 6.16 Klassenreferenztypen und Klassenmethoden ....................................... 444

XII Inhalt

6.17 Visuelle Programmierung und Properties (Eigenschaften) .................. .449 6.17.1 Array-Properties ........................................................................... .453 6.17.2 Indexangaben ............................................................................... .456 6.17.3 Speicherangaben .......................................................................... .458 6.17.4 Überschriebene Eigenschaften ...................................................... .459

6.18 Die Objekthierarchie von Delphi ......................................................... 459 6.19 Botschaften (Messages) ...................................................................... .469

6. I 9.1 Die Message Queue und die Window-Prozedur ............................. 469 6.19.2 Botschaften für eine Anwendung ................................................... 471 6.19.3 Selbstdefinierte Message-Handler für Windows-Steuerelemente ... .472 6.19.4 Botschaften versenden .................................................................. .4 76 6.19.5 Die Behandlung von Botschaften in der VCL ................................ 477

6.20 Die Erweiterung der Komponentenpalette .......................................... .483

7 Datenverwaltung und ein kleines Projekt ........................................ 491

7.1 Projektvorbereitungen ........................................................................ .492 7.2 Datenverwaltung mit Arrays ............................................................... 495 7.2.1 Vererbung von visuell erzeugten Formularen .................................. 497 7.2.2 Suchen und Sortieren ...................................................................... 501

7.3 Dateien ............................................................................................... 503 7.3.1 Sequentielle Dateibearbeitung ......................................................... 506 7.3.2 IIO-Fehler und EInOutError-Exceptions ......................................... 511 7.3.3 Textdateien und Drucken ................................................................ 515 7.3.4 Dateibearbeitung im Direktzugriff... ................................................ 519 7.3.5 Untypisierte Dateien ....................................................................... 522 7.3.6 File-Sharing, Zugriffsrechte und Record-Locking ........................... 523 7.3.7 Sortieren, Mischen und Gruppenverarbeitung ................................. 530

7.4 Rekursive Datenstrukturen .................................................................. 538 7.4.1 Verkettete Listen ............................................................................. 540 7.4.2 Programmbausteine mit generischen Pointern ................................. 551 7.4.3 Baumstrukturen .............................................................................. 553

8 Verschiedenes ................................................................................... 565

8.1 Datenbanken ....................................................................................... 566 8.1.1 TTable ............................................................................................ 566 8.1.2 Indizierte Tabellen .......................................................................... 574 8.1.3 SQL-Abfragen ................................................................................ 580 8.1.4 Datenbanken, Transaktionen und Cached Updates .......................... 582 8.1.5 Die BDE am Beispiel von ODBC und MS Access Datenbanken ...... 585 8.1.6 QuickReport. ................................................................................... 589

8.2 OLE .................................................................................................... 595 8.2.1 Ein einfacher OLE-Client ............................................................... 595

Inhalt xiii

8.2.2 Ein einfacher aLE-Server ............................................................... 597 8.2.3 Verknüpfen und Einbetten VOn aLE-Objekten ................................ 599

8.3 Dynamic Link Libraries (DLLs) .......................................................... 603 8.4 Windows API-Programme .................................................................. 609 8.5 Multitasking und Threads ................................................................... 611 8.5.1 Windows-API-Funktionen für Threads ............................................ 612 8.5.2 Threads und die VeL .................................................................... 616

8.6 Meßwert-Erfassung ............................................................................. 619

9 Lösungen .......................................................................................... 623

9.1 Lösungen Kapitel 2 ............................................................................. 623 9.2 Lösungen Kapitel 3 ............................................................................. 635 9.3 Lösungen Kapitel 4 ............................................................................. 653 9.4 Lösungen Kapitel 5 ............................................................................. 667 9.5 Lösungen Kapitel 6 ............................................................................. 679 9.6 Lösungen Kapitel 7 ............................................................................. 713

Literaturverzeichnis ............................................................................ 747

Index ................................................................................................... 749