[Xpert.press] C++ mit dem Borland C++Builder ||

Xpert. press

Springer-Verlag Berlin Heidelberg GmbH

Die Reihe Xpert.press des Springer-Verlags vermittelt Professionals in den Bereichen Betriebs- und Informationssysteme, Software Engineering und Programmiersprachen aktuell und kompetent relevantes Fachwissen ber Technologien und Produkte zur Entwicklung und Anwendung moderner Informations-technologien.

Richard Kaiser

C++ mitdem Borland C++Builder Einfhrung in den ANSIIISO-Standard und die objektorientierte Windows-Programmierung

MitCD-ROM

Springer

Prof. Richard Kaiser Schwarzlocher StraBe 53 72070 Tiibingen

[email protected] www.rkaiser.de

Additiona1 material to this book can be downloaded from http://extras.springer.com

ISSN 1439-5428 ISBN 978-3-662-06195-4

Die Deutsche Bibliothek - CIP-Einheitsaufnahme Kaiser, Richard: C++ mit dem Borland C++ Builder : Einfiihrung in den ANSIIISO-Standard und die objektorientierte Windows-Programmierung / Richard Kaiser. (Xpert. press)

ISBN 978-3-662-06195-4 ISBN 978-3-662-06194-7 (eBook) DOI 10.1007/978-3-662-06194-7

Dieses Werk (Buch und CD-ROM) ist urheberrechtlich geschiitzt. Die dadurch be-griindeten Rechte, insbesondere die der Ubersetzung, des Nachdrucks, des Vortrags, der Entnahme von Abbildungen und Tabellen, der Funksendung, der Mikroverfilmung oder der Vervielfaltigung auf anderen Wegen und der Speicherung in Datenverarbei-tungsanlagen, bleiben, auch bei nur auszugsweiser Verwertung, vorbehalten. Eine Vervielfaltigung dieses Werkes oder von Teilen dieses Werkes ist auch im Einzelfall nur in den Grenzen der gesetzlichen Bestimmungen des Urheberrechtsgesetzes der Bundesrepublik Deutschland vom 9. September 1965 in der jeweils geltenden Fassung zulssig. Sie ist grundstzlich vergiitungspflichtig. Zuwiderhandlungen unterliegen den Strafbestimmungen des Urheberrechtsgesetzes.

Der Springer-Verlag Berlin Heidelberg GmbH ist nicht Urheber der Daten und Programme. Weder der Springer-Verlag Berlin Heidelberg GmbH

noch der Autor iibemehmen Haftung ftir die CD-ROM und das Buch, ein-schlieBlich ihrer Qualitt, Handels- oder Anwendungseignung. In keinem Fall iiber-nehmen der Springer-Verlag Berlin Heidelberg GmbH

oder der Autor Haftung fiir direkte, indirekte, zufllige oder Folgeschden, die sich aus der Nutzung der CD-ROM oder des Buches ergeben. http://www.springer.de

Springer-Verlag Berlin Heidelberg 2002 Urspriinglich erschienen bei Springer-Verlag Berlin Heidelberg New York 2002 Softcover reprint of the hardcover 1 st edition 2002

Die Wiedergabe von Gebrauchsnamen, Handelsnamen, Warenbezeichnungen usw. in diesem Werk berechtigt auch ohne besondere Kennzeichnung nicht zu der Annahme, dass solche Namen im Sinne der Warenzeichen- und Markenschutz-Gesetzgebung als frei zu betrachten wren und daher von jedermann benutzt werden diirften.

Umschlaggestaltung: KiinkelLopka, Heidelberg Satz: Belichtungsfhige Daten vom Autor Gedruckt auf surefreiem Papier- SPIN: 10629246 33/3142 GF 543210

FrRuth

Geleitwort

Das Programmieren unter C++ gilt als die Knigsklasse der objektorientierten Applikations-Entwicklung: Anwender nutzen C++, um universell einsetzbare, modulare Programme zu erstellen. Wer diese Sprache beherrscht, profitiert von einem beispiellosen Funktionsumfang und von der Option, plattformunabhngig zu arbeiten. Das war anfangs nur hochgradig versierten Profis vorbehalten. Sie allein waren in der Lage, der Komplexitt des C++-Quellcodes Herr zu werden.

Lngst aber stehen die Vorzge von C++ auch all jenen zur Verfgung, die nur gelegentlich oder schlicht und ergreifend aus Freude am Tfteln Applikationen erstellen. Einen wesentlichen Beitrag zur ,,Demokratisierung" der objektorien-tierten Programmierung leisten integrierte RAD-Systeme (Rapid Application Development) wie der C++Builder von Borland.

Ganz gleich ob Profi oder Einsteiger: Die C++-Version der erfolgreichen Object Pascal-Lsung Borland Deiphi bietet Programmierern eine visuelle Entwick-lungsumgebung, mit der sie einfach und rasch objektorientierte Windows-Appli-kationen schreiben knnen. Der C++Builder verfgt ber eine umfangreiche Palette an fertigen Komponenten und erleichtert seit der Version 5 auch die Ent-wicklung von Web-Applikationen. Wer grafische Benutzeroberflchen bauen will, stellt diese einfach mit wenigen Handgriffen per Maus zusammen. Das ist die Basis fr ein schnelles, effizientes und komfortables Arbeiten. Kurzum: Mit dem C++Builder wird die Applikations-Entwicklung von der langwierigen Fleiaufgabe zur zielorientierten Kopfarbeit.

Das vorliegende Buch ist eine systematische Einfhrung in die Arbeit mit C++ und dem Borland C++Builder. Ausfhrlich und praxisnah schildert Richard Kaiser die Konzepte und Elemente der Programmiersprache und der Entwick-lungsumgebung. Mit zahlreichen Beispielen und bungsaufgaben erschliet er auch Lesern ohne Vorkenntnisse die Logik objektorientierten Programmierens.

Borland wnscht allen Nutzern dieses hervorragenden Lehrbuchs und Nach-schlagewerks viel Spa und Erfolg bei der Arbeit mit dem C++Builder.

Jason Vokes European Product Line Manager - RAD Products and InterBase

Vorwort

Dieses Buch entstand ursprnglich aus dem Wunsch, in meinen Vorlesungen ber C++ nicht nur Textfensterprogramme, sondern Programme fr eine grafi-sche Benutzeroberflche zu entwickeln. Mit dem C++Builder von Borland stand 1997 erstmals ein Entwicklungssystem zur Verfgung, das so einfach zu bedie-nen war, dass man es auch in Anfngervorlesungen einsetzen kann, ohne dabei Gefahr zu laufen, dass die Studenten nur noch mit dem Entwicklungssystem kmpfen und gar nicht mehr zum Programmieren kommen.

Angesichts der damals anstehenden Verabschiedung des ANSI/ISO-Standards von C++ lag es nahe, in diesem einfhrenden Lehrbuch auch gleich den gesam-ten Sprachumfang des Standards umfassend darzustellen. Mir war allerdings nicht klar, auf welche Arbeit ich mich damit eingelassen hatte. Ich hatte weder vor, vier Jahre an diesem Buch zu schreiben, noch einen Wlzer mit 1100 Seiten zu produzieren.

Als ich dann die Mglichkeit bekam, Kurse fr erfahrene Praktiker aus der In-dustrie zu halten, wurde ich mit einer Flle von Anregungen aus ihrer tglichen Arbeit konfrontiert. Diese gaben dem Buch enorme Impulse.

Die Programmiersprache C++ wurde als Obermenge der Programmiersprache C entworfen. Dieser Entscheidung verdankt C++ sicher seine weite Verbreitung. Sie hat aber auch dazu gefhrt, dass oft weiterhin wie in C programmiert wird und lediglich ein C++-Compiler anstelle eines C-Compilers verwendet wird. Dabei werden viele Vorteile von C++ verschenkt. Um nur einige zu nennen:

- In C++ werden die fehleranflligen Zeiger viel seltener als in C bentigt. - Die Stringklassen lassen sich wesentlich einfacher und risikoloser als die

nullterminierten Strings von C verwenden. - Die Containerklassen der C++-Standardbibliothek haben viele Vorteile ge-

genber Arrays, selbstdefinierten verketteten Listen oder Bumen. - Exception-Handling bietet eine einfache Mglichkeit, auf Fehler zu reagieren. - Objektorientierte Programmierung ermglicht bersichtlichere Programme. - Templates sind die Basis fr eine auerordentlich vielseitige Standardbiblio-

thek.

X Vorwort

Ich habe versucht, bei allen Konzepten nicht nur die Sprachelemente und ihre Syntax zu beschreiben, sondern auch Kriterien dafr anzugeben, wann und wie man sie sinnvoll einsetzen kann. Deshalb wurde z.B. mit der objektorientierten Programmierung eine Einfhrung in die objektorientierte Analyse und das ob-jektorientierte Design verbunden. Ohne die Beachtung von Design-Regeln schreibt man leicht Klassen, die der Compiler zwar bersetzen kann, die aber kaum hilfreich sind.

Man hrt immer wieder die Meinung, dass C++ viel zu schwierig ist, um es als einfhrende Programmiersprache einzusetzen. Dieses Buch soll ein in mehreren Jahren erprobtes Gegenargument zu dieser Meinung sein. Damit will ich aber die Komplexitt von C++ berhaupt nicht abstreiten.

Zahlreiche bungsaufgaben geben dem Leser die Mglichkeit, die Inhalte prak-tisch anzuwenden und so zu vertiefen. Da man Programmieren nur lernt, indem man es tut, mchte ich ausdrcklich dazu ermuntern, zumindest einen Teil der Aufgaben zu lsen und sich dann selbst neue Aufgaben zu stellen. Der Schwie-rigkeitsgrad der Aufgaben reicht von einfachen Wiederholungen des Textes bis zu kleinen Projektchen, die ein gewisses Ma an selbstndiger Arbeit erfordern. Die Lsungen der meisten Aufgaben findet man auf der beiliegenden CD und auf meiner Internetseite http://www.rkaiser.de.

Anregungen, Korrekturhinweise und Verbesserungsvorschlge sind willkommen. Bitte senden Sie diese an die Adresse [email protected].

Bei allen meinen Schulungskunden und ganz besonders bei Herrn W elsner und der Alcatel University der Alcatel SEL AG Stuttgart bedanke ich mich fr die Mg-lichkeit, dieses Manuskript in zahlreichen Kursen mit erfahrenen Praktikern wei-terzuentwickeln. Ohne die vielen Anregungen aus diesen Kursen htte es weder diesen Praxisbezug noch diesen Umfang erreicht. Peter Schwalm hat groe Teile des Manuskripts gelesen und es in vielen Diskussionen ber diffizile Fragen mit-gestaltet. Mein Sohn Alexander hat als perfekter Systembetreuer dafr gesorgt, dass die Rechner immer liefen und optimal installiert waren.

Die Untersttzung von Dr. Hans Wssner und seinem Team vom Springer-Verlag htte nicht besser sein knnen. Seine Hilfsbereitschaft und seine berragende fachliche Kompetenz waren immer wieder beeindruckend. ,,Meiner" Lektorin Ruth Abraham verdankt dieses Buch eine in sich geschlossene Form, die ich allein nicht geschafft htte. Die technische Herstellung war bei Gabi Fischer in erfahrenen guten Hnden. Herrn Engesser danke ich fr die gute Zusammenarbeit beim Abschluss des Projekts.

