Einführung in den C++ Builder

Einführung in den Borland C++ Builder

Die Entwicklungsumgebung

Wir starten aus dem Programmordner Borland C++ Builder den C++Builder.

Wir erhalten dann folgende Entwicklungsoberfläche:

In der Komponentenpalette befinden sich Windows-Steuererlemente, wie Schalflächen, Radiobuttons, Edit-Fenster usw., die wir auf das Formular (Form1) ziehen könnnen.

Im Objektinspektor können für die in einem Formular verwendete Objekte (Steuerelemente) Eigenschaften (wie z.B. Objektname, Überschrift, Schriftart usw.) eingestellt werden.

Ferner werden im Objektinspektor die verfügbaren Ereignisse eines Steuererlementes angezeigt. Z. B. für eine Schaltfläche button1 gibt es die Ereignisse OnClick, DragDrop usw..

Mit dem Startknopf starten wir später das Programm.

Erstes Beispiel: Ereignisorientierte Programmierung mit Textausgabe

Das erste Beispielprojekt speichern wir, bevor wir eine Zeile C++-Code geschrieben haben.

Beim Speichern ist zu beachten, dass einerseits eine Projektdatei und andererseits eine Unitdatei (mit der Endung *.cpp) gespeichert wird. Die Namen dieser beiden Dateien dürfen nicht identisch sein.

Wir gehen im Menü Datei auf Projekt speichern unter...

Dann gehen wir in das persönlichen loaklen Arbeitsverzeichnis (z.B. in c:\maier\ ). Dort speichern wir die Unit-Datei unter dem Namen bsp1_u.cpp. Im darauf erscheinenden Fenster wird die Projekt-Datei mit dem Namen bsp1_p.mak gespeichert. Es genügt auch, jeweils die Dateinamen ohne Extentions einzugeben.Es ist sinnvoll, aber nicht zwingend, die Projektdatei durch ein _p bzw. die Unit-Datei durch ein _u kenntlich zu machen, die Dateien dürfen ja nicht den selben Namen besitzen, wie es in Visual-Basic möglich ist.

Die Titelleiste der Form soll von form1 in Erstes Windowsprogramm umbenannt werden. Dazu aktivieren wir im Objektinspektor das Register Eigenschaften und tragen unter Caption Erstes Windowsprogramm ein.

Nun ziehen aus der Komponentenpalette ein Bezeichnungsfeld (Label) sowie drei Schaltfächen (Button) auf die Form. Dies erfolgt durch Anklicken der jeweiligen Steuerelemente.

Im Objektinspektor ändern wir die Caption-Eigenschaft (Überschrift) von Button1 in Gruss. Mit den beiden anderen Button verfahren wir ebenso.

Für das Label1 stellten wir im Objektinspektor die Schriftgröße über die Font-Eigenschaften auf 12 Grad ein.

Die Größe der Form wird reduziert, in dem man diese einmal anklickt und mit der Maus die rechte untere Ecke anfährt und dann bei gedrückter Maustaste die Form staucht.

Falls bei unseren Aktionen ein Editor-Feld für den Quellcode sich öffnet, ignorieren wir dieses und verkleinern dieses durch Anklicken des entsprechenden Window-Buttons <_>auf Symbolgröße. Es darf keineswegs mit <X>geschlossen werden, sonst verabschiedet sich unser Projekt!

Wir speichern die soeben erstellte Form durch anklicken des Speicher-Button mit dem Diskettensymbol.

Wir starten das Programm mit dem Startknopf. Wir sehen, daß einige hundert Programmzeilen compiliert werden, obwohl wir noch keine Programmzeile geschrieben haben. Der Compilierungsvorgang kann im Einzelfall etwa eine halbe Minute dauern.

Nachdem die Übersetzung abgeschlossen ist, könnnen wir die Schaltflächen Gruss, Clear oder Quit betätigen, ohne das unser Programm sich regt.

Wir stoppen das Programm durch betätigen der Stop-Schaltfläche:

Wir müssen nun unsere Befehsschaltfächen mit C++-Code füllen. Dazu klicken wir das Button1 mit der Bezeichnung Gruss zweimal an.
Anschließend erhalten wir das zugehörige Code-Fenster:

In diesem Fenster tragen wir den eigenen C-Code ein. Keinesfalls dürfen wir der Namen der Funktion ändern.

Falls wir den Funktionsnamen dennoch ändern wollen, müssen wir dies im Eigenschaftsfenster des Objektinspektors für das Button1-Objekt erledigen. Dort gibt es auch ein Feld für die Namen-Eigenschaft.

Dem Funktionsnamen entnehmen wir, daß es sich dabei um eine Methode handelt, die auf ein Objekt der Klasse Tform1 angewendet wird.

