C++ - Fachbereich Maschinenbau - FH

Fachhochschule Stralsund
Fachbereich Maschinenbau
Prof. Dr.-Ing. Ch. Wahmkow
Arbeitsblätter zur Vorlesung
C++
Diese Arbeitsblätter stellen eine sehr kurze Übersicht der in der Lehrveranstaltung
behandelten C++- Elemente dar.
Gliederung
1.
Die Oberfläche des Embarcadero C++ Builder ..................................................... 2
1.1
Anlegen eines neuen C++-Projektes ................................................................ 2
1.2
Die Entwicklungsoberfläche IDE ....................................................................... 3
1.3
Die Struktur eines C++ Projektes im Embarcadero C++ Builder .............. 4
1.4
Ereignisse, Methoden, Aktionen und Eigenschaften .................................. 5
2.
Grundlagen der Programmiersprache C++ ............................................................ 6
2.1
Fundamentale skalare Datentypen .................................................................. 6
2.2
Variablendeklaration ............................................................................................ 7
2.3
Funktionen für die Eingabe und Ausgabe ...................................................... 8
2.4
Zeichenkettenfunktionen..................................................................................... 8
2.5
Felder (Arrays) und StringGrids ....................................................................... 9
2.6
Externe Dateien .................................................................................................... 10
3.
Funktionen, Prozeduren, Eigenschaften und Methoden .................................. 12
3.1
Funktion oder Prozedur? .................................................................................. 12
3.2
wichtige Anweisungen....................................................................................... 12
4.
Nützliches ...................................................................................................................... 13
4.1
Tastencodes abfragen ....................................................................................... 13
4.2
OpenDialog, SaveDialog, PrintDialog ............................................................ 14
4.3
Try ... catch ............................................................................................................ 15
Literatur:
Kaiser, Richard
C++ mit dem Borland C++ Builder
Springer Verlag 2002
ISBN 3-540-62994-7
Schumann, Hans-Georg
C++ leicht & verständlich
Verlag: Knowware 1. Auflage 2005
ISBN 87-91364-56-6
1
1. Die Oberfläche des Embarcadero C++ Builder
1.1 Anlegen eines neuen C++-Projektes
Zur Entwicklung eines jeden C++ - Programmes erstellt der Embarcadero C++
Builder ein Projekt. Zu einem Projekt gehören mehrere Dateien. Zu Ihrer eigenen
Übersicht sollten Sie jedes neue C++-Programm in einem neuen Verzeichnis
ablegen.
Erstellen Sie vor dem Start des C++- Builders ein neues Verzeichnis mittels Windows
Explorer. (z.B. test)
Öffnen Sie danach den Embarcadero C++ Builder!
Da wir Windows-Anwendungen programmieren wollen, wählen Sie:
Menü Datei Neu…
VCL Formularanwendung C++ Builder
VCL ist die Abkürzung für Visual Component Library, einem Satz visueller und
nicht visueller Komponenten für die beschleunigte Erstellung von WindowsAnwendungen.
Diese Komponenten stehen uns in der Tool-Palette zur Verfügung.
Speichern Sie danach alles erst einmal ab! (Sie werden gleich sehen, wie viel
Dateien schon entstanden sind):
Menü Datei alles speichern…..
Wählen Sie als Speicherort jetzt das neue Verzeichnis (test)!
Zuerst wird der C++-Quelltext (cpp) abgelegt. Geben Sie hier einen logischen
Namen, der Ihrer Anwendung entspricht. (z.B. test)
Danach wird die Projektdatei (cbproj) abgelegt. Geben Sie hier auch einen logischen
Namen beginnend mit „P“ für Projekt (z.B. ptest).
Starten Sie jetzt Ihr Programm:
Entweder Menü Start oder
2
Sehen Sie sich anschließend in Ihrem Verzeichnis um. Sie werden staunen, wie viel
schon drin ist:
Die exe- ist das eigentliche Ziel unserer Arbeit. Die können Sie jetzt autark
verwenden, ohne die übrigen Dateien zu nutzen. Alles andere ist „lediglich“ für die
Entwicklung mittels C++ Builder erforderlich.
1.2 Die Entwicklungsoberfläche IDE
In dieser Ansicht sind wichtige Bestandteile des C++ Builders dargestellt.
Symbolleiste
Default Layout
Struktur,
alle
Objekte
des
Formulars
Formular als
Windowsoberfläche, sichtbar
in der Designansicht
Objektinspektor
Toolpalette
Registerleiste
Aufpassen, dass nicht zu viele Fenster aktiv sind, man verliert sonst schnell den
Überblick. Stellen Sie das Default Layout ein! Die Projektverwaltung können Sie
schließen.
In der Registerleiste kann man zum C++-Quelltext wechseln (test.cpp), und man
befindet sich im Quelltexteditor.
Auf das Formular werden alle sichtbaren und unsichtbaren Objekte (Komponenten)
aus der Toolpalette platziert. Auf einem Windowsformular können nur Texte ein- bzw.
ausgegeben werden.
3
Die Toolpalette bietet eine Unmenge von Komponenten an, die nach Kategorien
geordnet sind.
Mittels Objektinspektor können Sie sehr viele wesentliche Eigenschaften von
Objekten einstellen. Probieren Sie hier viel selbst aus!
In der Struktur sehen Sie alle Ihre auf dem Formular platzierten Objekte. Das ist
wichtig für deren Schreibweise. Sie sehen diese aber nur in der Designansicht.
Wechseln Sie in der Registerleiste durch Auswahl des cpp- Registers zum
Quelltexteditor:
Hier hinterlegen Sie all Ihre geistigen Ergüsse! Das ist das Fenster zum
Programmieren.
1.3 Die Struktur eines C++ Projektes im Embarcadero C++ Builder
Projektdatei
.cbproj
- Aufruf durch den C++-Builder
- beinhaltet den Aufruf sämtlicher
Bestandteile
Hauptprogramm des Projektes .cpp
- Quelltext
Formular1
Quelltext
des
Formulars
.cpp unit
Formularbeschreibung .dfm
Header
des Form.
.h
Ressourcen
des Projektes
.res
Ausführbare
Datei
.exe
Compiliertes
Hauptprogramm
.obj
Formular2
.
.
.
…
Symboldatei
für den
Debugger
.tds
Compilierte
Formulare
.obj
4
In der Projektverwaltung sieht man diese
Einteilung ähnlich als Baumstruktur:
In der Headerdatei (.h) eines Formulars werden die notwendigen Bibliotheken
eingebunden (z. B. #include <Controls.hpp>)und das Formular als neue Klasse mit
sämtlichen Eigenschaften eines Windowsfensters an das Hauptprogramm gebunden.
Hier kann man zusätzliche Bibliotheken einbinden.
Wird im Formular eine neue Komponente aus der Toolpalette aufgezogen, wird diese
hier aufgenommen.
Ereignisse werden hier ebenfalls deklariert. (automatisch)
Achtung!
Will man ein Ereignis löschen, so muss man es an dieser Stelle tun!
Die unit beinhaltet den Quelltext eines Formulars (.cpp) und ist die eigentliche
Datei, die für uns als Programmierer wichtig ist.
Borland hat schon wichtige Komponenten eingefügt:
- die VCL.h – die visuelle Komponentenpalette
- die Headerdatei unseres Formulars (.h)
- die Formularbeschreibung (.dfm)
- einen Zeiger auf die Klasse Formular (*Form1;) und dessen
Konstructor
Von uns werden jetzt sämtliche Ereignisse hier beschrieben (implementiert).
Der C++Builder gibt die Überschrift vor. Alles andere ist unsere Sache!!
1.4 Ereignisse, Methoden, Aktionen und Eigenschaften
Windows arbeitet ereignisorientiert. Es wartet also ständig, dass irgend etwas
passiert. Mausklicks, Buttonklicks, Tastatureingaben usw. Das sind Ereignisse.
Was passiert bei einem Ereignis? Das ist in den Methoden beschrieben
(programmiert). Der Ausdruck Methode kommt aus der objektorientierten
Programmierung.
Eine Methode ist also die programmierte Aktion auf ein Ereignis.
Über die Embarcadero C++-Oberfläche lassen sich die Ereignisse (nur
Standardereignisse) einfach in den Quelltexteditor hinein klicken. Das sieht dann
ungefähr so aus:
void __fastcall TForm1::Button1Click(TObject *Sender)
{
….hier steht die Action
}
void ist der Typ der Methode.
___fastcall kommt vom c++-Builder und ist eine Anweisung an den Compiler
5
TForm1 ist der Name des Objektes, auf dem ein Button platziert ist, der ein Ereignis
auslöst.
Button1Click ist der Name des Ereignisses.
Der doppelte Doppelpunkt verknüpft Klasse und Methode.
Werden vordefinierten Objekten Eigenschaften oder Methoden zugewiesen,
wird in C++ die Pfeilnnotation verwendet:
Edit1->SetFocus;
Label1->Caption=“Hallo“;
Man kann einigen Eigenschaften wieder Eigenschaften zuweisen:
Label1->Font->Name="Arial";
Label1->Font->Color=clRed;
Label1->Font->Size=14;
Label1->Font->Height=34;
Memo1->Lines->Add(“Eine neue Zeile”);
Label1->Font->Style=TFontStyles()<<fsBold;
Bei selbst definierten Objekten ist das Trennzeichen zwischen Objekt und Methode
bzw. Eigenschaft der Punkt.
Zusammenfassung
Trennzeichen zwischen
Objekt und Methode
::
->
Anwendung
verknüpft Klasse und
Methode
verknüpft Objekt und
Methode (eine Anweisung wird
Beispiel
TForm1::Button1Click
Edit1->Text
Timer1->Enabled
gegeben)
.
Verknüpft Objekte und
Methoden ohne Zeiger
String s
int i=s.Length();
2.
Grundlagen der Programmiersprache C++
In diesem Abschnitt sollen wesentliche Teile der Programmiersprache beschrieben
werden, die für die Lehrveranstaltung wichtig sind.
Ich weise darauf hin, dass wir hier nur einen kleinen Bruchteil der Mächtigkeit der
Sprache behandeln können. In den Lehrveranstaltungen können lediglich
Anregungen gegeben werden.
Probieren Sie selbst viel aus und testen Neues!
C++ unterscheidet streng zwischen Groß- und Kleinschreibung!!!!
2.1
Fundamentale skalare Datentypen
Jede Variable muss vereinbart werden. Die Stelle der Vereinbarung ist egal, auf
jeden Fall vor dem ersten Aufruf.
6
Am besten, Sie gewöhnen sich an, alle Variablen am Anfang eines Formulars oder
einer Prozedur zu vereinbaren.
Bei der Variablenvereinbarung werden einer Variablen der Speicherplatz in
entsprechender Größe und der Name zugewiesen.
Die Größe des Speicherplatzes hängt vom Datentyp der Variablen ab.
Jedem Datentyp kann man einen bestimmten Wertebereich zuordnen.
Folgende grundlegende skalare Datentypen gibt es (Auszug):
Datentyp
int
Größe
[Byte]
4
unsigned int
bool
char
unsigned char
short
4
1
1
1
2
unsigned short
long
2
4
long long
8
unsigned long
float
double
Extended
wchar_t
4
4
8
10
2
AnsiString
string
1-n Byte
0 - n-1 Byte
Andere Namen
signed,
signed int
unsigned
signed char
none
short int,
signed short int
unsigned short int
long int,
signed long int
unsigned long int
none
none
__wchar_t
Wertebereich
–2,147,483,648 to 2,147,483,647
0 bis 65535
false or true
–128 bis 127
0 bis 255
–32768 bis 32767
0 bis 65535
–2 147 483 648 bis 2 147 483 647
–9 223 372 036 854 775 808 bis
9 223 372 036 854 775 807
0 bis 4 294 967 295
3.4E +/- 38 (7 digits)
1.7E +/- 308 (15 digits)
-3,6 x 10^4951 .. 1,1 x 10^4932
0 bis 65 535
Bis zu 2 GB groß; wird nach Bedarf
reserviert
Bis zu 2 GB groß; wird nach Bedarf
reserviert
2.2
Variablendeklaration
Allgemeine Form: Datentyp Variablenname;
z.B.
int i; // hier werden 4 Byte Speicherplatz für eine ganze Zahl reserviert.
float x,y; //hier werden für die beiden reellen Zahlen x und y je 4 Byte reserviert.
AnsiString zk; //hier wird ein leerer String zur Verfügung gestellt
Man kann während der Deklaration auch gleich die Variable initialisieren, d.h. einen
Wert zuweisen.
int i=0;
7
float x=1,y;
AnsiString zk=”C++”;
lokale und globale Variable:
Lokale Variable gelten nur in den Prozeduren, wo sie deklariert sind.
Globale Variable gelten für das gesamte Formular.
Wird eine Variable in mehreren Prozeduren verwendet, so muss sie global vereinbart
werden.
Globale Variablen werden beim Deklarieren gleich mit initialisiert, lokale nicht!
Zeichenketten werden immer als leere Zeichenketten angelegt und damit initialisiert.
private oder public:
Alle Elemente, die unter privat deklariert wurden, sind nur in dieser Klasse gültig und
verwendbar. Elemente, die im gesamten Projekt verwendet werden sollen, sind als
public zu vereinbaren. Die Vereinbarung erfolgt in der Headerdatei.
2.3
Funktionen für die Eingabe und Ausgabe
Eine Eingabe ist in einem Windowsprogramm das Auslesen eines
Windowssteuerelementes und die Wertzuweisung auf eine Variable.
Die Ausgabe ist in einem Windowsprogramm die Umwandlung des Wertes einer
Variablen in eine Zeichenkette und deren Ausgabe auf ein
Windowssteuerelement.
Funktionen zur Eingabe:
StrToInt - k=StrToInt(Edit1->Text);
StrToFloat a=StrToFloat(Edit1->Text);
TryStrToInt -Versuch der Wertzuweisung; Fehler ist abfangbar!!
z.B.:
int a;
bool s;
s=TryStrToInt(Edit1->Text,a);
if (s)
{
Label1->Caption=IntToStr(a+1);
}
else
{
Label1->Caption="Fehler";
}
Funktionen zur Ausgabe:
IntToStr - Edit1->Text=IntToStr(i);
FloatToStr - Edit2->Text=FloatToStr(a); //Gibt 8 bzw.15 Stellen Genauigkeit aus
FormatFloat - Edit3->Text=FormatFloat(“0.00”,b);//gibt das reelle b mit 2 Stellen Genauigkeit aus
FloatToStrF Edit4->Text=FloatToStrF(b,ffNumber,8,2); // --“--, insgesamt 8 Stellen
2.4
Zeichenkettenfunktionen
Strings oder strings sind Klassen, d.h. man kann davon Objekte (Instanzen)
definieren, denen man Eigenschaften und Methoden zuweisen kann.
Bei den fundamentalen Datentypen (z.B. int oder float) kann man das nicht.
Vereinbarung:
AnsiString zk;
8
Zeichenkettenfunktion
MidStr(zk,Pos.,Anzahl)
SubString(Pos.,Anzahl) (substr)
Delete(Pos.,Anzahl) (erase)
Insert(neuezk,Pos.)
Pos(tzk) (find)
Length(zk)
Funktion, Prozedur oder
Methode
Funktion
Methode (Proz.)
Methode (Proz.)
Methode (Proz.)
Methode (Funktion)
Methode (Funktion)
Beispiel
tzk=MidStr(zk,i,1);
zk.SubString(2,3);
zk.Delete(3,2);
zk.Insert(„abc“,2);
i=zk.Pos(„ab“);
int n=zk.Length();
Man kann auch den Datentyp string verwenden.
Dann werden die Funktionsnamen einfach klein geschrieben bzw. es gelten die in
Klammern klein gedruckten Funktionsnamen.
Variable vom Typ AnsiString kann man nicht einfach auf Variablen vom Typ
string zuweisen.
z.B.
string s;
AnsiString a;
s=a; //Führt zum Fehler;
a=s; //Führt auch zum Fehler
So kann man eine Stringart in die andere überführen:
s=a.c_str() // s erhält den Wert von a
a=s.c_str() // a erhält den Wert von s
Achtung!!
Zeichenkettenfunktionen sind in der Unit StrUtils vereinbart. Diese muss man als
Includedatei in der Headerdatei hinzufügen:
#include <StrUtils.hpp>
2.5
Felder (Arrays) und StringGrids
Felder sind strukturierte Datentypen. Man unterscheidet sie von den fundamentalen,
skalaren Datentypen.
Ein Feld ist eine Zusammenfassung von Elementen desselben Datentyps unter
einem einzigen Namen.
Deklaration von Feldern:
Allgemein:
Datentyp Feldname[Anzahl der FE];
Das 1. Feldelement hat den Index 0, das letzte den Index Anzahl-1.
z.B.
int a[10]; // Dieses Feld a hat 10 Feldelemente von a[0] bis a[9]
int max=100;
float b[max];
9
double d[20];
String name[3];
int x[2]={0}; // x[0]=0=x[1]=0 zum Initialisieren eines Feldes
int z[10] [20]; ein 2-dimensionales Feld mit 10 Spalten und 20 Zeilen
Bei der Definition eines Feldes muss darauf geachtet werden, dass seine Grenze in
den zulässigen Speichergrenzen liegt.
Für lokale Definitionen liegt die Obergrenze bei 1 MB. Unter Projekt/Optionen/Linker
kann man diese Voreinstellung ändern.
Für global definierte Felder liegt die Obergrenze bei 2 GB.
Wird die Obergrenze überschritten, führt das zu einem Laufzeitfehler. Der Compiler
gibt nicht unbedingt eine Fehlermeldung oder Warnung aus.
Verarbeitung von Feldern:
Ein Feld wird immer über die einzelnen Elemente des Feldes angesprochen.
Ein Feldelement besteht aus dem Namen des Feldes und dem Index.
Der Index kann für ein Feldelement verschieden gewählt werden.
So kann innerhalb eines Programms ein Element a[i] gleich a[j] sein.
Der Index kann auch ein Ausdruck sein: z.B. a[i+1]
Die Eingabe und Ausgabe von Feldern passiert meist über die Komponente
StringGrid.
Ein StringGrid ist ein vordefiniertes Windowssteuerelement. Es hat die Form einer
Tabelle und ist damit ein 2-dimensionales Feld.
Die einzelnen Zellen können über deren Spalten – und Zeilenindex angesprochen
werden. Bei beiden Indizes beginnt die Zählung bei 0.
Eine Zelle wird definiert über: StringGrid1->Cells[Spalte][Zeile]
StringGrid1->Cells[0][0]
Da Stringgrids oft für die Ein- oder Ausgabe von Feldern
genutzt werden, spricht man die einzelnen Feldelemente
iterativ an.
z.B.: Eingabe: Hier wird die erste Spalte des
Stringgrids auf Feld a gelesen!
z.B.: Ausgabe: Hier wird in die 0. Zeile
der aktuelle Wert von i ausgegeben.
int a[10];
for (int i=1; i<=5;i++ )
{
a[i]=StrToInt(StringGrid1->Cells[1][i]);
}
for (int i=0;i<=3 ;i++ )
{
StringGrid1->Cells[i][0]=IntToStr(i);
}
2.6
Externe Dateien
Man unterscheidet zwischen Textdateien und formatierten Dateien.
10
In Textdateien steht zeilenweise nur Text drin. Diese Dateien sind auch nur
zeilenweise zu lesen. Zu vergleichen sind diese Dateien mit tatsächlichen Texten.
(siehe Word)
Eine Textdatei kann sehr einfach in ein Memofenster gelesen werden oder von da
geschrieben werden.
Memo1->Lines->LoadFromFile("text.txt"); //Lesen und Ausgabe ins Memofenster
Memo1->Lines->SaveToFile("text.txt"); // Schreiben des Inhalts vom Memofenster in Datei
Nichts weiter muss vereinbart werden. Eine zu lesende Datei muss im Verzeichnis
Debug_Build stehen, eine neue Datei wird da angelegt.
Bei formatierten Dateien ist die Struktur der einzelnen Datensätze bekannt. In der
Regel ist es ein Tabellenaufbau.
In einer Zeile können also verschiedene Daten unterschiedlichster Typen stehen.
Beispiel einer formatierten Datei:
Formatierte Dateien werden
auch als Stream bezeichnet.
Für deren Verarbeitung muss
man die Include-Datei
#include <fstream>
in die Quelle einfügen.
Deklaration:
Die Datei wird als Stream vereinbart und bekommt einen Namen ( hier f):
fstream f;
Öffnen der Datei zum Lesen
f.open(Filename,ios::in);
z.B.: f.open(OpenDialog1->FileName.c_str(),ios::in);
Öffnen der Datei zum Schreiben:
f.open(Filename,ios::out);
Einlesen der Datensätze:
f>>a[i]>>b[i]>>c[i]>>d[i]; //aus einer Zeile werden 4 Parameter gelesen
Schreiben der Datensätze auf Datei:
f<<a[i]<<b[i]<<c[i]<<d[i]; // 4 Parameter warden als eine Zeile in die Datei geschrieben
Schließen der Datei:
f.close();
11
3.
3.1
Funktionen, Prozeduren, Eigenschaften und Methoden
Funktion oder Prozedur?
In C++ sind eigentlich alle Unterprogramme Funktionen. Man unterscheidet aber
nach so genannten void- Funktionen und Funktionen mit Rückgabewert.
In der contextbasierten Hilfe findet man auch den Unterschied. Hier ist void oder der
Datentyp der Funktion ausgewiesen.
Eine void-Funktion wird wie eine Prozedur verwendet. Man fügt deren Namen
einfach in den eigenen Qelltext ein, führt eine eventuelle Parameterliste mit und ist
fertig.
z.B. Edit1->SetFocus();
also:
void Name()
{
Anweisungen
}
Funktionen mit Rückgabewert sind immer in einem Ausdruck zu verwenden. Hier
muss man darauf achten, welchen Datentyp der Rückgabewert hat.
Entweder ist ein Wert zuzuweisen (Label1->Visible=true;)
oder die Funktion ist einer Variablen zuzuweisen (int i=zk.Length();)
also:
Datentyp Name()
{
Anweisungen
Return Ergebnis
}
3.2
wichtige Anweisungen
- Edit- Fenster, Labels, Buttons, StringGrid…
Edit1->Clear(); //Löscht ein Editfenster
Edit1->SetFocus(); //Setzt den Fokus
Label1->Visible=false;
//Label wird unsichtbar
Button1->Enabled=false // Button nicht verfügbar aber sichtbar!
Timer1->Enabled=true; //Timer beginnt zu „laufen“
Label1->Caption=“Hallo“;
StringGrid1->Cells[1][2]=IntToStr(a); // Ausgabe
A=StrToInt(StringGrid1->Cells[1][2]; // Eingabe
Man kann einigen Eigenschaften wieder Eigenschaften zuweisen:
Label1->Font->Name="Arial";
12
Label1->Font->Color=clRed;
Label1->Font->Size=14;
Label1->Font->Height=34;
Memo1->Lines->Add(“Eine neue Zeile”);
Label1->Font->Style=TFontStyles()<<fsBold;
- Meldungsfenster
ShowMessage(„Fehlerhafte Eingabe!“);
- Zeit- und Datumsfunktionen
jetzt, heute,zeit vom Typ TDateTime
jetzt=Now(); //Das aktuelle Datum und Uhrzeit wird auf die Variable jetzt gelesen
heute=Date(); //aktuelles Datum wird auf heute zugewiesen
zeit=Time(); // aktuelle Zeit wird auf zeit zugewiesen
DecodeDate(jetzt,jahr, monat,tag);
DecodeTime(jetzt,stunde,minute,sekunde,msek);
- Zufallszahlen
Randomize(); //generiert den Zufallszahlengenerator
float z=Random(); // zufällige Zahl z zwischen 0 und 1
int a=Random(Grenze) zufällige ganze Zahl a; 0<=a< Grenze
- Abbruch
Close(); //schließt das aktuelle Fenster
Abort(); // verlässt die aktuellle Prozedur
exit(0);
// schließt die aktuelle Anwendung
break; // verlässt die aktuelle Struktur
- neues Fenster zeigen
2. Formular anlegen, dann deren Headerdatei im Quelltext des 1. Formulars
einbinden:
#include "Unit2.h" // entweder manuell oder über Menü Datei | unit verwenden…
an beliebiger Stelle:
Form2->Show();
4.
4.1
Nützliches
Tastencodes abfragen
Man kann nicht darstellbare Zeichen abfragen, z.B. die Enter-Taste oder ESC oder
die F-Tasten.
Man verwendet dazu die dezimale Verschlüsselung des Zeichens nach dem ASCIICode.
13
Meist wird eine Tast im Ereignis Keypressed abgefragt:
void __fastcall TForm1::Edit1KeyPress(TObject *Sender, char &Key)
{
if(Key==13)Button1->Click();//hier wird die Enter-Taste abgefragt und das Click-Ereignis für den
Button aufgerufen
}
if (Key=='a') Button1->SetFocus();
//hier wird die a-Taste abgefragt
Beachte die Hochkommas, da char!
if (Key==97) Button1->SetFocus();
//hier wird die a-Taste abgefragt
if (Key==8) Key = 8;
//backspace aktiviert
einige Tastencodes:
Enter
ESC
Del
Tab
Backspace
13
27
127
9
8
4.2 OpenDialog, SaveDialog, PrintDialog
Mit diesen Komponenten kann man die üblichen Fenster zum Öffnen, Speichern oder
Drucken einer Datei aufrufen.
void __fastcall TForm1::Button1Click(TObject *Sender)
{
String Dateiname;
if (OpenDialog1->Execute()==true) Dateiname=OpenDialog1->FileName;
}
if (OpenDialog1->Execute()) f.open(OpenDialog1->FileName.c_str(),ios::in);
void __fastcall TForm1::Button1Click(TObject *Sender)
{
String Dateiname;
if (SaveDialog1->Execute()==true) Dateiname=SaveDialog1->FileName;
}
void __fastcall TForm1::Button1Click(TObject *Sender)
{
if (PrintDialog1->Execute()==true) Form1->Print(); //Das Formular wird ausgedruckt, nicht der
Quelltext!!!
}
14
4.3 Try ... catch
Mit dem try….catch-Block kann man sehr elegant Laufzeitfehler abfangen.
Das heißt, versucht man irgendetwas in einem Programm umzusetzen (try) und es
klappt, ist alles in Ordnung.
Kommt es aber zu einem Laufzeitfehler, so kann man den abfangen (catch).
Achtung!
Sind Sie sich dessen bewusst, dass Sie dann die Fehlerkontrolle selbst in die
Hand nehmen. Normalerweise macht das das Betriebssystem.
Folgende Voreinstellung ist
dazu wichtig:
Menü: Tools| Optionen…|
Debugger-Optionen|
Sprachexceptions
Deaktivieren von: Bei
Sprach- Exceptions
benachrichtigen
Syntax:
try
Anweisungsblock
catch (...)
Anweisungsblock
z.B.
void __fastcall TForm1::Button1Click(TObject *Sender)
{
try
{
int k=StrToInt(Edit1->Text);
Label1->Caption=IntToStr(k+1);
}
catch(...)
{ShowMessage("Fehler!");}
}
15