Tbingen, im Oktober 2001 Richard Kaiser

Inhalt

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

1.1 Visuelle Programmierung: Ein erstes kleines Programm ........................... 2 1.2 Erste Schritte in C++ ................................................................................ 6 1.3 Der Quelltexteditor ................................................................................... 9 1.4 Projekte, Projektdateien und Projektoptionen ........................................... 12 1.5 Einige Tipps zur Arbeit mit Projekten ...................................................... 15 1.6 Die Online-Hilfe ...................................................................................... 16 1.7 Das lokale Men ...................................................................................... 17 1.8 Die Symbolleiste ...................................................................................... 18 1. 9 Programmierhilfen .................................................................................. 19 1.10 Packages und eigenstndig ausfhrbare Programme ............................... 20

2 Die Komponentenpalette .................................................................... 23

2.1 Die Online-Hilfe zu den Komponenten .................................................... 23 2.2 Namen ..................................................................................................... 27 2.3 Labels und Datentypen ............................................................................ 30 2.4 Funktionen, Methoden und die Komponente TEdit .................................. 35 2.5 Memos, ListBoxen, ComboBoxen und die Klasse TStrings ...................... .40 2.6 Buttons und Ereignisse ........................................................................... .44 2.7 CheckBoxen, RadioButtons und einfache if-Abfragen ............................. .47 2.8 Die Container GroupBox, Panel und RadioGroup ................................... .49 2.9 ScrollBar ................................................................................................. 52 2.10 Hauptmens und Popup-Mens .............................................................. 55 2.11 Die Komponenten der Seite Dialoge ...................................................... 58 2.12 Der Aufruf von eigenen Formularen und modale Fenster G;l ................. 61 2.13 Die Komponenten der Seite "Zustzlich" G;l .............................. 66 2.14 Einige Komponenten der Seiten Win32 und Win 3.1 ............................. 72

2.14.1 Mehrseitige Dialoge G;l ............................................................. 73 2.14.2 ImageList und ListView G;l ......................................................... 74

G;l Siehe den Hinweis auf Seite xx

xii Inhalt

2.14.3 Komponenten zur Anzeige hierarchischer Datenstrukturen E8 ......... 76 2.14.4 Komponenten zur Grenanpassung anderer Komponenten E8 ........ 78 2.14.5 Formatierte Texte ............................................................................ 79 2.14.6 Statusanzeigen E8 ............................................................................ 80 2.14.7 Weitere Komponenten E8 ................................................................. 81

2.15 Einige Komponenten der Seite System E8 ............................................... 84 2.16 ActiveX-Komponenten E8 ...................................................................... 87 2.17 Vordefinierte DialogBoxen E8 ................................................................ 92

3 Elementare Datentypen und Anweisungen ........................................ 95

3.1 Windows-Programme und Units .............................................................. 95 3.2 Syntaxregeln ............................................................................................ 97 3.3 Variablen und Bezeichner. ..................................................................... lOO 3.4 Ganzzahldatentypen .............................................................................. 103

3.4.1 Die interne Darstellung von Ganzzahlwerten .................................. 106 3.4.2 Der Datentyp von Ganzzahlliteralen ............................................... 109 3.4.3 Zuweisungen und Standardkonversionen bei Ganzzahlausdrcken .. 111 3.4.4 Operatoren und die "blichen arithmetischen Konversionen" .......... 114 3.4.5 Der Datentyp bool ........................................................................... 120 3.4.6 Die char-Datentypen und der ASCII- und ANSI-Zeichensatz .......... 125 3.4.7 Der Datentyp _int64 ...................................................................... 132

3.5 Kontrollstrukturen und Funktionen ........................................................ l32 3.5 .1 Die if- und die Verbundanweisung .................................................. 133 3.5.2 Wiederholungsanweisungen ............................................................ l34 3.5.3 Funktionen und der Datentyp void .................................................. 135

3.6 Der integrierte Debugger ....................................................................... 140 3.7 G1eitkommadatentypen .......................................................................... 146

3.7.1 Die interne Darstellung von Gleitkommawerten .............................. 147 3.7.2 Der Datentyp von Gleitkommaliteralen ........................................... 150 3.7.3 Implizite Konversionen ................................................................... 151 3.7.4 Mathematische Funktionen ............................................................. 157

3.8 Syntaxregeln fr einfache Deklarationen ............................................... 162 3.9 Zeiger, Strings und dynamisch erzeugte Variablen ................................ 164

3.9.1 Die Definition von Zeigern ............................................................. 165 3.9.2 Der Adressoperator, Zuweisungen und generische Zeiger. ............... 167 3.9.3 Dynamisch erzeugte Variablen: new und delete .............................. 171 3.9.4 Zeiger als Parameter und die Zeigertypen der Windows-API.. ......... 175 3.9.5 Zeigerarithmetik ............................................................................. 177 3.9.6 NullterminierteStrings und Zeiger auf char .................................... l78 3. 9. 7 Zeiger auf Zeiger auf Zeiger auf ..................................................... 184 3.9.8 Referenztypen und Referenzparameter ............................................ 185

3.10 Konstanten .......................................................................................... 189 3.11 Deklarationen mit typedefund typeid-Ausdrcke ................................. 193 3.12 Aufzhlungstypen ................................................................................ 195

Inhalt Xlll

3.13 Kommentare und interne Programmdokumentation ............................. 200 3.14 Prprozessoranweisungen .................................................................... 204

3.14.1 Die include-Anweisung ................................................................. 204 3.14.2 Makros 8:> ...................................................................................... 206 3.14.3 Bedingte Kompilation EE> ............................................................... 209 3.14.4 Pragmas 8:> .................................................................................... 214

4 Strukturierte Datentypen und vordefinierte Klassen ....................... 217

4.1 Die Stringklassen AnsiString und string ................................................. 217 4.1.1 Die Verwendung von Elementfunktionen vordefinierter Klassen ..... 219 4.1.2 Gemeinsamkeiten und Unterschiede der Stringklassen .................... 221 4.1.3 Funktionen fr die Klasse AnsiString .............................................. 225 4.1.4 Einige Elementfunktionen der Klasse string .................................... 230

4.2 Arrays und Container ............................................................................ 235 4.2.1 Eindimensionale Arrays .................................................................. 235 4.2.2 Arrays als Container ....................................................................... 245 4.2.3 Mehrdimensionale Arrays ............................................................... 252 4.2.4 Arrays, Zeiger und Zeigerarithmetik ............................................... 256 4.2.5 Arrays als Funktionsparameter ........................................................ 259 4.2.6 Dynamisch erzeugte Arrays ............................................................ 263 4.2.7 Array-Eigenschaften der VCL. ........................................................ 267

4.3 Sequenzielle Container der Standardbibliothek ...................................... 268 4.3.1 Die Container-Klasse vector ........................................................... 269 4.3.2 Algorithmen der Standardbibliothek ............................................... 275 4.3.3 Die Container-Klassenlist und deque ............................................. 277 4.3.4 Die Container-Adapter stack, queueund priority_queue ................. 281 4.3.5 Container mit Zeigern ..................................................................... 282 4.3.6 Die Container-Klassebitset 8:> ......................................................... 283

4.4 Strukturen und Klassen .......................................................................... 285 4.4.1 Mit struct definierte Klassen ........................................................... 285 4.4.2 Verkettete Listen ............................................................................. 295 4.4.3 "Memory leaks" und die berwachung des Heap 8:> ......................... 306 4.4.4 Datenstrukturen mit generischen Zeigern 8:> .................................... 308 4.4.5 Mitunion definierte Klassen EE> ....................................................... 309 4.4.6 Die Datentypen TVarRec und Variant EE> ......................................... 313 4.4.7 Bitfelder 8:> ...................................................................................... 315

4.5 Einige Klassen der VCL ........................................................................ 316 4.5 .1 Ein wenig Grafik: TCanvas, Tlmage und TPrinter EE> ...................... 317 4.5.2 Die Steuerung von MS-Office: Word-Dokumente erzeugen 8:> ......... 327 4.5.3 Internet-Komponenten EE> ................................................................ 329

EE> Siehe den Hinweis auf Seite xx

xiv Inhalt

4.5.4 Visuell gestaltete Ausdrucke mit QuickReport ............................. 334 4.5.5 Kaufmnnische Rechnungen: Die Klassen Currency und BCD ... 337 4.5.6 Klassen und Funktionen zu Uhrzeit und Kalenderdatum ............. 339 4.5.7 Die Klasse Set ............................................................................. 343

4.6 Dateien .................................................................................................. 346 4.6.1 Stream-Variablen, ihre Verbindung mit Dateien und ihr Zustand .... 346 4.6.2 Fehler und der Zustand von Stream-Variablen ................................ 350 4.6.3 Lesen und Schreiben von Binrdaten mit read und write ................. 352 4.6.4 Lesen und Schreiben von Daten mit den Operatoren> ...... 360 4.6.5 Manipulatoren und Funktionen zur Formatierung von Texten ......... 369 4.6.6 Textbildschirm-Anwendungen ........................................................ 372 4.6.7 Stringstreams .................................................................................. 373 4.6.8 Dateibearbeitung im Direktzugriff ............................................... 375 4.6.9 Sortieren, Mischen und Gruppenverarbeitung ............................. 379 4.6.10 C-Funktionen zur Dateibearbeitung ........................................... 386

4.7 Assoziative Container ............................................................................ 389 4.7.1 Die Containerset und multiset ........................................................ 389 4.7.2 Die Container map und multimap .................................................... 391 4.7.3 lteratoren der assoziativen Container .............................................. 392

4.8 Die numerischen Klassen der Standardbibliothek .................................. 396 4.8.1 Komplexe Zahlen ........................................................................ 396 4.8.2 Valarrays und Slices .................................................................. .400

5 Anweisungen und Ausdrcke ........................................................... 407

5.1 Die Ausdrucksanweisung ...................................................................... .408 5.2 Ausdrcke ............................................................................................. 410

5.2.1 Primre Ausdrcke ..................................................................... 411 5.2.2 Postfix-Ausdrcke ....................................................................... 414 5.2.3 Unre Ausdrcke ........................................................................ 416 5.2.4 Typkonversionen in Typecast-Schreibweise ................................ .419 5.2.5 Zeiger auf Klassenelemente ........................................................ .420 5.2.6 Multiplikative Operatoren .......................................................... .420 5.2.7 Additive Operatoren ................................................................... .420 5.2.8 Shift-Operatoren ........................................................................ .421 5.2.9 Vergleichsoperatoren ................................................................. .422 5.2.10 Gleichheitsoperatoren .............................................................. .423 5.2.11 Bitweise Operatoren ................................................................. .423 5.2.12 Logische Operatoren ................................................................ .424 5.2.13 Der Bedingungsoperator ........................................................... .425 5.2.14 Konstante Ausdrcke .............................................................. ..427 5 .2.15 Zuweisungsoperatoren .................................................................. .427 5.2.16 Der Komma-Operator ............................................................. ..428 5.2.17 L-Werte und R-Werte ............................................................... .429