Die Methode Button1Click wird immer dann aufgerufen, wenn die Schaltfläche Button1 mit der Mausangeklickt wird. Es handelt sich hierbei um eine Funktion die durch ein OnClick-Ereignis ausgelöst wird.

Der Funktionsparameter TObject *Sender enthält einen Zeiger auf ein Objekt (TObjekt) . Dieser Zeiger zeigt auf das Objekt, wo das Ereignis ausgelöst wurde.

Der C++-Builder legt Objekte dynamisch während der Programmlaufzeit an, deshalb müssen wir mit Pointer auf Objekte arbeiten!

Wir wollen erreichen, dass am Label1 ein Gruß erscheint, wenn die Methode Button1Click(TObjekt *Sender) augeführt wird. D.h. während der Programmlaufzeit muß der Label1-Caption-Eigenschaft der String "Hallo Welt !" zugewiesen werden.

Das geht mit dieser Programmzeile, die wir im Funktionsrumpf einfügen, hierbei ist strikt auf Groß- bzw. Kleinschreibung zu achten:

Label1 -> Caption = "Hallo Welt";

Zur Deutung dieser Zeile:

Label1 ist der Objektname. Falls wir den Namen eines Objekts nicht kennen, reicht es, dieses Steuerelement einmal mit der Maus anzuklicken, und schon erscheint sein Name im Titel des Objektinspektors.

Caption ( = Überschrift ) ist die Eigenschaft bzw. die Elementen Variable zu diesem Objekt.

Verfügbare Eigenschaften und mögliche Ereighnisse einer Klasse können wir dem Objektinspektor entnehmen:

Normalerweise müßten wir annehmen, der Objektname würde von Name der Eigenschaftsvariable mit einem Punkt getrennt, wie wir es auch von den Strukturen oder vielleicht von VisualBasic her kennen.

Tatsächlich haben wir es mit einem Pointer auf ein Objekt zu tun. Die ausführliche Schreibweise für eine Zuweisung sieht in C++ so aus: (*Label1).Caption = "Hallo....";

Wir erinnern uns an Pointer auf Strukturen bzw. auf Objekte, wo auch folgende Kurzschreibweise möglich ist: Label1 -> Caption =....

Die Caption-Eigenschaft hat übrigens den Datentyp String, den wir bisher noch nicht in C++ kennengelernt haben. Bei diesem Datentyp handelt es sich genauer gesagt um ein String-Objekt.

Unsere Funktion sollte so aussehen:

//----------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
Label1->Caption = "Hallo Welt";
}

//------------------------------------------------------

Um das Programm zu testen, aktivieren wir den Menübefehl Projekt -> Projekt neu compilieren.

Nachdem die 78718 Programmzeilen compiliert worden sind, betätigen wir die Startschalfläche.
Nun fehlen nur noch die Funktionen zum Löschen un zum Verlassen des Programms.

Wir stoppen die Programmausführung und klicken mit der Maus die zweite Schaltfläche ein. Dort weisen wir der Label1-Caption-Variable einen leeren String durch zwei Gänsefüßchen zu.

Als Befehl zum Beenden des Programms tragen wir in der dritten Schaltfläche Close( ) ein.

Da wir nur im C-Code der Unit etwas geändert haben, reicht es, die Unit zu compilieren mit dem Menübefehl Projekt->Unit Compilieren.

Wir schließen das Projekt mit dem Menübefehl Datei -> alle schließen und Beenden den Builder mit Datei -> Beenden.

Mit dem Windows-Explorer betrachten wir den Inhalt unseres CBuilder-Arbeitsverzeicnisses:

es dürften einige 10MB sein. Wir führen die exe-Datei bsp1.exe aus, das Programm sollte gestartet werden. Diese exe-Dateien sind auf alle win32-Rechner ausführbar und benötigen keine Zusatzmodule, wie etwa das vbrun32.dll-Modul für Visual-Basic-Programme.

Bevor wir zum nächsten Projekt schreiten, räumen wir mit unserer Batchdatei clean.bat das Verzeichnis auf.

Zweites Programmbeispiel: Berechung Ausgabe von Zahlen

Wir starten den Builder neu und legen die unten abgebildete Form an. Falls der Builder noch läuft, schließen wir zuvor alle Dateien und aktivieren den Menübefehl Datei -> Neue Anwendung.

Das neue Projekt speichern wir unter bsp_2.u.cpp und bsp2_p.cpp im lokalen Arbeitsverzeichnis c:\maier\. Diesmal verwenden wir zur Abwechselung das Edit-Steuerelement. Im Objektinspektor tragen wir zum Edit1-Objekt als Text-Eigenschaft 0 ein.