Siehe den Hinweis auf Seite xx

Inhalt XV

5.2.18 Die Prioritt und Assoziativitt der Operatoren E9 ........................ .430 5.2.19 Alternative Zeichenfolgen E9 ........................................................ .432 5.2.20 Explizite Typkonversionen E9 ....................................................... .434

5.3 Ein wenig Programmierlogik: Symbolische Ausfhrung ....................... .441 5.4 Die Deklarationsanweisung .................................................................. .449 5.5 Die Verbundanweisung und die Blockstruktur von C++ ........................ .450 5.6 Lebensdauer und Speicherklassenspezifizierer ...................................... .454 5.7 Auswahlanweisungen ............................................................................ 457

5.7.1 Die if-Anweisung ............................................................................ 458 5.7.2 Die switch-Anweisung ................................................................... .469 5.7.3 Ein wenig Programmierlogik fr Auswahlanweisungen ................. .472

5.8 Wiederholungsanweisungen ................................................................. .480 5.8.1 Die while-Anweisung ..................................................................... .481 5.8.2 Die da-Anweisung .......................................................................... 482 5.8.3 Die for-Anweisung .......................................................................... 483 5.8.4 Endlosschleifen, Abbruchbedingungen und Windows .................... .487 5.8.5 Ein wenig Programmierlogik fr Schleifen .................................... .493

5.9 Die Sprunganweisungen goto, breakund continue ................................ .499 5.10 Exception-Handling ............................................................................. 504

5.10.1 Die try-Anweisung ........................................................................ 505 5.10.2 Exception-Handler und Exceptions der Standardbibliothek ........... 509 5.10.3 Vordefinierte Exceptions der VCL ................................................ 513 5.1 0.4 Der Programmablauf bei Exceptions ............................................. 516 5.10.5 Das vordefinierte Exception-Handling der VCL ............................ 518 5.10.6 throw-Ausdrcke und selbst definierte Exceptions ......................... 519 5.10.7 Fehler, Exceptions und die Korrektheit von Programmen .............. 526 5.10.8 Die Freigabe von Ressourcen bei Exceptions ................................. 529 5.10.9 Exceptions in und die Funktion _matherr E9 .................. 536 5.10.10 Die Klasse auto_ptr E9 ................................................................. 537 5.10.11 Exception-Spezifikationen ........................................................... 539 5.10.12 Die Funktion terminate E9 ........................................................... 540 5.10.13 Das Win32-Exception-Handling mit try-_except E9 ................... 541

6 Funktionen ....................................................................................... 543

6.1 Die Definition und der Aufruf von Funktionen ...................................... 544 6.2 Die Verwaltung von Funktionsaufrufen ber den Stack .......................... 548 6.3 Funktionen mit Parametern ................................................................... 550

6.3.1 Werteparameter .............................................................................. 552 6.3.2 "Call by reference" mit Referenzparametern ................................... 554 6.3.3 Zeiger als Parameter ....................................................................... 557 6.3.4 Konstante Parameter ....................................................................... 559 6.3.5 Seiteneffekte und die Reihenfolge von Auswertungen ..................... 562 6.3.6 Default-Argumente ......................................................................... 566 6.3.7 Der Datentyp einer Funktion ........................................................... 568

E9 Siehe den Hinweis auf Seite xx

XVI Inhalt

6.3.8 Zeiger auf Funktionen ..................................................................... 570 6.3.9 Unspezifizierte Anzahl von Argumenten EB ..................................... 579 6.3.10 Die Funktionen main bzw. WinMain und ihre Parameter. .............. 580

6.3.11 Der Aufruf von Funktionen aus Deiphi im C++Builder EB ............. 582

6.3.12 Traditionelle K&R-Funktionsdefinitionen EB ................................. 584

6.3.13 Aufrufkonventionen EB .................................................................. 585 6.4 Schrittweise Verfeinerung als Entwurfstechnik ...................................... 585 6.5 Etwas Programmierlogik und-stilfr Funktionen .................................. 589 6.6 Rekursion .............................................................................................. 595

6.6.1 Quicksort ........................................................................................ 600 6.6.2 Ein rekursiv absteigender Parser ..................................................... 605

6.6.3 Rekursiv definierte Kurven EB ......................................................... 608

6.6.4 Indirekte Rekursion EB ..................................................................... 610 6.6.5 Rekursive Datenstrukturen und binre Suchbume .......................... 614 6.6.6 Rekursive Datenstrukturen in der Standardbibliothek von C++ ....... 619

6. 7 Inline-Funktionen .................................................................................. 622 6.8 berladene Funktionen .......................................................................... 624 6.9 berladene Operatoren mit globalen Operatorfunktionen ....................... 633

6.9.1 Globale Operatorfunktionen ............................................................ 634 6.9.2 Die Inkrement- und Dekrementoperatoren ...................................... 636 6.9.3 Referenzen als Funktionswerte ........................................................ 636 6.9.4 Die Ein- und Ausgabe von selbst definierten Datentypen ................. 639

7 Modulare Programmierung und Namensbereiche ........................... 643

7.1 Separate Kompilation und statische Bibliotheken ................................... 644

7.1.1 Projekte im C++Builder EB .............................................................. 644 7.1.2 Bindung EB ...................................................................................... 645

7.1.3 Deklarationen und Definitionen EB .................................................. 647

7.1.4 Die "One Definition Rule" EB .......................................................... 649

7.1.5 Reader-Dateien und Bibliotheken EB ................................................ 651

7.1.6 Der Aufruf von in C geschriebenen Funktionen EB ........................... 653 7.2 Dynamic Link Libraries (DLLs) ............................................................. 657

7.2.1 DLLs erzeugen EB ............................................................................ 657

7.2.2 Implizit geladene DLLs EB ............................................................... 659

7.2.3 Explizit geladene DLLs EB ............................................................... 660

7 .2.4 Hilfsprogramme zur Identifizierung von Funktionen in DLLs EB ..... 662

7.2.5 DLL-Funktionen mit visuell gestalteten Komponenten EB ................ 663

7.2.6 Projektgruppen EB ............................................................................ 664

7.2.7 Batch-Dateien EB ............................................................................. 666

EB Siehe den Hinweis auf Seite xx

Inhalt xvii

7.3 Namensbereiche .................................................................................... 667 7.3.1 Die Definition von benannten Namensbereichen ............................. 669 7.3.2 Die Verwendung von Namen aus Namensbereichen ........................ 671 7.3.3 Aliasnamen fr Namensbereiche ..................................................... 675 7.3.4 Unbenannte Namensbereiche .......................................................... 675 7.3.5 Module und das Geheimnisprinzip .................................................. 677

8 Objektorientierte Programmierung ................................................. 681

8.1 Klassen .................................................................................................. 682 8.1.1 Datenelemente und Elementfunktionen ........................................... 682 8.1.2 Der Gltigkeitsbereich von Klassenelementen ................................. 686 8.1.3 Objekte und die Zugriffsrechte private und public ........................... 688 8.1.4 Der Aufruf von Elementfunktionen und der this-Zeiger ................... 694 8.1.5 Konstruktaren und Destruktoren ..................................................... 696 8.1.6 00 Analyse und Design: Der Entwurf von Klassen ......................... 709 8.1. 7 Ein wenig Programmierlogik: Klasseninvarianten und Korrektheit. 714 8.1.8 UML-Diagramme fr Klassen und Objekte ..................................... 720

8.2 Klassen als Datentypen .......................................................................... 722 8.2.1 Der Standardkonstruktor ................................................................. 723 8.2.2 Objekte als Klassenelemente und Elementinitialisierer. ................... 725 8.2.3 friend-Funktionen und -Klassen ...................................................... 731 8.2.4 berladene Operatoren als Elementfunktionen ................................ 735 8.2.5 Der Copy-Konstruktor ..................................................................... 743 8.2.6 Der Zuweisungsoperator =fr Klassen ............................................ 751 8.2.7 Benutzerdefinierte Konversionen .................................................... 760 8.2.8 Explizite Konstruktaren Ei:) 764 8.2.9 Statische Klassenelemente .............................................................. 766 8.2.10 Konstante Klassenelemente und Objekte ....................................... 768 8.2.11 Weitere Deklarationsmglichkeiten in Klassen Et) ................ 770 8.2.12 Klassen und Reader-Dateien ......................................................... 771 8.2.13 berladene Operatoren fr new und delete Et) ........... 773

8.3 Vererbung ............................................................................................. 776 8.3.1 Die Elemente von abgeleiteten Klassen ........................................... 776 8.3.2 Zugriffsrechte auf die Elemente von Basisklassen ........................... 779 8.3.3 Die Bedeutung von Elementnamen in einer Klassenhierarchie ........ 781 8.3.4 using-Deklarationen in abgeleiteten Klassen Ei:) 783 8.3.5 Konstruktoren, Destruktoren und implizit erzeugte Funktionen ....... 784 8.3.6 Vererbung bei Formularen im C++Builder. ..................................... 790 8.3.7 00 Design: public Vererbung und "ist ein"-Beziehungen ............... 791 8.3.8 00 Design: Komposition und "hat ein"-Beziehungen ..................... 797 8.3.9 Konversionen zwischen public abgeleiteten Klassen ....................... 799 8.3.10 protected und private abgeleitete Klassen EB .................................. 802 8.3.11 Mehrfachvererbung und virtuelle Basisklassen .............................. 806

Ei:) Siehe den Hinweis auf Seite xx

xviii Inhalt

8.4 Virtuelle Funktionen, spte Bindung und Polymorphie .......................... 812 8.4.1 Der statische und der dynamische Datentyp .................................... 813 8.4.2 Virtuelle Funktionen ....................................................................... 814 8.4.3 Die interne Realisierung von virtuellen Funktionen: vptr und vtb/ ... 825 8.4.4 00-Design: Der Einsatzbereich von virtuellen Funktionen ............. 831 8.4.5 Komposition und private Mehrfachvererbung EB ............................. 832 8.4.6 Virtuelle Konstruktaren und Destruktoren ...................................... 833 8.4.7 Virtuelle Funktionen in Konstruktaren und Destruktoren EB ............ 836 8.4.8 Virtuelle Funktionen und Erweiterbarkeit ....................................... 837 8.4.9 Rein virtuelle Funktionen und abstrakte Klassen ............................. 840 8.4.10 00-Design: Virtuelle Funktionen und abstrakte Basisklassen ....... 843 8.4.11 Protokollklassen und Programmgerste ......................................... 848 8.4.12 Muster (Patterns) .......................................................................... 850 8.4.13 UML-Diagramme fr Vererbung und Komposition ....................... 855 8.4.14 Zeiger auf Klassenelemente EB ....................................................... 857

8.5 Laufzeit-Typinformationen .................................................................... 862 8.5.1 Typinformationen mit dem Operatortypeid EB ................................. 862 8.5.2 Typkonversionen mit dynamic_cast EB ............................................ 866 8.5.3 Anwendungen von Laufzeit-Typinformationen EB ........................... 870 8.5.4 static_cast mit Klassen EB ............................................................... 873 8.5.5 Laufzeit-Typinformationen fr die Klassen der VCL EB ................... 875

9 Die Bibliothek der visuellen Komponenten (VCL) .......................... 879

9.1 Besonderheiten der VCL. ....................................................................... 880 9.2 Visuelle Programmierung und Properties (Eigenschaften) ..................... 884

9.2.1 Lesen und Schreiben von Eigenschaften .......................................... 884 9.2.2 Array-Properties ............................................................................. 887 9.2.3 lndexangaben .................................................................................. 889 9 .2.4 Speicherangaben ............................................................................. 890 9 .2.5 berschriebene Eigenschaften ......................................................... 891

9.3 Die Klassenhierarchie der VCL ............................................................. 891 9.4 Selbst definierte Komponenten und ihre Ereignisse ............................... 899 9.5 MDI-Programme ................................................................................... 904 9.6 Klassenreferenztypen und virtuelle Konstruktaren ................................. 907 9.7 Botschaften (Messages) .......................................................................... 912

9. 7.1 Die Message Queue und die Window-Prozedur ............................... 912 9.7.2 Botschaften fr eine Anwendung .................................................... 914 9.7.3 Die Behandlung von Botschaften in der VCL. ................................. 915 9.7.4 Selbst definierte Message-Handler fr Windows-Steuerelemente ..... 921 9.7.5 Botschaften versenden ..................................................................... 923

9.8 Die Erweiterung der Komponentenpalette .............................................. 927

EB Siehe den Hinweis auf Seite xx

Inhalt xix

10 Templates und die STL .................................................................. 935

10.1 Generische Funktionen: Funktions-Templates ...................................... 936 10.1.1 Die Deklaration von Funktions-Templates mit Typ-Parametern .... 937 1 0.1.2 Spezialisierungen von Funktions-Templates .................................. 939 10.1.3 Funktions-Templates mit Nicht-Typ-Parametern E9 ....................... 944 1 0.1.4 Explizit instanziierte Funktions-Templates EEl ............................... 946 10.1.5 Explizit spezialisierte und berladene Templates .......................... 946 1 0.1.6 Rekursive Funktions-Templates .................................................... 950

10.2 Generische Klassen: Klassen-Templates .............................................. 953 10.2.1 Die Deklaration von Klassen-Templates mit Typ-Parametern ........ 953 10.2.2 Spezialisierungen von Klassen-Templates ..................................... 954 10.2.3 Templates mit Nicht-Typ-Parametern E9 ....................................... 962 10.2.4 Explizit instanziierte Klassen-Templates E9 ................................... 963 10.2.5 Partielle und vollstndige Spezialisierungen E9 .............................. 964 10.2.6 Elemente undfriend-Funktionen von Klassen-Templates E9 .......... 970 10.2.7 Ableitungen von Templates E9 ....................................................... 974 10.2.8 Exportierte Templates ................................................................... 975 10.2.9 UML-Diagramme fr parametrisierte Klassen E9 ........................... 976

10.3 Funktionsobjekte in der STL. ............................................................... 980 10.3.1 Der Aufrufoperator () .................................................................... 980 10.3.2 Prdikate und arithmetische Funktionsobjekte ............................... 982 10.3.3 Binder, Funktionsadapter und Negatoren ...................................... 986

10.41teratoren und die STL-Algorithmen .................................................... 992 10.4.1 Die verschiedenen Arten von lteratoren ........................................ 993 10.4.2 Urnkehriteratoren .......................................................................... 995 10.4.3 Einfgefunktionen und Einfgeiteratoren ...................................... 996 10.4.4 Stream-Iteratoren .......................................................................... 998 10.4.5 Container-Konstruktaren mit lteratoren ........................................ 999 10.4.6 STL-Algorithmen fr alle Elemente eines Containers ................. 1000

10.5 Die Algorithmen der STL .................................................................. 1002 10.5.1 Lineares Suchen .......................................................................... 1003 10.5.2 Zhlen ........................................................................................ 1005 10.5.3 Der Vergleich von Bereichen ...................................................... 1005 10.5.4 Suche nach Teilfolgen ................................................................. 1007 10.5.5 Minimum und Maximum ............................................................ 1008 10.5.6 Elemente vertauschen ................................................................. 1010 10.5.7 Kopieren von Bereichen .............................................................. 1011 10.5.8 Elemente transformieren und ersetzen ......................................... 1012 10.5.9 Elementen in einem Bereich Werte zuweisen .............................. 1014 10.5.10 Elemente entfernen ................................................................... 1014 10.5.11 Die Reihenfolge von Elementen vertauschen ............................. 1 016 10.5.12 Permutationen ........................................................................... 1017 10.5.13 Partitionen ................................................................................ 1018 10.5.14 Bereiche sortieren ..................................................................... 1019 10.5.15 Binres Suchen in sortierten Bereichen ..................................... 1021

E9 Siehe den Hinweis auf Seite xx

XX Inhalt

10.5.16 Mischen von sortierten Bereichen ............................................. 1022 10.5.17 Mengenoperationen auf sortierten Bereichen ............................. 1023 10.5.18 Heap-Operationen ..................................................................... 1 024 10.5.19 Verallgemeinerte numerische Operationen ................................ 1025

11 Verschiedenes ............................................................................... 1027

11.1 3D-Grafik mit OpenGL.. .................................................................... 1028 11.1.1 Initialisierungen .......................................................................... 1028 11.1.2 Grafische Grundelemente: Primitive ........................................... 1031 11.1.3 Modelltransformationen .............................................................. 1 036 11.1.4 Vordefinierte Krper .................................................................. . 1 039 11.1.5 Lokale Transformationen ...................................................... ...... 1 041 11.1.6 Beleuchtungseffekte .................................................................... 1 044 11.1.7 Texturen ..................................................................................... 1046

11.2 Win32-Funktionen zur Dateibearbeitung ........................................... 1051 11.2.1 Elementare Funktionen ............................................................... 1051 11.2.2 Der gleichzeitige Zugriff von mehreren Anwendern auf e. Datei .1 055 11.2.3 Record-Locking .......................................................................... 1056 11.2.4 VCL-Funktionen zur Dateibearbeitung und TFileStream ............. 1057

11.3 Datenbertragung ber die serielle Schnittstelle ................................. 1059 11.3.1 Grundbegriffe ............................................................................. 1060 11.3.2 Standards fr die serielle Schnittstelle: RS-232C bzw. V.24 ........ 1061 11.3.3 Win32-Funktionen zur seriellen Kommunikation ........................ 1063

11.4 Datenbank-Komponenten der VCL .................................................... 1067 11.4.1 Tabellen und die Komponente TTable ......................................... 1067 11.4.2 Die Anzeige von Tabellen mit der Komponente DBGrid ............. 1 072 11.4.3 Indizierte Tabellen ...................................................................... 1075 11.4.4 Datenbanken mit mehreren Tabellen ........................................... 1078 11.4.5 SQL-Abfragen ............................................................................ 1 080 11.4.6 Transaktionen und Cached Updates ............................................ 1082 11.4.7 Die BDE am Beispiel von ODBC und MS Access Datenbanken .. 1084 11.4.8 Visuell gestaltete Datenbank-Ausdrucke mit QuickReport ........... 1086

Literaturverzeichnis .......................................................................... 1091

Verschiedenes .................................................................................... 1095

Angesichts des Umfangs dieses Buches habe ich einige Abschnitte mit dem Zeichen in der berschrift als "weniger wichtig" gekennzeichnet. Damit wollte ich dem Anfnger nur eine kleine Orientierung durch die Flle des Stoffes geben. Eine solche Kennzeichnung soll aber berhaupt nicht bedeuten, dass dieser Teil unwichtig ist. Es kann sogar gut sein, dass gerade Sie diese Inhalte laufend bentigen.

1 Die Entwicklungsumgebung

Der C++Builder besteht aus einer greren Anzahl von Werkzeugen (Tools), mit denen Windows-Programme entwickelt werden knnen. Eine solche Zusammen-stellung von Werkzeugen zur Programmentwicklung bezeichnet man auch als Programmier- oder Entwicklungsumgebung.

Einfache Entwicklungsumgehungen bestehen nur aus einem Editor, von dem aus ein integrierter Compiler aufgerufen werden kann. Mit der zunehmenden Kom-plexitt der Software und des damit verbundenen Entwicklungsaufwands wurden aber immer mehr Tools notwendig. Wenn diese Tools wie im C++Builder unter einer einheitlichen Benutzeroberflche integriert sind, spricht man auch von einer integrierten Entwicklungsumgebung.

In diesem Kapitel werden die wichtigsten Werkzeuge der Entwicklungsumge-bung des C++Builders vorgestellt. Weitere werden spter beschrieben, wenn sie dann auch eingesetzt werden knnen.

2 1 Die Entwicklungsumgebung

1.1 Visuelle Programmierung: Ein erstes kleines Programm

Nach dem Start des C++Builders wird ein Teil der Tools angezeigt:

Komponcntenpalcuc mit der Seite Standard - weitere Seiten (Zus!itzlich. Datenzugrirrusw.) stehen Oberdie Register zur Verfgung

r-t~.u fl'-" ..... m--. -~~ ,., __ 1'-

1.1 Visuelle Programmierung: Ein erstes kleines Programm 3

und knnen ber die Register (Standard, Zustzlich usw.) angewhlt werden. Ein Teil dieser Komponenten (wie z.B. Buttons, ListBoxen, ComboBoxen von der Seite Standard) entspricht Steuerelementen, die im laufenden Programm ange-zeigt werden . Andere, wie der Timer von der Seite System, sind im laufenden Programm nicht sichtbar.

Zeigen;ymbol. mit dem die Anwahl einer Komponente zurckgesetzt werden kann

Falls Ihnen die kleinen lcons nicht allzu viel sagen, lassen Sie einfach den Maus-zeiger kurz auf einer Komponente stehen: Dann erscheint ein kleines gelbes Hinweisfenster, das den Namen der Komponente anzeigt.

Eine Komponente aus der Komponentenpalette wird dem Formular hinzugefgt, indem man die gewnschte Komponente zunchst mit einem einfachen Maus-klick markiert (die Schaltflche wird dann als gedrckt dargestellt). Anschlie-end zeigt man mit dem Mauszeiger auf die Stelle im Formular, an die die linke obere Ecke der Komponente kommen soll , und setzt die Komponente durch einen einfachen Mausklick auf das Formular.

Beispiel: Nachdem man ein Label (die dritte Komponente von links mit dem groen A), ein Edit-Fenster (die vierte Komponente von links mit der Aufschrift ab) und einen Button (die sechste von links mit der Auf-schrift OK) auf das Formular gesetzt hat, sieht es etwa folgendermaen aus:

,.folm1 R[!]

4 I Die Entwicklungsumgebung

Diese Art der Programmierung bezeichnet man auch als visuelle Programmie-rung. Whrend man bei der konventionellen Programmierung ein Programm ausschlielich durch das Schreiben von Anweisungen (Text) in einer Program-miersprache entwickelt, wird es bei der visuellen Programmierung ganz oder teilweise aus vorgefertigten grafischen Komponenten zusammengesetzt. Damit sieht man bereits beim Entwurf des Programms, wie es spter zur Laufzeit aus-sehen wird.