Wir deklarieren eine Zählvariable global als Integer. Dazu klicken wir auf ein Steuerelement unserer Form und scrollen den Quellcode der Unit zum Programmkopf. Unterhalb der Compiler-Direktiven nehmen wir die Deklaration vor:

#pragma hdrstop
#include "bsp2_u.h"
//-------------------------------------------
#pragma resource "*.dfm"

int zaehler = 0; // Globale Deklaration

TForm1 *Form1;

In der ersten Befehlsschalftfläche schreiben wir den Code zum hochzählen. Da die Text-Eigenschaft des Edit1-Objekts vom Typ String ist, ist eine Typ-Umwandlung der Integer-Variable zaehler mit Hilfe der Funktion AnsiString(zahl)erforderlich. Die vollständige Befehlszeile zur Zahlenausgabe lautet:

Edit1->Text = AnsiString(zaehler);

Der Rest läuft analog zu unserem ersten Programmbeispiel.

Übung 1:
Ergänzen Sie das Programm um eine weitere Schaltfläche zum herunterzählen, wobei der Wert 0 nicht unterschritten werden darf.

Übung 2:
Die Zählrichtung soll über zwei Radio-Buttons eingestellt werden. Die Objekte haben die Namen RadioButton1 und RadioButton2. Der Zustand, ob ein Button aktiviert ist, ist in der Eigenschaftsvariablen Checked enthalten, es sind die beiden Werte true oder false möglich.

Legen Sie im Objektinspektor für das RadioButton1 die Caption-Eigenschaft Aufwärts und die Checked-Eigenschaft mit true fest.

In der Zähl-Schaltfläche erfolgt die Verzweigung mit if-Anweisungen wie if (RadioButton1->Checked)....

Drittes Programmbeispiel: Berechnung mit Zahleneingabe über ein Edit-Steuerelement

Wir wollen ein Programm zur Berechnung des Sinuswertes von einem Winkel schreiben.

Dazu erstellen wir die neben abgebildete Form.

Alternativ zur Mausbedienung lassen sich die Schaltfächen Berechne und Quit später in der Programmausführung durch Betätigen der Tasten <Alt> <B> bzw. >Alt><Q> ansteuern.

Wir erhalten den Unterstrich unter dem B bzw. unter dem Q, in dem wir bei der Eingabe der Caption-Eigenschaft im Objektinspektor ein & der Bezeichnung voranstellen. Wir tragen dort also &Berechne bzw. &Quit ein.

Unter der Schaltfläche Berechne tragen wir unseren C-Code ein.

Als erstes muß der Inhalt vom Edit1-Fenster einer Zahlenvariable zugewiesen werden. Weil die Text-Eigenschaftsvariable ein String-Objekt ist, müssen wir eine Konvertierungsmethode auf dieses Objekt anwenden.

Die Methode ToDouble( ) liefert den Double-Wertvon einem String-Objekt. Für ganze Zahlen gibt es die Funktion ToInt( ).Im C-Builder sind Int-Zahlen übrigens 32 bit groß!

Unter der Deklaration des Winkels als lokale double Variable in der Schaltfläche Button1 tragen wir folgende Programmzeile ein:

winkel = Edit1->Text.ToDouble();

Zur Erinnerung: Der -> Operator ist erforderlich, weil das Edit1-Objekt ein Pointer ist. Zwischen der Objekteigenschaft Text und der Umwandlungsmethode ToDouble() steht hingegen ein Punkt, da Text wiederum ein Objekt der Klasse String ist, wobei es sich in diesem Fall nicht um einen Zeiger handelt. Wir haben es hier mit verschachtelten Objekten zu tun.

Wir schreiben noch die restlichen Programmzeilen für die Ereignisroutine TForm1::Button1Click() hin:

sinus = sin(winkel * M_PI / 180.);
Edit2->Text = AnsiString(sinus);

Wenn wir nun das Programm starten, erhalten wir für sin() und M_PI Fehlermeldungen. Wir müssen also noch die Include-Datei math.h irgendwo im Programm einbauen.

Wir öffnen zu diesem Zweck wieder das Code-Fenster (beispielsweise durch Anklicken der Form oder eines Steuerelements) und scrollen den Bildschirm nach oben.

Oberhalb der vorhandenen #include-Anweisungen tragen wir unsere Include-Anweisung ein:

# include <math.h>

Jetzt sollte die Berechnung einigermaßen funktionieren. Vervollständigen Sie Ihr Programm und testen es aus.

Übung: Notenberechung

Schreiben Sie ein Programm zur Notenberechnung. Nach der Eingabe der Maximalpunktzahl und der erreichten Punkten in zwei Edit-Felder soll an einem weiteren Edit-Fenster die Note ausgegeben werden.