Mit dem C++Builder kann die Benutzeroberflche eines Programms visuell ge-staltet werden. Die Anweisungen, die als Reaktionen auf Benutzereingaben (Mausklicks usw.) erfolgen sollen, werden dagegen konventionell in der Pro-grammiersprache C++ geschrieben.

Durch diese Spielereien haben Sie schon ein richtiges Windows-Progranun er-stellt- zwar kein besonders ntzliches, aber immerhin. Sie knnen dieses Pro-gramm folgendermaen starten:

- mit StartiStart von der Menleiste, - mit F9 von einem beliebigen Fenster im C++Builder oder - durch den Aufruf der vom Compiler erzeugten Exe-Datei.

Dieses Programm hat schon viele Eigenschaften, die man von einem Windows-Programm erwartet: Man kann es mit der Maus verschieben, vergrern, verklei-nern und schlieen.

Bemerkenswert an diesem Programm ist vor allem der geringe Aufwand, mit dem es erstellt wurde. Im Vergleich zu einem nichtvisuellen Entwicklungssystem stellt man eine betrchtliche Arbeitserleichterung fest. So braucht Petzold in seinem Klassiker "Programmierung unter Windows" (Petzold 1992, S. 33) ca. 80 Zeilen fr ein einfaches C-Programm, das (wie in einem Label) den Text "Hello Windows" in ein Fenster schreibt. Und in jeder dieser 80 Zeilen kann man einiges falsch machen.

Die zuletzt auf ein Formular gesetzte Komponente ist dann immer so lange die aktuell ausgewhlte Komponente, bis eine andere ausgewhlt wird. Man er-kennt sie im Formular an den 8 kleinen schwarzen Quadraten an ihrem Rand, den so genannten Ziehquadraten. Setzt man den Mauszeiger auf eines der Zieh-quadrate und drckt die linke Maustaste, kann man die Gre der Komponente durch Ziehen mit der Maus verndern.

1.1 Visuelle Programmierung: Ein erstes kleines Programm

Der Objektinspektor zeigt immer die Eigenschaf-ten der aktuell ausgewhlte Komponente an. In der linken Spalte stehen die Namen und in der rechten die Werte der Eigenschaften.

Den Wert einer Eigenschaft kann man nach dem Anklicken der jeweiligen Zeile verndern, indem man einen neuen Wert eintrgt. Ersetzt man z.B. den Wert "Button I" fr Caption (berschrift) durch "OK", wird die Aufschrift auf dem Button im Formular verndert.

Mit der Taste Fl erhlt man eine Beschreibung der Eigenschaft.

5

ObJektinspektor ll3

j Button1: TBulton :::J Eigenschalten I Ereignisse J

Action l!JAnchors

BiOiMode Cancel Caption

l!JConstr~ CI.ISOI Defd 0 rag(:I.ISOI Dr~ Drad-Aode Enabled

crOrag dkDrag drnMaooal true (TFoot) 25 0

Genauso, wie der Wert einer Komponente im Formular an die aktuellen Werte im Objektinspektor angepasst wird, werden die Werte im Objektinspektor an die aktuellen Werte einer Komponente im Formular angepasst: Wenn man die Gre einer Komponente durch Ziehen an den Ziehquadraten verndert, werden die entsprechende Werte (Left, Top, Height oder Width) im Objektinspektor automa-tisch aktualisiert.

Wenn man mit der Maus eine freie Stelle im Formular anklickt, wird das Formu-lar die aktuell ausgewhlte Komponente. Man kann dann die Eigenschaften des Formulars im Objektinspektor verndern. Fr ein Formular bezeichnet Caption die Fensterberschrift, und wenn man hier "mein erstes C++-Pro-gramm" eintrgt, wird die Titelzeile des Formulars entsprechend angepasst. Oder man kann die Farbe des Formulars verndern, indem man Color anklickt und im Pulldown-Men clYellow fr ein wunderschnes Gelb auswhlt.

Im Unterschied zu einem Button ist ein Formular nicht durch Ziehquadrate als aktuell ausgewhlte Komponente gekennzeichnet. Es wird aber wie jede andere ausgewhlte Komponente im Objektselektor des Objektinspektors angezeigt:

I Objektselektor

Klickt man im Objektselektor rechts das kleine, nach unten zeigende Dreieck an, erhlt man ein Pulldown-Men:


Whlt man aus diesem Pulldown-Men eine Komponente aus, ist sie dann die aktuell ausgewhlte.

1.2 Erste Schritte in C++

Wie bereits erwhnt wurde, ist das im letzten Abschnitt entwickelte Programm nicht besonders ntzlich: Es stellt lediglich einige Steuerelemente dar und hat vom C++Builder einige allgemeine Eigenschaften erhalten, die fr Windows-Programme typisch sind. Die auf das Formular platzierten Komponenten reagie-ren jedoch auf keine Benutzereingabe. Zwar kann man den Button anklicken, der dann auch gedrckt dargestellt wird, aber es erfolgt keine Reaktion darauf -welche sollte auch erfolgen?

Windows-Programme reagieren auf Benutzereingaben in Form von Mausklicks oder Tastatureingaben. Im Gegensatz zu einfachen DOS-Programmen ist es aber nicht notwendig und auch nicht mglich, Benutzereingaben in speziellen Anwei-sungen (wie Readln in Pascal oder scanf in C) direkt entgegenzunehmen. Statt-dessen werden alle Eingaben von Windows zentral entgegengenommen und als so genannte Botschaften (Messages, Meldungen) an das entsprechende Pro-gramm weitergegeben. Diese Botschaften lsen dann in dem Programm, fr das sie bestimmt sind, ein so genanntes Ereignis aus.

Die Ereignisse, auf die eine Komponente des C++Builders reagieren kann, zeigt der Objektinspektor fr die jeweils aktuelle Komponente an, wenn man das Register Ereignisse anklickt.

Die folgende Abbildung zeigt die Ereignisse fr einen Button. Dabei steht OnClick fr das Ereignis, das beim Anklicken der Komponente eintritt:

1.2 Erste Schritte in C++ 7

Obtekltnspeklor 1!3

I Bultonl : TButton ::::J

OnEnd)rag OnEnter OnEICII OnKej{)own OnKeyPress OnKe}II.Jp OnMouoeO

Ereignis;el

Mit einem Doppelklick auf die rechte Spalte eines Ereignisses kann man den Quelltexteditor aufrufen. Dabei erzeugt der C++Builder automatisch den Rah-men fr eine Funktion, die auf das angewhlte Ereignis reagiert. So erhlt man nach einem Doppelklick auf das Ereignis OnClick der Komponente Button]:

Der hier dargestellte Programmtext von "void" bis ")" wurde vom C++Builder automatisch erzeugt. Zwischen den geschweiften Klammern "{" und "}" kann man jetzt in der Programmiersprache C++ die Anweisungen schreiben, die das Programm ausfhren soll, wenn das Ereignis OnClick eintritt.

Da OnClick eines der am hufigsten benutzten Ereignisse bei einem Button ist, erhlt man dieses Programmfragment auch durch einen Doppelklick auf einen Button im Formular.

Welche Anweisungen mglich sind und wie diese aufgebaut werden mssen, ist der Hauptgegenstand dieses Buches und wird ab dem bernchsten Kapitel aus-fhrlich beschrieben. Im Rahmen dieses einfhrenden Kapitels sollen nur einige wenige Anweisungen vorgestellt werden und diese auch nur so weit, wie das zum Grundverstndnis des C++Builders notwendig ist. Falls Ihnen Begriffe wie "Variablen" usw. neu sind, lesen Sie trotzdem weiter- aus dem Zusammenhang erhalten Sie sicherlich eine intuitive Vorstellung, die zunchst ausreicht. Spter werden diese Begriffe dann genauer erklrt.


Eine beim Programmieren hufig verwendete Anweisung ist die Zuweisung (mit dem Operator"="), mit der man einer Variablen einen Wert zuweisen kann. Als Variablen sollen zunchst nur solche Eigenschaften von Komponenten verwendet werden, die auch im Objektinspektor angezeigt werden. Diesen Variablen knnen dann die Werte zugewiesen werden, die auch im Objektinspektor in der rechten Spalte der Eigenschaften vorgesehen sind.

In der folgenden Abbildung sieht man einige zulssige Werte fr die Eigenschaft Color. Sie werden nach dem Anklicken des kleinen Dreiecks (rechts vom aktuel-len Wert) angezeigt.

0 bjeklinspektor l:l Editl : TEdit

Eigenschalten I Ereignisse I -~-----

BorderStyle bsSingle CMICase ecNormal

Schreibt man jetzt zwischen die geschweiften Klammem die Anweisung

Editl->Color = clYellow;

wird dadurch festgelegt, dass beim Anklicken von Button] whrend der Ausfh-rung des Programms die Eigenschaft Edit->Color den Wert c!Yellow erhlt, der fr die Farbe Gelb steht:

void __ fastcall TForml::ButtonlClick(TObject *Sender) { Editl->Color = clYellow; }

Wenn Sie das Programm jetzt mit F9 starten und dann Button] anklicken, erhlt das Textfeld im Edit-Fenster tatschlich die Farbe Gelb.

Auch wenn dieses Programm noch nicht viel sinnvoller ist als das erste, haben Sie doch gesehen, wie mit dem C++Builder Programme entwickelt werden. Die-ser Entwicklungsprozess besteht immer aus den folgenden Aktivitten, die in beliebiger Reihenfolge ausgefhrt werden knnen:

1.3 Der Quelltexteditor 9

1. Man whlt eine Komponente aus der Komponentenpalette aus und fgt diese einem Formular hinzu.

2. Man setzt die Werte von Eigenschaften im Objektinspektor bzw. ndert das Layout eines Formulars mit der Maus.

3. Man schreibt in C++ die Anweisungen, die als Reaktion auf Benutzereinga-ben erfolgen sollen.

4. Man startet das Programm und testet, ob es sich auch wirklich so verhlt, wie es sich verhalten soll.

Die Aktivitten unter 1. und 2. werden auch als visuelle Programmierung bezeichnet und betreffen vor allem die Gestaltung der Benutzeroberflche. Hier werden die im Objektinspektor angezeigten Eigenschaften von Komponenten angepasst, ohne dass Anweisungen in einer Programmiersprache geschrieben werden mssen. Die Aktivitten unter 3. sind dagegen konventionelle (nichtvi-suelle) Programmierung, da Anweisungen in einer Programmiersprache ge-schrieben werden.

Der gesamte Zeitraum der Programmentwicklung (Aktivitten 1.-3.) wird auch als Entwurfszeit bezeichnet. Im Gegensatz dazu bezeichnet man die Zeit, wh-rend der ein Programm luft (vom Start bis zum Ende), als Laufzeit eines Programms.

Diese Unterscheidung ist nicht ganz so belanglos, wie sie sich zunchst vielleicht anhren mag. So stehen fr die meisten Komponenten whrend der Entwurfszeit im Objektinspektor nicht alle die Eigenschaften zur Verfgung, die auch wh-rend der Laufzeit zur Verfgung stehen. Auf die Eigenschaften, die nur whrend der Laufzeit eines Programms verfgbar sind, kann man nur ber Anweisungen in C++ zugreifen. Aus diesem Grund wird zwischen ,,Eigenschaften zur Ent-wurfszeit" und "Eigenschaften zur Laufzeit" unterschieden.

1.3 Der Quelltexteditor

Der Quelltexteditor (kurz: Editor) ist das Werkzeug, mit dem die Quelltexte ge-schrieben werden. Er ist in die Entwicklungsumgebung des C++Builders inte-griert und kann von verschiedenen Stellen aus aufgerufen werden, z.B. durch einen Doppelklick auf

- das Register des Fensters einer Unit. Die bisherige Position des Cursors wird dabei nicht verndert. Er befindet sich an derselben Stelle wie beim letzten Aufruf des Editors.

- die rechte Spalte eines Ereignisses auf der Seite Ereignisse des Objektinspek-tors. Der Cursor befindet sich dann in der Routine, die zu dem angeklickten Ereignis gehrt.


- eine Komponente in einem Formular. Der Cursor befindet sich dann in einer Funktion, die zu einem bestimmten Ereignis fr diese Komponente gehrt.

Der Editor kann auerdem von der Menleiste aus ber Ansicht! Units aufgerufen werden. Mit Fl2 kann man zwischen einem Formular und der zugehrigen Unit wechseln.

Da ein Doppelklick auf eine Komponente im Formular oder das entsprechende Ereignis im Objektinspektor den Editor an der zum Ereignis gehrigen Stelle ffnet, muss man den Quelltext fr eine bestimmte Ereignisbehandlungsroutine nicht mhsam im Quelltexteditor suchen.

Der Editor enthlt ber Tastenkombinationen zahlreiche Funktionen, mit denen sich nahezu alle Aufgaben effektiv durchfhren lassen, die beim Schreiben von Programmen auftreten. Unter Toolsl Umgebungsoptionen kann die Tastaturbe-legung auf die von einigen verbreiteten Editoren vordefiniert und individuell angepasst werden. Im Folgenden sind nur einige der wichtigsten Tastenkombina-tionen fr die nach der Installation eingerichtete "Vorgabe-Tastaturbelegung" (auch als "Standard-Tastaturvorlage" bezeichnet) zusammengestellt:

Tastenkrzel Aktion oder Befehl

Fl bzw. Strg+FI wie Hilfe llnhalt, oder fall der Cur or ber einem Wort steht, kontextsensitiv

F3 wie SucheniSuche wiederholen Strg+F wie SucheniSuchen Strg+ R wie SucheniErsetzen.

Strg+P interpretiert da nchste eingegebene Zeichen als Steuerzeichen, z.B. das Zeichen "C" als Strg+C. Damit knnen Steuerzeichen in den Quelltext ge-schrieben werden.

Strg +S wie Datei iDatei speichern

StrR+T lscht das Wort ab der Cursorposition Strg+Y lscht die gesamte Zeile Strg+Rcktaste lscht das Wort rechts vom Cursor Strg+En.tf lscht einen aktuellen Block StrR+Vmschalt+ Y lscht die Zeile ab dem Cursor bis zum Ende

All+Rcktasle oder wie BearbeiteniRckgngig. Damit knnen Editor-Strg+Z Aktionen rckgngig gemacht werden Alt+Umschalt+ wie Bearbeiten I Widerrufen Rckraste oder Strg+Umschalt+Z

Strg+Umschalt+f rckt d n a ls Block markierten Text eine Spalte bzw. nach links bzw. rechts (zum Au - und Einrcken Strg+Umschalt+U von (}-B lcken)

1.3 Der Quelltexteditor 11

Tastenkrzel Aktion oder Befehl

All+[ bzw. Alt+] ucht das pas nd B gr nzung zeichen (z. B. Klammern) vorwrts bzw. rckwrts

Pos / bzw. Ende Cursor pringt an d n Anfang bzw. das Ende der Ze ile

Strg+Posl bzw. Cur or pringt an den Anfang bzw. das Ende der Strg+Ende Datei Strg+~ bzw. versetzt d n Cur or um in Wort nach link bzw. Strg+....,. rechts

Strg+Tab versetzt den Cursor auf die nchste Seite Strg+ Umschalt+ Tab versetzt den Cursor auf die vorhergehende Seite Srrg+Bildf bzw. ver chiebt den Cursor an den oberen bzw. unteren Strg+BildJ Bi ldschirmrand

Strg+ 1 bzw. ver ch iebt den Text um eine Zeile nach oben bzw. Strg+ J unten

Srrg+Eingabetasre ff11et eine Datei mit dem Dateinamen , der dem Wort unter dem Cursor entspricht

Alt+Shift+ ~ zum Markieren von Spalten Alt+Shift+--+

Alt+Shift+ f Alt+Shift+ J Einfg schaltet zwischen Einfgen und berschreiben um

FJJ wie Ansicht!Objektinspektor F/2 wie Ansicht] Umschalten Formular/Unit

Alr+FlO zeigt ein lokales Men an Alt+O wie Ansicht! Fensterliste Strg+F/2 wie Ansicht! Units Umschalt+F 12 wie Ansiclzt!Formulare

Strg+Umschalt+R zeichnet e in Tastaturmakro auf Strg+Umschalt+P spielt ein Tastaturmakro ab

Dazu kommen noch die blichen Tastenkombinationen unter Windows, wie Markieren eines Textteils mit gedrckter Shift-Taste und gleichzeitigem Bewe-gen des Cursors bzw. mit der Maus bei gedrckter linker Maustaste. Ein so mar-kierter Bereich kann dann mit Strg+X ausgeschnitten, Strg+C kopiert, Strg+ V eingefgt und mit Entf gelscht werden. Diese Operationen stehen auch in der Menleiste unter Bearbeiten zur Verfgung.

Die Beachtung der folgenden Regel kann eine Menge rger ersparen: Eine vom C++Builder automatisch erzeugte Funktion sollte man nicht manuell lschen. Der C++Builder entfernt eine solche Funktion beim nchsten Kompilieren automatisch, wenn zwischen den geschweiften Klammern kein Text steht.


Beispielsweise erzeugen Anfnger manchmal versehentlich durch einen Doppel-klick auf ein Edit-Fenster den folgenden Rahmen fr eine Funktion:

void __ fastcall TForml::EditlChange(TObject *Sender) {

}

Diese Funktion wird zur Laufzeit des Programms bei jeder nderung des Textes im Edit-Fenster aufgerufen. Da man aber auf solche nderungen meist nicht rea-gieren will, kann man die Funktion durch den C++Builder wieder entfernen las-sen, indem man nichts zwischen die geschweiften Klammern schreibt.

Es wird dringend davon abgeraten, sie manuell aus dem Quelltext zu lschen. Sonst erhlt man nach dem Kompilieren vom Linker eine Fehlermeldung der Art

LinkerFehler Unresolved external 'TForml::EditlChange( ...

Falls ein solcher Fehler trotzdem einmal auftritt, macht ein Anfanger am ein-fachsten alle bisherigen Eingaben mit Alt+Rcktaste wieder rckgngig, bis die Funktion wieder angezeigt wird, oder er fangt das gesamte Projekt nochmals neu an. Falls der damit verbundene Aufwand zu gro ist, kann man auch in der Header-Datei zur Unit (die man mit Strg+F6 im Editor erhlt) die folgende Zeile durch die beiden Zeichen"//" auskommentieren:

II void __ fastcall EditlChange(TObject *Sender);

Ansonsten wird ein Anfnger aber vor jeder Vernderung dieser Datei gewarnt.

Aufgabe:

Schreiben Sie einen kleinen Text im Editor und probieren Sie die Tastenkombi-nationen aus. Insbesondere sollten Sie zumindest einmal gesehen haben, wie man mit Alt-Rcktaste nderungen rckgngig machen kann, mit Alt-Umschalt-Rck taste rckgngig gemachte nderungen wiederherstellen kann und mit Strg-+Umschalt+l bzw. -+U markierte Blcke ein- und ausrcken kann.

1.4 Projekte, Projektdateien und Projektoptionen

Nachdem man ein Programm oder Teile davon geschrieben hat, wird man es meist auf der Festplatte speichern wollen. Dafr bietet die Menleiste vor allem die Option DateilAUes speichern und die Symbolleiste das Symbol

1.4 Projekte, Projektdateien und Projektoptionen 13

an. Damit werden alle Dateien gespeichert, die fr den C++Builder zu einem Projekt gehren. Falls dieses Symbol oder die entsprechende Menoption nicht aktiviert ist, wurden die Dateien seit dem letzten Speichern nicht verndert.

Beim erstmaligen Speichern fragt der C++Builder zuerst nach einem Namen fr alle zum Projekt gehrenden Units und dann nach einem Namen fr das Projekt.

Der fr das Projekt angegebene Name wird fr die Exe-Datei verwendet, die durch das Projekt erzeugt wird. Auerdem werden Dateien mit dem Projekt-namen und den folgenden Namensendungen erzeugt:

.CPP Diese Datei ist das so genannte Hauptprogramm und enthlt den Quelltext fr den Aufruf der Funktion WinMain. Sie wird vom C++Builder automatisch angelegt und verwaltet und sollte normalerweise nicht manuell verndert werden .

. BPR Die so genannte Projekt-Datei.

.OBI Eine so genannte Object-Datei.

.RES Die so genannte Ressourcen-Datei.

Der fr eine Unit angegebene Name wird fr Dateien mit den folgenden Endun-gen verwendet:

.CPP

. H

. OBI

.DFM

Der C++Builder erzeugt fr jedes Formular automatisch eine so genannte Unit. Sie enthlt die Funktionsdefinitionen fr die ausge-whlten Ereignisse und wird vom Programmierer durch eigene An-weisungen ergnzt. EineHeader-Datei mit Klassendefinitionen . Eine weitere Object-Datei . Diese Datei enthlt fr jedes Formular die Daten aller visuellen Komponenten und ihrer Eigenschaften. Sie wird beim Speichern einer Unit automatisch als Binrdatei gespeichert. Sie kann aber auch als Textdatei gespeichert werden. Dann knnen Unterschiede zwischen verschiedenen Versionen eines Formulars leichter verglichen werden.

Zu einem Projekt gehren noch weitere Dateien, in denen der C++Builder interne Einstellungen zum Projekt oder zur Entwicklungsumgebung speichert. Dateien, deren Namensendung mit dem Zeichen- beginnt (-CP, -DF), sind Sicherungs-kopien der CPP- und DFM-Dateien, die vor dem Speichern der aktuellen Version angelegt werden.

Angesichts der relativ groen Anzahl von Dateien, die zu einem Projekt gehren, empfiehlt Borland, jedes Projekt in einem eigenen Verzeichnis zu speichern. Das ist bei greren Projekten mit mehreren Units meist empfehlenswert, bei vielen kleinen Projekten (wie den spter folgenden Aufgaben) aber eher umstndlich.


Da sowohl zum Projektnamen als auch zum Namen der Uniteine Datei mit der Endung ".cpp" angelegt wird, mssen fr das Projekt und die Units verschiede-ne Namen vergeben werden. Das erreicht man am einfachsten dadurch, dass man beiden Namen gibt, die mit derselben Zeichenfolge beginnen. So sieht man im Explorer, welche Dateien zusammengehren. Damit die Namen des Projekts und der Unit verschieden sind, reicht es aus, wenn sie sich im letzten Buchstaben unterscheiden (z.B . durch ein "P" fr die Projektdatei oder ein "U" fr die Unit).

Zum Speichern von Dateien gibt es auerdem noch die folgenden Optionen:

- DateiiProjekt speichern unter speichert die zu einem Projektnamen gehren-den Dateien unter einem neuen Namen. Diese Option sollte nicht so verstan-den werden, dass man damit alle Dateien eines Projekts speichern kann (z.B. auf Diskette). Wenn man danach das Projekt von der Diskette bearbeiten will, ist die Enttuschung meist gro: Die Dateien mit den Units fehlen .

- Dareilspeichern bzw. Strg+S bzw. das Anklicken des Diskettensymbols in der Symbolleiste speichert die derzeit im Editor angezeigte Unit einschlielich der zugehrigen Header- und Formulardatei .

Es empfiehlt sich, ein Projekt oder zumindest die gerade bearbeiteten Dateien regelmig zu speichern. Man kann nie ausschlieen, dass sich Windows oder ein anderes Programm aufhngt oder ein Stromausfall die Arbeit seit dem letzten Speichern zunichte macht.

In diesem Zusammenhang empfiehlt sich die Verwendung der unter Toolsi-UmgebungsoptioneniPrferenzen angebotenen "Optionen fr Autospeichern":

Umgebung1opltonen

"'""""""I e-1 P-1 c .a.-o .... I a...E~ I ~en Fomdor-Do-r.~ocnft~ Pa-.._ r, 8~- P l>{j)FIMtot-on r H-~~orns ... p.;~.., r ~-1"-r Ve>N_.t ..... daP-- P o._-H,_.........., p HIUo~ P NyF ......... e ... T."

Pr.....u .... - ...."..,

.....,..,. ... p o.._ ... l,oobol-"'" r: e .... ~,."..,s,..,.. G....-.-0--ll- 1

X

B

Markiert man hier "Editordateien", werden vor jedem Start des Programms alle zum Projekt gehrenden Dateien gespeichert. Markiert man auerdem noch die Option "Projekt-Desktop", werden beim nchsten Start des C++Builders wieder alle die Dateien geffnet, die beim letzten Beenden geffnet waren.

1.5 Einige Tipps zur Arbeit mit Projekten 15

Auerdem wird empfohlen, unter ToolsiEditor-OptioneniEditor die Option "Rckgngig nach Speichern" zu markieren. Dann kann man Textnderungen auch dann noch mit Alt+Rcktaste rckgngig machen, nachdem die Datei ge-speichert wurde.

Der C++Builder erzeugt fr jedes Projekt einige Dateien, die recht gro werden knnen, und die fr eine sptere Weiterarbeit am Projekt nicht bentigt werden. Da diese Dateien automatisch aus den Quelltexten der Units und aus den Formu-laren erzeugt werden, kann man sie lschen. In der Version 5 sind das die Da-teien, deren Name aus dem Projektnamen und den Endungen

".tds" und ".obj"

besteht, und in Version 1 auerdem die Dateien mit den Namensendungen ".il?".

1.5 Einige Tipps zur Arbeit mit Projekten

Anfnger finden sich in der Vielzahl der Funktionen zur Projektverwaltung manchmal nicht ganz zurecht. Deshalb sind hier einige Tipps zusammengestellt, die vor allem fr die Projekte hilfreich sein knnen, die bei der Lsung der Auf-gaben anfallen.

- Zumindest am Anfang ist es meist am einfachsten, wenn fr jede Aufgabe mit DateiiNeue Anwendung ein neues Projekt angelegt wird.

Wenn man dagegen zur Lsung einerneuen Aufgabe dem aktuellen Projekt nur mit DateiiNeues Formular ein Formular hinzufgt, wird dieses Formular beim Start des Programms nicht automatisch angezeigt. Das hat dann die ver-zweifelte Frage zur Folge, wo denn das soeben geschriebene Programm bleibt.

- Wenn man die Arbeit an einem Projekt abschliet, besteht keine Notwendig-keit, die Fenster mit den Formularen und Quelltextdateien extra zu schlieen. Lsst man sie offen, werden sie beim nchsten ffnen des Projekts automa-tisch geffnet.

Schliet man sie dagegen, werden sie nicht geffnet. Mancher Anfnger hat dann schon gemeint, dass seine Dateien verschwunden wren.

- Markiert man unter Toolsl Umgebungsoptionen I Prferenzen bei den "Optio-nen fr Autospeichern" die Option "Desktop", wird beim nchsten Start des C++Builders automatisch das Projekt geffnet, das beim letzten Beenden des C++Builders geffnet war. Man kann dann sofort an diesem Projekt weiter-arbeiten, ohne dass man es extra ffnen muss.


Zum ffnen eines lteren Projekts werden vor allem die Optionen Neu ffnen und Projekt ffnen aus dem Men Datei empfohlen. Unter Neu ffnen werden in der oberen Hlfte des Untermens die zuletzt geffneten Projekte ange-zeigt. Eines dieser Projekte kann man durch einfachesAnklicken ffnen. Mit Projekt ffnen kann man auf den Laufwerken nach einem Projekt suchen.

- Mit Dareilffnen kann man sowohl Projekte als auch andere Dateien ffnen. Da in der Voreinstellung viele verschiedene Dateitypen angezeigt werden und die Bedeutung der Symbole fr Projekte und andere Dateitypen oft nicht be-kannt ist, werden sie von Anfngern gelegentlich verwechselt.

In der Voreinstellung von DareilProjekt ffnen werden dagegen nur Projekt-dateien angezeigt, so dass diese Gefahr hier nicht besteht. Deshalb wird em-pfohlen, Projekte nicht mit Dareilffnen zu ffnen.

1.6 Die Online-Hilfe

Da sich kaum jemand die Bedeutung der vielen Einzelheiten in Zusammenhang mit dem C++Builder merken kann, ist es fr eine effektive Arbeit unerlsslich, die Mglichkeiten der Online-Hilfe zu kennen und nutzen zu knnen.

Unter HilfeiC++Builder-Hilfe (in der Menleiste) erhlt man eine nach Themen geordnete bersicht. Durch Anklicken der Buchsymbole kann man die verschie-denen Bcher aufschlagen und wieder zuklappen.

r~.l&Qin

CON~~.wd-"'"' 11:1

1.7 Das lokale Men

- r:


Im Quelltexteditor erhlt man:

S Umtl cpp .. (il EJ

#1ncludl!'

1.9 Programmierhilfen 19

Die Symbolleiste kann leicht ber die Option Anpassen des lokalen Mens (ber die rechte Maustaste) verndert werden. Dabei kann jedes Menelement eines Untermens der Menzeile in die Symbolleiste aufgenommen werden. Falls die Breite der Symbolleiste fr die neuen Symbole nicht ausreicht, kann sie durch Ziehen am rechten Rand verlngert werden.

1.9 Programmierhilfen

Der Editor des C++Builders enthlt zahlreiche Programmierhilfen, die das Schreiben von Programmen erleichtern sollen. Diese zeigen z.B. Informationen ber Sprachelemente an und schlagen Argumente fr Funktionsaufrufe vor Mit Quelltextvorlagen kann man auf einfache Weise oft verwendete Texte einfgen.

Mit der Taste Strg+l im Editor werden Quelltextvorlagen angezeigt:

I Umtl cpp ~~~~

Unll~ II-- -----------------------------------------------------::!J vo:1d _f.atoaJ.J. Tr orft'tl :: BuetonlC.lick (TObject ._Sender)

Aus dieser Liste kann man mit den Pfeiltasten und der Enter-Taste bzw. mit einem Doppelklick eine der Vorlage auswhlen und in den Editor einfgen.

Wenn der Cursor am Ende einer Zeichenfolge steht, die mit dem Anfang einer der Abkrzungen am rechten Rand der Liste bereinstimmt, werden nach Strg+l nur diese Vorlagen angeboten:

I Umtl cpp ~~~~

Urit~ II---- --------------------------------------------------~il void _ :tastca.l1 Tforml: : ButtonlC liek ( TObj~ct Sr!:nd~r)

}

l!l

nwei.Uf"IQ db

;re -------------------------~ 1 [ome KlatM>eee


1.10 Packages und eigenstndig ausfhrbare Programme

Viele Programme, die mit dem C++Builder entwickelt werden, verwenden ge-meinsame Komponenten und Funktionen. Beispielsweise verwenden die meisten Programme Komponenten der Komponentenpalette. Wenn man den Code fr alle Komponenten und Funktionen in jede Exe-Datei aufnimmt, wird die relativ gro. Deswegen fasst man hufig benutzte Komponenten oder Funktionen oft in Bib-liotheken (meist so genannte DLLs) zusammen. Diese Bibliotheken mssen dann beim Start der Exe-Datei verfgbar sein.

Der C++Builder verwendet fr solche Bibliotheken so genannte Packages. Das sind im Wesentlichen DLLs mit dem Programmcode fr eine Gruppe von Kom-ponenten und Funktionen. Wenn unter ProjektiOptioneniPackages die Option "Mit Laufzeit-Packages compilieren" markiert ist, verwendet das vom C++Buil-der erzeugte Programm die angegebenen Packages.

Pro1ektophonen Ei

C++ Pascal Linker

FornUe I Anwendu-lg I Compilel ~ ... -".ft Verzeichnisse/Bedngungen J VerS!OnSfio .~~~~

~Emwufu~~~~------~----~--------------~

~ -- .: : I II ~ Borland C++ InterBaseAlerter Component

~~ Borland C++ Sampie Components ~ Borland C++Builder COM Server Components Sampie Package ~ Borland C++Bwlder Internet Explorer 5 Components Package ~ Borland Datenbankkomponenten .:J .. c:\cbuider5depr\cbuider5\Bin\dcb:le50.bpl

: r H~ugen ... I II Ent!emen 1 II .eearbeiten I ,!;omponenten

JvcL50;VCLX50;bcbsmp50;QRPT50;VCLDB50;VCLBDE50;i HilzlilW\-..

DK J::!ife

In der Voreinstellung ist diese Option nicht markiert. Ein einfaches Programm mit einem Button ist dann ca. 200 KB gro, whrend es mit Packages nur etwa 20 KB gro ist.

Wenn man ein Programm auf einem anderen Rechner ausfhren will, ist es oft einfacher, dieses ohne die Verwendung von Packages zu erzeugen. Dann reicht zum Start des Programms die Exe-Datei aus und man braucht die teilweise rela-

1.10 Packages und eigenstndig ausfhrbare Programme 21

tiv groen DLLs nicht (z.B. 2 MB fr die immer bentigte VCL50.BPL). Falls man mehrere Programme auf dem anderen Rechner installiert, kann es aber auch einfacher sein, die Packages zu installieren. Da bei der Installation des C++Buil-ders automatisch alle Packages in das System-Verzeichnis von Windows kopiert werden, sind diese auf einem Rechner mit dem C++Builder ohne zustzlichen Aufwand verfgbar.

Ein mit dem C++Builder erzeugtes Programm bentigt zum Start auerdem die beiden DLLs

CP3240MT.DLL BorlandMM.DLL

falls unter ProjektiOptioneniLinker die Option ,,Dynamische RTL verwenden" wie in der Voreinstellung markiert ist. Wenn diese Option nicht markiert ist, sind diese DLLs nicht notwendig und die Exe-Dateien werden etwas grer.

Fassen wir zusammen:

- Wenn man ein Programm nur auf dem Rechner ausfhren will, auf dem man es entwickelt, kann man Speicherplatz und Zeit beim Kompilieren sparen, wenn man Packages verwendet. Das drfte fr die meisten bungsaufgaben, die spter gestellt werden, am besten sein.

- Wenn man ein Programm dagegen auf einem Rechner ausfhren will, auf dem der C++Builder nicht installiert ist, muss man entweder alle notwendi-gen Bibliotheken zur Verfgung stellen und dabei darauf achten, dass man keine vergisst. Oder man bersetzt das Programm

1. ohne Laufzeit-Packages, indem man unter ProjektiOptioneniPackages die Option "Mit Laufzeit-Packages compilieren" nicht markiert, und

2. ohne dynamische Laufzeitbibliothek, indem man unter ProjektiOptio-neniLinker die Option "Dynamische RTL verwenden" nicht markiert.

2 Die Komponentenpalette

Dieses Kapitel gibt einen berblick ber die wichtigsten Komponenten der Kom-ponentenpalette. Die meisten entsprechen Dialogelementen, mit denen ein Pro-gramm dem Anwender Informationen anzeigt oder Informationen von ihm entge-gennimmt. Andere (wie z.B. ein Timer) sind whrend der Ausfhrung des Pro-gramms nicht sichtbar.

Die Komponentenpalette enthlt ber 100 Komponenten mit den meisten der heute unter Windows blichen Dialogelementen. Angesichts der groen Anzahl von Eigenschaften, Methoden und Ereignissen, die fr jede Komponente zur Ver-fgung stehen, ist keine vollstndige Darstellung beabsichtigt: Die Hilfedateien im Verzeichnis "Help" des C++Builders sind mehrere MB gro. Auerdem wer-den keine Komponenten behandelt, die tiefere Vorkenntnisse erfordern (Daten-banken, Internet usw.). Hier werden vor allem die Komponenten und Elemente vorgestellt, die man in den meisten Windows-Programmen findet und die eine in-tuitive Bedienung eines Programms ermglichen.

In Zusammenhang mit den Komponenten werden auch einige Grundkonzepte der Programmierung angesprochen, wie z.B. Datentypen, Anweisungen, Funktionen und Klassen. Diese werden spter ausfhrlich dargestellt.

2.1 Die Online-Hilfe zu den Komponenten

Da in diesem Kapitel nicht alle Komponenten ausfhrlich behandelt werden kn-nen, soll zuerst gezeigt werden, wie man mit der Online-Hilfe weitere Informa-tionen zu den einzelnen Komponenten bekommen kann. Dafr gibt es im We-sentlichen die folgenden Mglichkeiten:

24 2 Die Komponentenpalette

1. Falls man den Namen des gesuchten Begriffs kennt:

Unter Hilfeilnhalt nach Index oder Suchen den Suchbegriff eingeben. Im Editor den Cursor auf den Suchbegriff setzen und dann Fl drcken.

2. Die unter 1. beschriebenen Mglichkeiten fhren allerdings nicht immer zum Ziel, da es zu einem Suchbegriff oft mehrere hnliche Begriffe gibt, so dass man nicht wei, welchen man auswhlen soll. Und dass man zur Komponente Edit ber den Suchbegriff TEdit kommt, ist fr einen Anfnger nicht unbe-dingt naheliegend. Die folgenden Vorgehensweisen sind oft einfacher:

Informationen zu einer Eigenschaft oder zu einem Ereignis erhlt man, indem man sie im Objektinspektor an klickt und dann die Taste F 1 drckt. Fr die Eigenschaft Height erhlt man so:

TControl : :Holght """"" - -014! E.gtntthaft Htrght gib~ dtt HOht dtt Sltutrtlttntntt tn Pt:t:tl n roJei'\.J' t.nt HelQ'bt f nll r K.l'Q'bt, wl'ttc!-:tH.c-ight,

node..fAuJ.t l;

Oetehrtlbung Mit Herght kennen Sre d1e H6he du Steuere tments a.bnden odtr tndtrn

Informationen zu einer Komponente erhlt man, indem man sie in der Komponentenpalette anklickt und dann die Taste F 1 drckt.

lEIM J..191 .. d11 ttnultgtfl E!ngtbN!df( 'tllll'l 'MndGwl.

Unh

= Bnctlrtl'-ung Mit ...,.,... TEcfiiOb,tkt hnnlfl S11 tiMt dtt unttr Wind"""" Uibkhtlll'l Sur.dar!J-E.ngltltllidff '" .." FC!m'llbr 111f0ttn E"'tlbtt.ldtr .,._, du\1, 'WQII'I 8erH.Cztm ttngtgtbtnotn ltl:l zu llri'Utiltl Aulltfdtm kann,.... Mt~~~ Tt .. J b Mn S.nt.uer ~~~plttgl...,....n.

Wtnn S.. Tt~ ltdlijbch ..,Zfotitn ~. hal d .. a..Mz .. bflo tlnttl'l E111"ab4Hid dlt Ml)fk:hlo trt , dtl'l Tful :u ~und 1r1 dlt .Z,..".,c;htl\l~ ZU 1.~ Wtn~ 'lhnt 8urtllht111"1QtmOQIICP'IkNII'I r.t:hr: biMI!:Ifl ~. WI'Mf'I~Mfl s.."' L.IWCitllf!.t TEcill ~Ptll dn ~VIIIriulltoniiOfll TC!A1omE611 0.. tOu .. Mklantrt'rl ... dM'WOI'I TCut:tomEdtl ~lfbctn E'iliftldtabn. ~. ~ J4doch htll !lt'VIt' Vtdd.lltn II\ F1.11 lpu..-. E.ng1MftldM konnen S. ~ 1110n TCtmomEIM .. h9tlt1t111 IOnllll'l ""~ orJtr ltllt:llfll'tkht abltlltn.

Stren Sie sich nicht daran, dass die Edit-Komponente hier als TEdit bezeichnet wird: Im C++Builder beginnen die Namen der Datentypen fast aller Komponen-ten mit dem Buchstaben "T", und eine Komponente der Komponentenpalette ist im C++Builder ein Datentyp.

Klickt man in diesem Fenster auf Eigenschaften, werden alle Eigenschaften der Edit-Komponente angezeigt, zu denen man sich dann weiter durchklicken kann:

2.1 Die Online-Hilfe zu den Komponenten

Hier sind diejenigen Eigenschaften, die auch im Objektinspektor angezeigt werden, mit einem kleinen grnen Quadrat gekennzeichnet. Alle Eigenschaften ohne ein solches Quadrat sind nur whrend der Laufzeit des Programms verfgbar.

In dieser Darstellung sieht man bereits ein Cha-rakteristikum der objektorientierten Programmie-rung: Unter den Eigenschaften, die zu der ausge-whlten Klasse gehren, gibt es solche, die nur zu dieser Klasse gehren (hier keine Einzige). In den Abschnitten mit der berschrift "Abgeleitet von" findet man dagegen Klassenelemente, die aus Vorgngern bernommen werden. Diese abgelei-teten Elemente gehren aber ebenso zu einer Klasse wie diejenigen, die nur zu dieser Klasse gehren.

Die Eigenschaften einer Klasse werden vor allem zusammen mit einer Zuweisung (Operator "=") verwendet wie z.B. in

Editl->Text = "Hallo"~

Klickt man im Hilfefenster "Komponente TEdit" auf Methoden, erhlt man eine Liste der zu TEdit gehrenden Methoden. Auch hier sind die Metho-den, die nur zu TEdit gehren, im Abschnitt "In TEdit" zusammengefasst und alle weiteren in Ab-schnitten mit der berschrift "Abgeleitet von".

Methoden sind Funktionen, die zu einer Kompo-nente gehren . Sie unterscheiden sich von den Ei-genschaften unter anderem dadurch, dass sie auf-gerufen werden . Dazu gibt man nach dem Namen der Methode ein Paar runde Klammern an und dazwischen eventuell noch weitere Argumente:

Editl->Clear()~

Methoden, die denselben Namen wie die Klasse haben (hier TEdit und - TEdit), sind so genannte Konstruktoren und Destruktoren und haben eine besondere Bedeutung.

m Borland c .. Bu1ldcr - Httfe l!!l[i] Eigenschaften von TEdlt

0~

D~

~ D~ a HtdeSelecf!on

D~

M2ll!fwl o OEMCorwert a PassWl)rdChlr

0 Bea.d.Qn1x

~ ~ ~

Abgeleitet von TWinControl lmtl .. ~ ~ Contro!Count

Methoden von TEdlt

Abgele itet von TCustomEdit Qu[ ClearSelectron

CopyToC!ipboard

CutToChpboard

DefaultHandler

GetSeiietByf PasteFromChpboard

SetSe!Te

26 2 Die Komponentenpalette

Wenn man jetzt den Verweis auf Clear anklickt, erhlt man eme inhaltliche Beschreibung dieser Funktion:

,, X o-t- ,.,... .. _1 HO- l""" 0 ......

TCustomEdit::Ciear _!'!

2.2 Namen

Wenn man schlielich im Hilfefenster zu "Kom-ponente TEdit" den Verweis auf Ereignisse an-klickt, erhlt man eine Zusammenstellung der fr die Edit-Komponente verfgbaren Ereignisse. Offensichtlich kann auch ein Edit-Fenster auf Ereignisse reagieren und nicht nur ein Button.

Allerdings wird man auf das Anklicken eines Edit-Fensters normalerweise nicht reagieren. Der Anwendereines Windows-Programms wird meist nicht erwarten, dass das Anklicken eines Edit-Fensters irgendeine Aktion des Programms aus-lst.

27

;l Borland C++Burlder Hrlle fii[O)Ei Ereignisse von TEdlt

Abgeleitet von TCustomEdit

"~ Abgeleitet von TWinControl

" QnEnill

" OnVeyDQ'W!l o OnkeyPre5s

"~ Abgeleitet von TControl

"~ o OnConte>tPopyp

"~ c OnDr>gOroo

c OnOragOver

c OnEndOock

c~ c OnMou5eDowo c OnMou$&MO"!!l c On Mo use:Up

c OnStaaoocb c OnStartProg

Offensichtlich enthlt die Online-Hilfe eine Flle

Documents

[Xpert.press] C++ mit dem Borland C++Builder ||