Sie sind auf Seite 1von 49

B

Boorrllaanndd D
Deellpphhii

Programmieren

mit OBJECT PASCAL

in der Entwicklungsumgebung

DELPHI

Grundkurs Informatik – Staatliches Herder-Gymnasium Nordhausen

1/49
www.pdfmailer.de
B
Boorrllaanndd D
Deellpphhii

Inhaltsverzeichnis

Seite

Was ist Delphi? 3

Einordnung von Delphi 4

Benutzeroberfläche 6

Elementare Datentypen 9

Typumwandlungen 11

Operatoren und Operationen 12

Arithmetik 16

Programmstruktur 17

Anweisungen 18

Grundlegende Syntax 21

Delphi-Zeichensatz 24

Reservierte Wörter 25

Fehlerarten 27

Algorithmus-Begriff 29

Top-Down-Prinzip 30

Schleifen 31

Bedingte Anweisungen 33

Rekursion 35

Arrays 37

Records 39

OOP –Ein erster Zugang 40

Komponenteneigenschaften 42

Grafikausgabe 46

2/49
BBoorrllaanndd D
Deellpphhii

Der Name Delphi

Der Name Delphi hat seinen Ursprung in der starken Datenbankorientierung der
Entwicklungsumgebung. Oracle ist sowohl der Name eines Datenbanksystems als auch das englische
Wort für Orakel. Als bekanntestes Orakel gilt das Orakel von Delphi.

Was ist Delphi?

Delphi ist der Name einer von der Firma Borland entwickelten Entwicklungsumgebung zum Erstellen
von Programmen unter Windows, die ursprünglich aus der von Nikolaus Wirth erstellten
Programmiersprache Pascal hervorgegangen ist.

Delphi basiert auf der Programmiersprache Object Pascal. Borland benannte Object Pascal jedoch
2003 in Delphi-Language um, mit der Begründung, dass sich bereits so viel in der Sprache verändert
habe, dass man es nicht mehr mit Pascal vergleichen könne. So wurden, zum Beispiel, viele originäre
Konstrukte, wie sie von Niklaus Wirth für Pascal als Programmiersprache zu Schulungszwecken
erdacht worden sind (wie eine absolut strenge Typisierung) durch die aus der Praxis resultierende
Erfordernisse aufgeweicht.

Delphi beinhaltet einen leistungsfähigen Pascal-Compiler, einen speziellen syntaxempfindlichen Editor


und viele visuelle Komponenten die standardmäßig mitgeliefert werden.

Mit Delphi kann jede(r) einfach und schnell Windowsprogramme entwickeln, falls er/sie
ein wenig Hintergrundwissen besitzt.

Der Vorteil von Windowsprogrammen liegt in ihrer mausgestützten Bedienung, deren Basiselemente
(Menüs, Knöpfe, Dropdownleisten, etc) stark standardisiert und damit leicht bedienbar sind.
Windowsprogramme werden in Fenstern ("Windows") ausgeführt, die oft nur einen Teil des gesamten
Bildschirmes beanspruchen.

3/49
BBoorrllaanndd D
Deellpphhii

Einordnung von Delphi

Da Delphi mehr ist als eine Programmiersprache, lässt sich Delphi auch nicht exakt einordnen. Die
Basissprache (Pascal) zählt man zu den Sprachen der 3. Generation, andere Teile von Delphi (z.B.
Object-Pascal, die visuellen Komponenten, oder die SQL-Anbindung) zählen zur 4. Generation

1. Generation: Maschinensprachen

Unter Maschinensprache versteht man die Bitkombinationen, die von der CPU (central processing unit
= Mikroprozessor) als Befehle verstanden und ausgeführt werden. Die ersten Computer Ende der
1940er Jahre konnten nur in Maschinensprache programmiert werden. In Maschinensprache wird
heute nicht mehr programmiert, da es für jeden CPU-Typ zumindest einen Assembler (siehe unten)
gibt. Grundsätzlich ist jedes Programm, das direkt in Maschinensprache geschrieben wird extrem teuer
(weil zeitaufwändig) und extrem schlecht zu warten.

Beispiel: 11001011
00110101
11100011
10111101

2. Generation: Assemblersprachen

Um die für den Menschen ziemlich schwierige Maschinensprache leichter zugänglich zu machen, hat
man schon sehr früh die so genannte Assemblersprache eingeführt. Dabei handelt es sich um eine 1:1
Entsprechung von sog. Mnemonics zu den Bits der Maschinensprache. Die Mnemonics können vom
Menschen wesentlich leichter erlernt werden, zu mal Adressbezüge gesondert ausgewiesen werden.
Für die Übersetzung der Assemblersprache in die Maschinensprache ist der so genannte Assembler
zuständig (den Vorgang nennt man "assemblieren").
Wichtig ist, dass die Assemblersprache immer exakt auf die jeweilige CPU zugeschnitten ist. Wenn
man also eine Assemblersprache (zum Beispiel für die 68000er CPU-Familie) beherrscht, kann man
keinesfalls Assembler für eine andere CPU-Familien (z.B. Intel Pentium). Um Assembler überhaupt
sinnvoll einsetzen zu können, benötigt man sehr detaillierte Kenntnisse des jeweiligen
Mikroprozessors. Der Vorteil von Assemblersprachen liegt in der maximal möglichen Geschwindigkeit
des erzeugten Codes. Daher wird Assembler auch nur an sehr zeitkritischen Stellen eingesetzt.

Beispiel: Das folgende Beispiel zeigt einen Ausschnitt aus einem Assemblerprogramm für
die Pentium-Familie:
PUSHFD
POP EAX
MOV EDX, EAX
XOR EAX, CPUIDID_BIT
PUSH EAX
POPFD
PUSHFD
POP EAX
XOR EAX, EDX
JZ @exit
MOV AL, TRUE

4/49
BBoorrllaanndd D
Deellpphhii

3. Generation: Hochsprachen

Hochsprachen zeichnen sich dadurch aus, dass die Programmiersprache unabhängig vom
verwendeten Computer ist. Das Programm wird entweder vor der Ausführung (Compiler) oder
während der Ausführung (Interpreter) in die Maschinensprache übersetzt. Manchmal - bei ganz alten
Sprachen, wie Basic, und bei ganz neuen Ansätzen, wie .NET (sprich "dotnet") - wird nicht direkt in
die Maschinensprache sondern in eine maschinenunabhängige Zwischensprache übersetzt.

Prozedurale Ansätze

Prozedurale Ansätze stellen den Algorithmus, also die Abarbeitung des Programms nach bestimmten
von der Aufgabe erzeugten Vorgaben. Zu den prozeduralen Sprachen gehören Basic, Fortran, C,
Pascal, und viele andere.

Beispiel: Readln(kilometer);
Readln(liter);
verbrauch := 100*liter/kilometer;
if verbrauch > 7.0 then
writeln "Verbrauch zu hoch!";

Objektorientierte Ansätze

Bei objektorientierten Ansätzen steht nicht der Algorithmus, sondern ein Datenobjekt im Mittelpunkt.
Dieses Datenobjekt besitzt einerseits entsprechende Felder zur Speicherung der Daten und
andererseits sog. Methoden zur Bearbeitung der Daten. Die Algorithmen (der Methoden) werden also
zum Teil eines Objekts.
Objektorientierte Ansätze haben viele Vorteile, da von Vorneherein bestimmte Fehler vermieden
werden. Die enge Verbindung zwischen Daten und Algorithmen entspricht außerdem mehr der
Realität. Zu den objektorientierten Sprachen gehören Object-Pascal (Delphi), Java, C++ oder
Smalltalk.

Deklarative Ansätze

Deklarative Ansätze werden manchmal auch als Sprachen zur künstlichen Intelligenz bezeichnet (was
aber stark irreführend ist). Solche Sprachen, wie z.B. Lisp, Prolog, oder DataLog verfolgen jeweils
eigene Ansätze, die ganz spezielle Merkmale aufweisen. So ist Lisp auf die Bearbeitung von Listen
spezialisiert und erlaubt selbst-modifizierenden Code. Prolog dient zur Auflösung logischer Ausdrücke,
und Datalog dient als Programmiersprache für relationale Datenbanken.

5/49
BBoorrllaanndd D
Deellpphhii

Die Benutzeroberfläche von Delphi – Ein kurzer Überblick über die IDE (Integrated
Development Environment)

Nach dem Start von Delphi findet man etliche, scheinbar nicht zusammengehörige Fenster vor.
Welche Fenster tatsächlich angezeigt werden, hängt vom Zustand beim Verlassen von Delphi ab.

Die Konsole

Symbolleisten: Delphi bietet mehrere verschiebbare Leisten auf denen sich verschiedene Funktionen
wie Speichern, Öffnen, Erstellen neuer Formulare, einem Button zum Erstellen (=Kompilierung) der
EXE-Datei (das grüne Dreieck), dazu einige Debugging-Funktionen befinden.

Menüleiste: Sie bietet sämtlichen verfügbaren Kommandos (außer die der Kontextmenüs)

Komponentenpalette: Auf ihr befinden sich in mehrere Seiten unterteilt alle in Delphi installierten
Komponenten. Hier kann man auch eigene Komponenten oder solche von Drittanbietern installieren.

6/49
BBoorrllaanndd D
Deellpphhii

Der Object Instpector

Im Object Inspector lassen sich Eigenschaften


(Properties) von Komponenten zur Entwurfszeit
sehr einfach ändern.

Man wählt einfach die Komponente aus. Ihre


Eigenschaften werden nun im Objektinspektor
angezeigt. Man kann sie nun, wie man es von
Windows gewohnt ist, ganz intuitiv mit wenigen
Klicks und Tastatureingaben ändern. Bei älteren
Delphiversionen sind die Properties alphabetisch
geordnet, bei den neueren kann man die
Properties gruppieren.

Der Object Inspector zeigt immer zwei Spalten an,


links den Namen der jeweiligen Eigenschaft,
rechts den zugehörigen Wert. Einfache Werte wie
Zahlen oder Texte können direkt eingegeben
werden; kompliziertere Eigenschaften, wie z.B. der
Zeichensatz (property Font) werden entweder
über ein aufklappbares Untermenü (kleines
Pluszeichen links neben dem Namen) oder durch
einen so genannten Property-Editor geändert.

Der Property Editor ist spezifisch für eine


bestimmte Eigenschaft und kann durch Klicken
des kleinen Knopfes rechts neben dem Inhalt der
jeweiligen Property aufgerufen werden. Fehlt ein
solcher Knopf, so gibt es keinen passenden
Property-Editor für die ausgewählte Eigenschaft.

Der Quelltexteditor

Um tatsächlich
programmieren zu können,
benötigt man einen Editor
mit dem man die
Programmzeilen schreiben
kann.

Grundsätzlich könnte man


jeden beliebigen Editor
verwenden, allerdings ist
der eingebaute Delphi-
Editor so gut und perfekt
zum Programmieren
geeignet, dass kaum
jemand auf die Idee kommt
einen externen Editor zu
verwenden.
Der Editor lässt sich in fast
allen Bereichen einstellen.
Man kann den Editor sowohl in Farbe, Form, Schrift, und Tastaturbelegung anpassen (Befehl
"Tools/Editor Options"). Der Editor bietet auch die syntaxgesteuerte Einfärbung des Codes an (Syntax-
Highlighting). Im linken Teil des Editors sieht man den sogenannten Codeexplorer, der einem weitere
Informationen zum gerade bearbeiteten Programmteil geben kann.

7/49
BBoorrllaanndd D
Deellpphhii

Das Formular

Da Delphi eine visuelle Entwicklungsumgebung ist, ist eine der wichtigsten Eigenschaften solcher
Umgebungen, dass man das Benutzerinterface interaktiv und graphisch entwickelt. Die übliche
Vorgangsweise ist dabei so, dass man aus der Komponentenpalette einzelne Komponenten (z.B.
Knöpfe) auswählt und auf einem anfangs leeren Formular passend platziert. Das Ganze passiert mit
Drag&Drop, Die Elemente kann man später ebenso auch mit der Maus verschieben oder die Ausmaße
ändern.
Grundsätzlich ist ein Formular immer mit einer Cope-Einheit ("unit" genannt) verknüpft. Also: jedes
Formular hat genau eine zugehörige Unit. Aber: eine Unit muss kein passendes Formular besitzen - es
gibt auch nicht-visuelle Units (Libraries).

Das Message-Fenster

Ein unscheinbares, aber wichtiges Fenster ist das Message-Fenster. In diesem Fenster zeigt die IDE
diverse Fehlermeldungen, Warnungen und Hinweise an. Am besten dockt man das Message-Fenster
an den Editor (am unteren Ende) an. Klickt man auf eine Meldung im Messagefenster, so zeigt die IDE
den zugehörigen Source-Code an, der die Ursache für die Meldung war.

8/49
BBoorrllaanndd D
Deellpphhii

Elementare Datentypen

Name Größe Wertebereich Beschreibung


ByteBool /
1 Byte true oder false boolescher Wert
Boolean
WordBool 2 Byte true oder false boolescher Wert
LongBool 4 Byte true oder false boolescher Wert
Byte 1 Byte 0 bis 255 vorzeichenlose 8 bit-Ganzzahl
Word 2 Byte 0 bis 65535 vorzeichenlose 16 bit-Ganzzahl
Cardinal 4 Byte 0 bis 4.294.967.295 vorzeichenlose 32 bit-Ganzzahl
ShortInt 1 Byte -128 bis 127 vorzeichenbehaftete 8 bit-Ganzzahl
SmallInt 2 Byte -32.768 bis 32.767 vorzeichenbehaftete 16 bit-Ganzzahl
31 31
LongInt 4 Byte -2 bis 2 -1 vorzeichenbehaftete 32 bit-Ganzzahl
63 63
Int64 8 Byte -2 bis 2 -1 vorzeichenbehaftete 64 bit-Ganzzahl
Real48 6 Byte 2,9x10-39 bis 1,7x1038 48 bit-Gleitkommazahl
32 bit-Gleitkommazahl (IEEE 754-
Single 4 Byte 1,5x10-45 bis 3,4x1038
float)
64 bit-Gleitkommazahl (IEEE 754-
Double 8 Byte 5,0x10-324 bis 1,7x10308
double)
Extended 10 Byte 3,6x10-4951 bis 1,1x104932 80 bit-Gleitkommazahl
vorzeichenbehaftete 64 bit-Ganzzahl,
Comp 8 Byte -263 bis 263-1
mit der über die FPU gerechnet wird
-922.337.203.685.477,5808 bis vorzeichenbehaftete 64 bit-
Currency 8 Byte
922.337.203.685.477,5807 Festkommazahl
8 bit-Zeichen, z. B. ASCII-/ANSI-
Char 1 Byte #0 bis #255
Zeichen
WideChar 2 Byte #0 bis #65535 16 bit-Zeichen, z. B. Unicode-Zeichen
bis 256
ShortString Aneinanderreihung von bis zu 255 Chars
Byte
bis 2
AnsiString Aneinanderreihung von bis zu 231 Chars
GByte
bis 2
WideString Aneinanderreihung von bis zu 230 WideChars
GByte

Der Datentyp Real entspricht in Delphi standardmäßig dem Double. Zur Rückwärtskompatibilität kann
man ihm mit dem Compilerschalter {$REALCOMPATIBILITY ON} dem Real48 gleichsetzen.

Der Datentyp Integer hängt von der jeweiligen Pascal-Implementation ab. In 16-Bit-Implementationen
(z. B. Turbo Pascal) entsprach er einem SmallInt, in 32bit-Implementationen einem LongInt und in
64-Bit-Implementationen wird er einem Int64 entsprechen.

Der Datentyp String entspricht standardmäßig einem AnsiString. Mit {$LONGSTRINGS OFF} entspricht
er zur Rückwärtskompatibilität einem ShortString.

9/49
BBoorrllaanndd D
Deellpphhii

Reservierte Symbole

and array as asm begin case class const constructor destructor dispinterface div do downto else end
except exports file finalization finally for function goto if implementation in inherited initialization inline
interface is label library mod nil not object of or out packed procedure program property raise record
repeat resourcestring set shl shr string then threadvar to try type unit until uses var while with xor

Direktiven

Direktiven sind Symbole die nur in bestimmten Kontexten reserviert sind, sonst aber als Namen für
Variablen, Funktionen, usw. benutzt werden können.

absolute abstract assembler at automated cdecl default deprecated dispip dynamic export far
implements index library near nodefault on overload override pascal platform private protected public
automated published read register reintroduce safecall stdcall stored virtual write

10/49
www.pdfmailer.de
B
Boorrllaanndd D
Deellpphhii

Typumwandlung

Im Gegensatz zu einigen anderen Sprachen ist Delphi bei Typen sehr streng. Es ist also nicht möglich,
einer Integer-Variable eine Gleitkommazahl-Variable zuzuweisen. Dafür steht eine große Auswahl an
Konvertierungsfunktionen zur Verfügung:

von nach Funktion Beispiel


Integer Real kein Problem, einfache var zahl1: integer;
Zuweisung zahl2: real;
begin
zahl2 := zahl1;
Real Integer Möglichkeiten: var zahl1: real;
- Nachkommastellen zahl2: integer;
abschneiden (trunc) begin
- kaufm. Runden (round) zahl2 := trunc(zahl1);
- aufrunden (ceil, Unit Math) zahl2 := round(zahl1);
- abrunden (floor, Unit Math)
Integer String IntToStr var textzahl: string;
zahl: integer;
begin
textzahl := IntToStr(zahl);
Real String FloatToStr var textzahl: string;
FloatToStrF zahl: real;
begin
textzahl := FloatToStr(zahl);
String Integer StrToInt var textzahl: string;
StrToIntDef zahl: Integer;
begin
zahl := StrToInt(textzahl);
String Real StrToFloat var textzahl: string;
zahl: real;
begin
zahl := StrToFloat(textzahl);
String Char Zugriff über Index var text: string;
(1 ist erstes Zeichen) zeichen: char;
begin
zeichen := text[1];
Char String kein Problem, einfache var zeichen: char;
Zuweisung text: string;
begin
text := zeichen;

11/49
1
www.pdfmailer.de
B
Boorrllaanndd D
Deellpphhii

Operatoren

Operatoren verhalten sich wie vordefinierte Funktionen, die Bestandteil der Sprache Delphi sind. So
setzt sich beispielsweise der Ausdruck (X + Y) aus den Variablen X und Y (den so genannten
Operanden) und dem Operator + zusammen. Wenn X und Y den Typ Integer oder Real haben, liefert
der Ausdruck (X + Y) die Summe der beiden Werte.

Operatoren sind @, not, ^, *, /, div, mod, and, shl, shr, as, +, -, or, xor, =, >, <, <>,
<=, >=, in und is.

Die Operatoren @, not und ^ sind unäre Operatoren und haben nur einen Operanden. Alle anderen
Operatoren sind binär und haben zwei Operanden. Eine Ausnahme bilden die Operatoren + und -, die
entweder unär oder binär sein können.
Ein unärer Operator steht immer vor seinem Operanden (z. B. -B). Eine Ausnahme von dieser Regel
bildet der Operator ^, der auf seinen Operanden folgt (z. B. P^). Binäre Operatoren stehen immer
zwischen ihren Operanden (z. B. A = 7).
Das Verhalten einiger Operatoren hängt von dem Datentyp ab, der an sie übergeben wird.
Beispielsweise führt der Operator not eine bitweise Negation eines Integer-Operanden und eine
logische Negation eines Booleschen Operanden aus. Solche Operatoren sind deshalb auch mehreren
Kategorien zugeordnet.

Arithmetische Operatoren

Zu den arithmetischen Operatoren für Real- oder Integer-Operanden gehören die Operatoren +, -, *,
/, div und mod.

Binäre arithmetische Operatoren

Operator Operation Operandtyp Ergebnistyp Beispiel

+ Addition Integer, Real Integer, Real X+Y

- Subtraktion Integer, Real Integer, Real Ergebnis - 1

* Multiplikation Integer, Real Integer, Real P * InterestRate

/ Gleitkommadivision Integer, Real Real X/2

Div Ganzzahlige Division Integer Integer Total div UnitSize

mod Rest Integer Integer Y mod 6

Unäre arithmetische Operatoren

Operator Operation Operandtyp Ergebnistyp Beispiel

+ Positives Vorzeichen Integer, Real Integer, Real +7

- Negatives Vorzeichen Integer, Real Integer, Real -X

Für arithmetische Operatoren gelten die folgenden Regeln:

• Der Wert von x / y ist vom Typ Extended, unabhängig vom Typ von x und y. Bei allen
anderen Operatoren ist das Ergebnis vom Typ Extended, wenn mindestens ein Operand den
Typ Real hat. Ist das nicht der Fall, ist das Ergebnis vom Typ Int64, wenn mindestens ein
Operand den Typ Int64 hat, ansonsten ist das Ergebnis vom Typ Integer. Wenn der Typ eines

12/49
www.pdfmailer.de
B
Boorrllaanndd D
Deellpphhii

Operanden ein Unterbereich eines Integer-Typs ist, wird er wie ein Operand vom Typ Integer
behandelt.
• Der Wert von x div y entspricht dem Wert von x / y, abgerundet in Richtung Null bis zum
nächsten Integer-Wert.
• Der Operator mod liefert den Rest, der sich bei der Division seiner Operanden ergibt. Das
bedeutet: x mod y = x (x div y) * y.
• Wenn y in einem Ausdruck der Form x / y, x div y oder x mod y den Wert Null hat, tritt ein
Laufzeitfehler auf.

Boolesche Operatoren

Die Operanden der Booleschen Operatoren not, and, or und xor können einen beliebigen Booleschen
Typ haben. Die Operatoren liefern einen Wert vom Typ Boolean zurück.

Boolesche Operatoren

Operator Operation Operandtyp Ergebnistyp Beispiel

not Negation Boolean Boolean not (C in MySet)

and Konjunktion Boolean Boolean Done and (Total > 0)

or Disjunktion Boolean Boolean A or B

xor Exklusive Disjunktion Boolean Boolean A xor B

String-Operatoren

Die relationalen Operatoren =, <>, <, >, <= und >= funktionieren auch mit String-Operanden. Der
Operator + verkettet zwei Strings.

String-Operatoren

Operator Operation Operandtyp Ergebnistyp Beispiel


String,gepackter
+ Verkettung
String, Char
String S + '. '

Für die Verkettung von Strings gelten folgende Regeln:

• Die Operanden für + können Strings, gepackte Strings (gepackte Arrays vom Typ Char) oder
Zeichen sein. Wenn jedoch ein Operand vom Typ WideChar ist, muss der andere Operand ein
langer String (AnsiString oder WideString) sein.
• Das Ergebnis einer +-Operation ist mit allen String-Typen kompatibel. Wenn aber beide
Operanden kurze Strings oder Zeichen sind und ihre gemeinsame Länge größer als 255 ist,
wird das Ergebnis nach dem 255. Zeichen abgeschnitten.

13/49
www.pdfmailer.de
B
Boorrllaanndd D
Deellpphhii

Mengenoperatoren

Die folgenden Operatoren haben eine Menge als Operanden.

Mengenoperatoren

Operator Operation Operandtyp Ergebnistyp Beispiel

+ Vereinigung Menge Menge Set1 + Set2

- Differenz Menge Menge S-T

* Schnittmenge Menge Menge S*T

<= Untermenge Menge Boolean Q <= MySet

>= Obermenge Menge Boolean S1 &gt;= S2

= Gleich Menge Boolean S2 = MySet

<> Ungleich Menge Boolean MySet <> S1

in Element einer Menge Ordinalwert, Menge Boolean A in Set1

Für +, - und * gelten die folgenden Regeln:

• Der Ordinalwert O ist nur in X + Y enthalten, wenn O in X oder Y (oder beiden) enthalten ist.
O ist nur in X - Y enthalten, wenn O in X, aber nicht in Y enthalten ist. O ist nur in X * Y
enthalten, wenn O sowohl in X als auch in Y enthalten ist.
• Das Ergebnis einer Operation mit +, - oder * ist vom Typ set of A..B, wobei A der kleinste
und B der größte Ordinalwert in der Ergebnismenge ist.

Für <=, >=, =, <> und in gelten folgende Regeln.

• X <= Y ist nur dann True, wenn jedes Element von X ein Element von Y ist. Z >= W ist
gleichbedeutend mit W <= Z. U = V ist nur dann True, wenn U und V genau dieselben
Elemente enthalten. Andernfalls gilt U <> V ist True.
• Für einen Ordinalwert O und eine Menge S ist O in S nur dann True, wenn O ein Element von
S ist.

Relationale Operatoren

Relationale Operatoren dienen dem Vergleich zweier Operanden. Die Operatoren =, <>, <= und >=
lassen sich auch auf Mengen anwenden.

Relationale Operatoren

Operator Operation Operandtyp Ergebnistyp Beispiel


Einfacher Typ, Klassen-, Klassenreferenz-
= Gleich , Interface-, String- und gepackter Boolean I = Max
String-Typ
Einfacher Typ, Klassen-, Klassenreferenz-
<> Ungleich , Interface-, String- und gepackter Boolean X <> Y
String-Typ
Einfacher Typ, String-, gepackter String
< kleiner als
und PChar-Typ
Boolean X<Y

Einfacher Typ, String-, gepackter String


> Größer als
und PChar-Typ
Boolean Len > 0

14/49
B
Boorrllaanndd D
Deellpphhii

Einfacher Typ, String-, gepackter String


<= Kleiner oder gleich
und PChar-Typ
Boolean Cnt <= I

Einfacher Typ, String-, gepackter String


>= Größer oder gleich
und PChar-Typ
Boolean I >= 1

Bei den meisten einfachen Typen ist der Vergleich unkompliziert. I = J ist beispielsweise nur dann
True, wenn I und J denselben Wert haben. Andernfalls ist I <> J True.

Für relationale Operatoren gelten die folgenden Regeln:

• Operanden müssen kompatible Typen haben, mit folgender Ausnahme: Reelle und Integer-
Typen können miteinander verglichen werden.
• Strings werden gemäß den ordinalen Werten verglichen, die die Zeichen ausmachen, aus
denen wiederum der String besteht. Zeichen-Typen werden als Strings der Länge 1 behandelt.
• Zwei gepackte Strings müssen beim Vergleich dieselbe Anzahl von Komponenten aufweisen.
Wird ein gepackter String mit n Komponenten mit einem String verglichen, wird der gepackte
String als String der Länge n behandelt.
• Die Operatoren <, >, <= und >= werden nur dann für den Vergleich von PChar-Operanden
(sowie PWideChar) verwendet, wenn die beiden Zeiger auf Elemente in demselben Zeichen-
Array zeigen.
• Die Operatoren = und <> können Operanden von Klassen- und Klassenreferenztypen haben.
Mit Operanden eines Klassentyps werden = und <> entsprechend den Regeln für Zeiger
ausgewertet: C = D ist nur dann True, wenn C und D auf dasselbe Instanzobjekt zeigen.
Ansonsten ist C <> D True. Mit Operanden eines Klassenreferenztyps ist C = D nur dann
True, wenn C und D dieselbe Klasse bezeichnen. Andernfalls ist C <> D True. Dies ist nicht
mit Daten zu vergleichen, die in Klassen gespeichert sind

Rangfolge von Operatoren

In komplexen Ausdrücken wird die Reihenfolge, in der Operationen ausgeführt werden, durch die
Rangfolge der Operatoren festgelegt.

Wertigkeit der Operatoren

Operatoren Rangfolge
Ein Operator mit einer höheren
@, not Erste (höchste) Wertigkeit wird vor einem Operator mit
einer niedrigeren Wertigkeit
*, /, div, mod, and, shl, shr, as Zweite ausgewertet. Gleichrangige Operatoren
werden von links nach rechts
+, -, or, xor Dritte
ausgewertet. Aus diesem Grund
multipliziert der Ausdruck X + Y * Z
=, <>, <, >, <=, >=, in, is Vierte (niedrigste)
zunächst Y mit Z und addiert dann X
zum Ergebnis der Multiplikation. Die
Operation * (Multiplikation) wird zuerst ausgeführt, weil dieser Operator höherwertig ist als der
Operator +.

15/49
www.pdfmailer.de
B
Boorrllaanndd D
Deellpphhii

Arithmetik

Abs Die Funktion Abs gibt einen absoluten Wert zurück.


Ceil Ceil rundet den Wert einer Variablen auf.
Exp Die Funktion Exp gibt die Potenz von X zurück.
Factorial Factorial berechnet die Fakultät zu N.
Floor Floor rundet Variablen ab.
Frac Die Funktion Frac gibt den Nachkommaanteil einer reellen Zahl zurück.
Frexp Die Prozedur Frexp zerlegt einen Wert in Mantisse und Exponent.
GCD Die Funktion GCD ermittelt den größten gemeinsamen Teiler (ggT) von x
und y.
High Die Funktion High gibt den größten Wert im Bereich des Arguments zurück.
Int Die Funktion Int gibt den ganzzahligen Anteil einer reellen Zahl zurück.
IntPower IntPower errechnet die Potenz aus einer Basis.
LCM Die Funktion LCM ermittelt das kleinste gemeinsame Vielfache (kgV) von x
und y.
Ldexp Ldexp gibt X mal (2 hoch P) zurück.
Ln Die Funktion Ln gibt den natürlichen Logarithmus eines Real-Ausdrucks
zurück.
LnXP1 LnXP1 gibt den natürlichen Logarithmus von (X+1) zurück.
Log10 Log10 berechnet den Logarithmus zur Basis 10 (dekadisch).
Log2 Log2 berechnet den Logarithmus zur Basis 2.
LogN LogN berechnet den Logarithmus zur Basis N.
Max Max gibt den größeren von zwei numerischen Werten zurück.
Min Max gibt den kleineren von zwei numerischen Werten zurück.
Pi Die Funktion Pi gibt den Wert von Pi zurück (3,1415926535897932385).
Poly Poly wertet ein einheitliches Polynom einer Variable für den Wert X aus.
Power Power errechnet aus der Basis Base und dem beliebigen Wert Exponent die
Potenz.
Pythagoras Berechnet die Wurzel aus x2 + y2
RelativePrime Ermittelt, ob die beiden Zahlen teilerfremd sind oder nicht.
Round Die Funktion Round rundet den Wert von X auf den nächsten Integer-Wert.
Sgn Gibt das Vorzeichen einer Zahle zurück (-1, 0, 1) (Signum(X))
Signe Gibt den Wert der Zahl X mit dem Vorzeichen von Y zurück.
Sin Die Funktion Sin berechnet den Sinus von X
Sqr Die Funktion Sqr gibt das Quadrat eines Wertes zurück.
Sqrt Die Funktion Sqrt gibt die Quadratwurzel eines Wertes zurück.
SwapFloats Die Funktion vertauscht die Werte von x und y.
TenToY TenToY berechnet die Potenz zur Basis 10.
TwoToY TwoToY berechnet die Potenz zur Basis 2.

16/49
BBoorrllaanndd D
Deellpphhii

Struktur eines Pascal-Programms

Pascal ist so konzipiert, dass Programme durch einen so genannten One-Pass-Compiler übersetzt
werden kann. Dies hat für die Geschwindigkeit der Übersetzung einen enormen Vorteil, bedeutet aber,
dass der Programmierer eine bestimmte Reihenfolge innerhalb eines Programms einhält. Diese
Einschränkung ist aber in der Praxis keine, sondern eher eine Erleichterung, da man auch bei fremden
Programmen sehr schnell die Struktur erkennen kann.

Betrachtet man ANSI-Pascal so ergibt sich für die Abfolge der wichtigsten Programmteile folgende
Reihenfolge (Object-Pascal hält sich natürlich auch an diese Reihenfolge, allerdings kommen noch
weitere Konstrukte, wie Interfaces etc. dazu):

Hauptprogramm

Das Hauptprogramm befindet sich immer am Ende des Programms und wird durch begin und end.
begrenzt (wichtig ist der Punkt hinter dem end - end. darf nur einmal in jedem Programm oder Modul
vorkommen und zeigt das Ende des Quellcodes an. Überlicherweise ist das Hauptprogramm ziemlich
kurz, und weist meist nicht mehr als ein paar Zeilen auf. Im Hauptprogramm stehen meist nur ein
paar Aufrufe von Unterprogrammen.

Als Folge des One-Pass-Compiler-Konzepts müssen Unterprogramme im Quellcode immer vor dem
aufrufenden Programm stehen, wodurch sich zwangsläufig ergibt, dass das Hauptprogramm am Ende
des Codes steht.

Programmnamen

Jedes Programm hat einen Programmnamen der mit dem Schlüsselwort program bzw. unit oder
library (wenn es sich um ein Modul oder eine Bibliothek handelt) gekennzeichnet ist. Der
Programmname selber darf keine Leerzeichen enthalten.

Hinweis: Delphi verlangt, dass die Identifier der Schlüsselwörter program, unit und library
mit den Dateinamen der jeweiligen Files übereinstimmen. Das bedeutet, dass
man ein Programm nur umbenennen kann indem man es unter einem anderen
Namen abspeichert.

17/49
B
Boorrllaanndd D
Deellpphhii

Deklarationen

Die Namen von Variablen, Konstanten, Typen, Feldern, Eigenschaften, Prozeduren, Funktionen,
Programmen, Units, Bibliotheken und Packages werden Bezeichner genannt. (Numerische Konstanten
wie 26057 sind keine Bezeichner.) Damit ein Bezeichner verwendet werden kann, muss er zuerst
deklariert werden. Ausnahmen bilden einige vordefinierte Typen, Routinen und Konstanten, die vom
Compiler auch ohne Deklaration interpretiert werden können, die Variable Result innerhalb eines
Funktionsblocks und die Variable Self in einer Methodenimplementierung. Eine Deklaration definiert
den Bezeichner und sorgt dafür, dass bei Bedarf Speicher für ihn reserviert wird.

Beispiel: var Size: Extended;

Diese Anweisung deklariert eine Variable namens Size, die einen Extended-Wert (Typ Real) enthält.

function DoThis(X, Y: string): Integer;

Dagegen deklariert diese Anweisung eine Funktion mit dem Namen DoThis, die zwei Strings als
Argumente übernimmt und einen Integer zurückgibt.

Jede Deklaration wird durch einen Strichpunkt abgeschlossen. Werden mehrere Variablen,
Konstanten, Typen oder Labels gleichzeitig deklariert, genügt es, das entsprechende reservierte Wort
nur einmal anzugeben:

var Size: Extended;


Quantity: Integer;
Description: string;

Die Syntax und der Ort einer Deklaration ist vom Typ des Bezeichners abhängig, der definiert werden
soll. In der Regel erfolgen Deklarationen nur am Anfang eines Blocks bzw. am Anfang des interface-
oder implementation-Abschnitts einer Unit (nach der uses-Klausel).

Anweisungen

Anweisungen definieren algorithmische Aktionen in einem Programm. Einfache Anweisungen (z. B.


Zuweisungen und Prozeduraufrufe) können kombiniert werden. Auf diese Weise lassen sich Schleifen,
bedingte Anweisungen und andere strukturierte Anweisungen erzeugen. Mehrere Anweisungen in
einem Block sowie im initialization- und finalization-Abschnitt einer Unit werden durch Strichpunkte
voneinander getrennt.

Einfache Anweisungen

Einfache Anweisungen enthalten keine anderen Anweisungen. Zu ihnen gehören Zuweisungen,


Aufrufe von Prozeduren und Funktionen sowie goto-Anweisungen.

Zuweisungen

Eine Zuweisung hat folgendes Format:

Variable := Ausdruck

Das Symbol := wird als Zuweisungsoperator bezeichnet. Eine Zuweisung ersetzt den aktuellen Wert
von Variable durch den Wert von Ausdruck.

Beispiel: I := 3;

Mit dieser Anweisung wird der Variablen I der Wert 3 zugewiesen. Die Variablenreferenz auf der linken
Seite der Zuweisung kann auch im Ausdruck auf der rechten Seite enthalten sein.

Beispiel: I := I + 1; Hier wird der Wert von I erhöht.

18/49
B
Boorrllaanndd D
Deellpphhii

Weitere Beispiele für Zuweisungen: X := Y + Z;


Done := (I >= 1) and (I < 100);
Hue1 := [Blue, Succ(C)];
I := Sqr(J) - I * K;
Shortint(MyChar) := 122;
TByteRec(W).Hi := 0;
MyString[I] := 'A';
SomeArray[I + 1] := P^;
TMyObject.SomeProperty := True;

Prozedur- und Funktionsaufrufe

Ein Prozeduraufruf besteht aus dem Namen einer Prozedur (mit oder ohne Qualifizierer) und (falls
erforderlich) einer Parameterliste.

Hier einige Beispiele für Prozeduraufrufe: PrintHeading;


Transpose(A, N, M);
Find(Smith, William);
Writeln('Hello world!');
DoSomething();
Unit1.SomeProcedure;
TMyObject.SomeMethod(X,Y);

Goto-Anweisungen

Die Syntax für goto-Anweisungen lautet: goto Label

Eine goto-Anweisung setzt die Ausführung des Programms mit der Anweisung fort, die mit dem
angegebenen Label markiert ist.

Die goto-Anweisung kann auch eingesetzt werden, um eine verschachtelte Schleife zu verlassen. Das
Label einer goto-Anweisung darf sich nicht innerhalb einer anderen Schleife oder strukturierten
Anweisung befinden, da dies zu unvorhersehbaren Ergebnissen führen könnte.

Strukturierte Anweisungen

Strukturierte Anweisungen sind aus anderen Anweisungen aufgebaut. Sie werden eingesetzt, wenn
andere Anweisungen sequenziell, wiederholt oder in Abhängigkeit von einer Bedingung ausgeführt
werden sollen.

Verbundanweisungen

Eine Verbundanweisung setzt sich aus einer Folge von anderen (einfachen oder strukturierten)
Anweisungen zusammen, die in der genannten Reihenfolge ausgeführt werden. Die in einer
Verbundanweisung enthaltenen Teilanweisungen sind zwischen den reservierten Wörtern begin und
end eingeschlossen und durch Strichpunkte voneinander getrennt.

Beispiel: begin
Z := X;
X := Y;
X := Y;
end;

Verbundanweisungen sind wichtig, wenn die Syntax von Delphi genau eine Anweisung verlangt. Sie
können in Programm-, Funktions- und Prozedurblöcke und in andere strukturierte Anweisungen (z. B.
bedingte Anweisungen oder Schleifen) integriert werden.

19/49
B
Boorrllaanndd D
Deellpphhii

Es gibt auch Verbundanweisungen, die nur eine einzelne Teilanweisung enthalten. Wie runde
Klammen in einem komplexen Ausdruck tragen auch die Wörter begin und end zur Vermeidung von
Mehrdeutigkeiten und zur Verbesserung der Lesbarkeit bei.

Es ist auch möglich, mit einer leeren Verbundanweisung einen Block zu erzeugen, der keine Aktion
ausführt:
begin
end;

20/49
BBoorrllaanndd D
Deellpphhii

Grundlegende Pascal-Syntax

Wie in jeder Programmiersprache gibt es auch in Pascal ein paar Regeln, die man wissen muss um
überhaupt eine brauchbare Programmzeile zu schreiben. Dazu gehören z.B. Regeln für
Variablennamen, der Umgang mit Leerzeilen, etc. Im Folgenden sind die wichtigsten Grundregeln für
Pascal zusammengestellt:

Länge einer Programmzeile


In Pascal dürfen Programmzeilen beliebig lang sein. Allerdings ist das wenig empfehlenswert, da das
die Lesbarkeit massiv beeinträchtigt. Überall dort wo ein Leerzeichen (blank) möglich ist, können auch
eine oder mehrere Leerzeilen eingefügt werden. Dies ermöglicht eine leichte Formatierung des Codes.

Einrückungen

Einrückungen von Code-Teilen sind ein wichtiges Stilelement, das man ganz gezielt einsetzen sollte.

Strichpunkte

Jedes Pascal-Statement muss am Ende durch einen Strichpunkt begrenzt sein. Fehlt der Strichpunkt,
so liefert der Compiler eine Fehlermeldung, die üblicherweise erst in der nächsten Programmzeile
auftritt, da ja vorher nicht klar ist, dass eine Strichpunkt fehlt.

Es gibt von dieser Regel nur zwei Ausnahmen. Die eine Ausnahme betrifft das Schlüsselwort end.
(beachte den Punkt), das in jedem Programm nur einmal vorkommen darf und das Ende des
Programms signalisiert. Programmzeilen nach einem end. werden vom Compiler ignoriert. Die zweite
Ausnahme betrifft Statements unmittelbar vor einem end-Statement. Hier darf der Strichpunkt
weggelassen werden (was eine gewisse Inkonsistenz erzeugt), muss aber nicht. Generell sollte man
sich zur Gewohnheit machen, immer einer Strichpunkt zu schreiben.

Hinweis: Bei if-then-else-Konstrukten darf der abschließende Strichpunkt nur nach dem else-Teil
stehen, da sonst das Statement nicht komplett ist. Das heißt aber nicht, dass in einem solchen
Konstrukt kein Strichpunkt vorkommen darf - falls die einzelnen Teile durch Anweisungsblöcke
(begin...end) codiert sind, müssen innerhalb der Anweisungsblöcke sehr wohl Strichpunkte gesetzt
werden, obwohl diese Teil eines übergeordneten if-then-else-Konstrukts sind.

Groß/Kleinschreibung

In Pascal dürfen Groß- und Kleinbuchstaben beliebig gemischt werden. Man kann so Groß- und
Kleinschreibung gezielt als Stilelement einsetzen um die Lesbarkeit von Programmen zu erhöhen
(siehe auch Deklaration von Konstanten)

Länge von Bezeichnern

Namen oder Bezeichner (engl. identifier) von Konstanten, Datentypen, Variablen, Prozeduren und
Funktionen, etc. können beliebig lange sein, allerdings empfiehlt sich ein Kompromiss zwischen sehr
kurzen und sehr langen Namen (die kurzen Namen sind schnell zu schreiben, die langen leichter zu
lesen). Für Variable wird man nur für Hilfsvariable kurze Bezeichner wählen.

21/49
BBoorrllaanndd D
Deellpphhii

Gleichheitszeichen

Das Gleichheitszeichen (=) wird in Pascal in drei verschiedenen Situationen eingesetzt. Einmal zum
Vergleich von zwei Variablen, dann zur Definition von Datentypen und Konstanten, und als drittes in
Kombination mit einem Doppelpunkt als Zuweisungsoperator. Um Pascal-Code leicht lesen zu können,
gewöhnt man sich am besten an, die Kombination := als ein eigenes Schlüsselwort zu lesen. Zwischen
Doppelpunkt und Gleichheitszeichen darf niemals ein Leerzeichen stehen.

Beispiel: if (x1 = 2) then


begin
end;
Hier wird das Gleichheitszeichen zum Vergleich verwendet (falls x1 gleich 2 ist
dann....).
type
TMyType = (mtJan, mtFeb, mtMar);
In der Deklaration von TMyType werden die Werte mtJan, mtFeb und mtMar als
zusammengehörig definiert.
x1 := 5;
Dieses Statement weist der Variablen x1 den Wert 5 zu.

Kommentare

Grundsätzlich erlaubt Delphi vier verschiedene Arten von Kommentaren, wobei Kommentare überall
dort im Programmcode geschrieben werden dürfen, wo ein Leerzeichen syntaktisch erlaubt ist:

Mit dem Doppelschrägstrich werden Teile einzelner Zeilen als Kommentar markiert. Alle
// Zeichen rechts neben dem Doppelschrägstrich bis ans Ende der Zeile gelten als
Kommentar.
Möchte man mehr als eine Zeile als Kommentar kennzeichnen, oder Teile innerhalb einer
{} Zeile, so benützt man geschweifte Klammern. Alle Zeichen innerhalb geschweifter
Klammern sind Kommentar.
Man kann statt geschweiften Klammern auch die Zeichenkombinationen (* und *)
benützen; (* steht für die linke geschweifte Klammer, *) für die rechte. Diese Art der
(* *) Klammerung verhält sich exakt so wie die geschweiften Klammern. Allerdings darf man {
} und (* *) nicht mischen. (* irgend ein Text } ist zwar ein Kommentar, der Kommentar
hört aber nicht mit } auf, sondern geht weiter bis die nächste *) Kombination auftritt
Eine Besonderheit von Pascal ist, dass jeglicher Text nach dem Statement end. als
Text nach Kommentar betrachtet wird (der Compiler hört mit end. zu übersetzen auf). Dies kann
dem dazu benützt werden, um sich während der Programmentwicklung einen kleinen
finalen Notizblock zu schaffen. Allerdings sollte man diese Möglichkeit nur für vorübergehende
end. Notizen einsetzen. Kommentare sollten nämlich immer an die Stellen geschrieben werden,
auf die sie sich beziehen.

Neben der oben beschriebenen grundsätzlichen Syntax gibt es noch eine weitere wichtige Regel:
Kommentare dürfen nicht verschachtelt werden, wenn sie die selbe Kommentarkennung (also (* *)
oder {} ) benützen. Man darf aber Kommentare, die ausschließlich die eine Möglichkeit benützen, mit
der anderen Möglichkeit umklammern. Doppelschrägstrich-Kommentare sind davon nicht betroffen.

Hinweis: Man sollte sich angewöhnen, für längere Kommentare immer dieselbe Art zu
verwenden, da es nur so möglich ist, längere Teile von Code einschließlich der
zugehörigen Kommentare versuchsweise aus dem Programmcode heraus zu
nehmen, indem man den betroffenen Code als Kommentar kennzeichnet. Man
nennt diese Vorgangsweise auch "auskommentieren".

22/49
BBoorrllaanndd D
Deellpphhii

Neben den eigentlichen Kommentaren gibt es noch eine spezielle Art von Kommentaren, die zur
Steuerung des Compilers dienen: das sind so genannte Compiler-Switches und Anweisungen zur
bedingten Compilation. Näheres dazu finden Sie im Delphi-Help (Stichwort "Compileranweisungen"
bzw. "Compiler Directives")

Eine wichtige Frage betrifft den Stil der Kommentare und deren Länge: Grundsätzlich gilt für
Kommentare die Maxime "keep it plain and simple". Kommentare sollen keine hochgestochene
Belletristik sein, sondern schlicht und einfach die Gedankengänge des Programmierer widerspiegeln
und Hilfestellung für das Verstehen eines Programms geben. Gerade im deutschen Sprachraum (auch
wenn die Kommentare in Englisch geschrieben sind) findet man sehr oft die Angewohnheit,
Kommentare möglichst kompliziert zu machen, damit der Leser des Kommentars vor Ehrfurcht über
das Wissen des Programmierers erschauern möge - das ist kontraproduktiv, ein Kommentar soll helfen
den Code zu verstehen und nicht ein Denkmal für den Programmierer sein.

Kommentare haben neben der eigentlichen Notiz- und Erklärungsfunktion auch noch die Funktion das
Programmieren zu erleichtern. Zum einen setzt man Kommentare in den Headern von
Unterprogrammen zur Dokumentation der Funktion des jeweiligen Unterprogramms ein. Hält man sich
bei den Kommentaren an eine bestimmte Syntax, so können diese durch spezielle Tools automatisch
zu einem Helpfile zusammengestellt werden. Zum anderen kann man Kommentare dazu verwenden,
um vor der Codierung eines Algorithmus dessen Funktion als Pseudo-Code zu notieren. Dieser
Pseudo-Code dient als roter Faden bei der eigentlichen Implementierung und bleibt als Kommentar im
Programmcode erhalten.

23/49
B
Boorrllaanndd D
Deellpphhii

Der Delphi-Zeichensatz

Die Delphi-Sprache verwendet den Unicode-Zeichensatz mit alphabetischen und alphanumerischen


Unicode-Zeichen und Unterstrichen. Die Sprache unterscheidet nicht zwischen Groß- und
Kleinschreibung. Das Leerzeichen und die ASCII-Steuerzeichen (ASCII 0 bis 31 einschließlich ASCII 13
für Zeilenvorschub) werden als Blanks bezeichnet. Kombinationen, die sich aus den grundlegenden
syntaktischen Elementen (den so genannten Token) zusammensetzen, ergeben Ausdrücke,

Deklarationen und Anweisungen. Eine Anweisung beschreibt eine algorithmische Aktion, die innerhalb
eines Programms ausgeführt werden kann. Ein Ausdruck ist eine syntaktische Einheit, die in einer
Anweisung enthalten ist und einen Wert beschreibt. Eine Deklaration definiert einen Bezeichner (z. B.
den Namen einer Funktion oder Variablen), der in Ausdrücken und Anweisungen verwendet wird. Sie
weist dem Bezeichner bei Bedarf auch Speicherplatz zu.

Bezeichner

Bezeichner werden für Konstanten, Variablen, Felder, Typen, Eigenschaften, Prozeduren, Funktionen,
Programme, Units, Bibliotheken und Packages verwendet. Obwohl ein Bezeichner beliebig lang sein
kann, sind nur die ersten 255 Zeichen signifikant. Ein Bezeichner muss mit einem alphabetischen
Zeichen oder einem Unterstrich (_) beginnen und darf keine Leerzeichen enthalten. Auf das erste
Zeichen können alphanumerische Zeichen, Ziffern und Unterstriche folgen. Reservierte Wörter dürfen
nicht als Bezeichner verwendet werden.

Hinweis: Der .NET SDK empfiehlt als erstes Zeichen eines Bezeichners keinen Unterstrich zu
verwenden, weil diese Notation für das System reserviert ist.

Da die Groß-/Kleinschreibung in Delphi nicht berücksichtigt wird, sind beispielsweise für den
Bezeichner CalculateValue folgende Schreibweisen zulässig:

CalculateValue
calculateValue
calculatevalue
CALCULATEVALUE

Da Unit-Namen Dateinamen entsprechen, kann eine unterschiedliche Schreibweise zu


Compilierungsfehlern führen.

Qualifizierte Bezeichner

Wenn Sie einen Bezeichner verwenden, der an mehreren Stellen deklariert wurde, muss dieser unter
Umständen qualifiziert werden. Die Syntax für einen qualifizierten Bezeichner lautet:

Bezeichner1.Bezeichner2

Dabei qualifiziert Bezeichner1 den Bezeichner2. Angenommen, zwei Units deklarieren eine Variable
namens CurrentValue.

Mit der folgenden Anweisung legen Sie fest, dass auf CurrentValue in Unit2 zugegriffen werden soll:

Unit2.CurrentValue

Bezeichner können über mehrere Ebenen qualifiziert werden.

Beispiel: Form1.Button1.Click

Mit dieser Anweisung wird die Methode Click in Button1 von Form1 aufgerufen. Wenn Sie einen
Bezeichner nicht qualifizieren, wird seine Interpretation von den Regeln für den Gültigkeitsbereich
festgelegt, die unter Blöcke und Gültigkeitsbereich beschrieben werden.

24/49
B
Boorrllaanndd D
Deellpphhii

Reservierte Wörter

Die folgenden reservierten Wörter können weder neu definiert noch als Bezeichner verwendet werden.

Reservierte Wörter

and else inherited packed then

array end initialization procedure threadvar

as except inline program to

asm exports interface property try

begin file is raise type

case final label record unit

class finalization library repeat unsafe

const finally mod resourcestring until

constructor for nil sealed uses

destructor function not set var

dispinterface goto object shl while

div if of shr with

do implementation or static xor

downto in out string

Neben den oben aufgeführten Wörtern gelten in Objekttypdeklarationen auch private, protected,
public, published und automated als reservierte Wörter. In allen anderen Fällen werden sie als
Direktiven behandelt. Die Wörter at und on haben ebenfalls eine besondere Bedeutung.

Direktiven

Direktiven sind Wörter, die an bestimmten Stellen des Quelltextes besonders behandelt werden.
Direktiven haben in Delphi spezielle Bedeutungen. Sie werden aber im Gegensatz zu reservierten
Wörtern nur in Umgebungen verwendet, in denen benutzerdefinierte Bezeichner nicht auftreten
können. Aus diesem Grund lassen sich Bezeichner definieren, die wie Direktiven lauten. (Dieses
Vorgehen ist allerdings nicht empfehlenswert.)

Direktiven

absolute local platform requires dynamic

abstract message private resident export

assembler name protected safecall external

automated near public stdcall far

25/49
B
Boorrllaanndd D
Deellpphhii

cdecl nodefault published stored forward

contains overload read varargs implements

default override readonly virtual index

deprecated package register write inline

dispid pascal reintroduce writeonly library

Zahlen

Integer- und Real-Konstanten lassen sich in dezimaler Notation als Folge von Ziffern ohne Kommas
oder Leerzeichen darstellen. Das Vorzeichen wird durch den vorangestellten Operator + oder -
angegeben.
Werte sind per Vorgabe positiv (67258 ist also identisch mit +67258) und müssen im Bereich des
größten vordefinierten Real- bzw. Integer-Typs liegen. Zahlen mit Nachkommastellen oder
Exponenten bezeichnen Real-Konstanten. Andere Dezimalzahlen sind Integer-Konstanten.
Bei Real-Typen wird die wissenschaftliche Notation (E oder e gefolgt von einem Exponenten) als "mal
10 hoch" gelesen. So bedeutet 7E2 beispielsweise 7 * 10^2, und 12.25e+6 oder 12.25e6 bedeutet
12.25 * 10^6.
Das Dollarzeichen als Vorzeichen kennzeichnet eine hexadezimale Zahl, beispielsweise $8F.
Hexadezimalzahlen ohne vorausgehenden unären Operator - werden als positive Werte angesehen.

Labels

Ein Label ist ein Standard-Delphi-Bezeichner. Der Unterschied zu anderen Bezeichnern besteht darin,
dass Labels mit einer Ziffer beginnen können. Numerische Labels können nicht mehr als zehn Ziffern
enthalten, d. h. eine Zahl zwischen 0 und 9999999999. Labels werden in goto-Anweisungen
verwendet.

Zeichen-Strings

Ein Zeichen-String (auch String-Literal oder String-Konstante genannt) kann aus einem String in
Anführungszeichen, einem Steuerzeichen-String oder einer Kombination aus beiden bestehen.
Trennzeichen treten nur bei Strings in Anführungszeichen auf. Ein String in Anführungszeichen setzt
sich aus einer Folge von maximal 255 Zeichen des erweiterten ASCII-Zeichensatzes zusammen, muss
in einer Zeile stehen und in halbe Anführungszeichen eingeschlossen sein. Ein String in
Anführungszeichen, der zwischen den halben Anführungszeichen kein Zeichen enthält, ist ein Null-
String. Zwei in einem String in Anführungszeichen unmittelbar aufeinander folgende halbe
Anführungszeichen stehen für ein einzelnes Anführungszeichen.

Beispiel: 'BORLAND' { BORLAND }


'Müller''s Büro'' { Müller's Büro' }
'' { Null-String }
'' { ein Leerzeichen }

26/49
B
Boorrllaanndd D
Deellpphhii

Fehlerarten

Fehler lassen sich in drei Gruppen untergliedern: Fehlerarten

Syntaxfehler

Laufzeitfehler

Logische Fehler

Syntaxfehler

Diese Fehler treten bereits während der Compilierung des Programms auf, wenn sich nicht an die
Syntax von Object Pascal gehalten wird. Delphi stoppt den Compiliervorgang nach dem Compilieren
der ersten fehlerhaften Unit.

Beispiele:

• Es werden Bezeichner für Variablen, Konstanten oder Prozeduren, die reservierte Wörter von
Object Pascal darstellen benutzt.
• Es wurden Sonderzeichen (Hochkommata, Klammern, Semikolons) vergessen.
• Ein Schlüsselwort wurde falsch geschrieben.
• Es werden Operationen mit Datentypen durchgeführt, die für diese nicht erlaubt sind.

Laufzeitfehler

Nachdem alle Syntaxfehler beseitigt sind, wird das Programm ausgeführt. Tritt während der
Ausführung ein Fehler auf, wird das Programm abgebrochen, bevor das Programmende erreicht wird.
Es ist ein Laufzeitfehler eingetreten. Im Gegensatz zu Syntaxfehlern treten Laufzeitfehler nicht bei der
Compilierung, sondern während der Programmausführung auf.

Beispiele:

• Das Programm versucht, eine Zahl durch Null zu dividieren.


• Das Programm will eine Datei zur Bearbeitung öffnen, die nicht existiert.
• Es wurde ein Programm geschrieben, das eine Tabelle auf dem Drucker ausgeben soll. Der
Drucker enthält jedoch kein Papier, während der Programmausführung.

27/49
B
Boorrllaanndd D
Deellpphhii

Logische Fehler

Logische Fehler sind Fehler, die weder die Syntax der Programmiersprache verletzen noch einen
Absturz des Programms bewirken. Deshalb erkennt weder der Compiler den Fehler, noch kann er
durch einen einfachen Start des Programms ermittelt werden. Diese Art von Fehlern äußert sich
beispielsweise in fehlerhaften Ergebnissen von Berechnungen oder im inkorrekten Anzeigen von
Daten.

Beispiel: Statt V:= a * b * c hat man V:= 2*(a*b + a*c + b*c) eingegeben.

Deshalb ist es ratsam, nach erfolgreicher Compilierung und Ausführung des Programms Testläufe mit
Beispieldaten durchzuführen um solche Fehler auszuschließen.

28/49
B
Boorrllaanndd D
Deellpphhii

Algorithmus-Begriff

Unter der Spezifikation eines Algorithmus versteht man eine Aussage, die möglichst genau beschreibt,
was der Algorithmus leistet. Zwei Algorithmen heißen wirkungsgleich (äquivalent), wenn sie der
gleichen Spezifikation genügen.

Algorithmus:

Beschreibung zur Lösung eines Problems, die so formuliert ist, dass sie von einer Maschine
abgearbeitet werden kann.

Eigenschaften von Algorithmen:

1. Jeder Algorithmus löst eine Klasse von Problemen.


2. endliche Beschreibung
3. endliche Abarbeitung
4. Determiniertheit (gleiche Eingabe --> gleiche Ausgabe)
5. Arten:
ƒ deterministische
(Zu jedem Zeitpunkt seiner Ausführung besteht höchstens eine Möglichkeit der
Fortsetzung.)
ƒ nichtdeterministische,
(An gewissen Stellen gibt es bei der Ausführung mehrere Möglichkeiten der
Fortsetzung, von denen man nach Belieben eine auswählen kann.)
ƒ stochastische (An gewissen Stellen gibt es bei der Ausführung mehrere
Möglichkeiten der Fortsetzung, für deren Auswahl man Wahrscheinlichkeiten zuordnen
kann.)

Formulierung von Algorithmen:

1. verbale
2. Struktogramm
3. Programm (Quelltext)

29/49
B
Boorrllaanndd D
Deellpphhii

Top-Down-Prinzip

Lösung des Problems

Anweisungen

ungelöstes Teilproblem 1

Anweisungen

ungelöstes Teilproblem 2
Lösung von Teilproblem 1

Anweisungen

Anweisungen

Teilproblem 1a

Anweisungen

Teilproblem 1b Lösung von

Teilproblem 1a Teilproblem 1b

Anweisungen Anweisungen

Teilproblem 1 ist gelöst, da die Teilprobleme 1a und 1b durch vollständig bekannte Anweisungen
ersetzt werden können. Die Lösung von Teilproblem 2 erfolgt entsprechend.

Das TOP-DOWN-Prinzip kann sinnvoll bei allen schwierigen Programmieraufgaben eingesetzt werden.

TOP-DOWN-Prinzip der Programmierung


Man zerlegt ein Problem in gelöste und ungelöste Teile und behandelt dabei die ungelösten Teile so,
als seien sie gelöst. Dann behandelt man der Reihe nach die einzelnen ungelösten Teilprobleme nach
demselben Verfahren so lange, bis das letzte derart erzeugte Teilproblem vollständig durch bekannte
Verfahren gelöst werden kann.

30/49
B
Boorrllaanndd D
Deellpphhii

Schleifen

sind Wiederholungsstrukturen, die sowohl eine bestimmte als auch eine unbestimmte Anzahl von
Durchläufen aufweisen können. Schleifen ermöglichen die wiederholte Ausführung einer
Anweisungsfolge. Eine Bedingung oder eine Variable bestimmt, wann die Ausführung angehalten wird.

Delphi unterstützt drei Arten von Schleifen: repeat-, while- und for-Schleifen. Mit den
Standardprozeduren Break und Continue können Sie in den Ablauf einer repeat-, while- oder for-
Schleife eingreifen. Break beendet eine Schleife, Continue fährt mit der nächsten Iteration fort.

Schleifen

bestimmte Anzahl unbestimmte Anzahl


von Durchläufen von Durchläufen

FOR-Schleife

Syntax: for Zähler:=Anfangswert to Endwert do


begin
...
end;

Man verwendet anstelle von to downto, wenn der Anfangswert größer als der Endwert ist.

Beispiel:

Berechnung der Quadrat-


zahlen von 1 bis 20.

Achtung: Die Zählvariable muss immer vom ordinalen


Datentyp d. h. abzählbar sein. Real und dergleichen
Datentypen sind also nicht zulässig und erzeugen
eine Fehlermeldung.

31/49
B
Boorrllaanndd D
Deellpphhii

WHILE-Schleife

Während die for-Schleife eine reine Zählschleife war, sind Schleifen mit einer unbestimmten Anzahl
von Durchläufen, Schleifen bei denen Anfangs- bzw. Endbedingungen überprüft werden.

Die while-Anweisung überprüft die Anfangsbedingung und arbeitet nach erfolgter Auswertung die
Schleife ab oder nicht.

Syntax: while Ausdruck do Anweisung

Ausdruck liefert einen Booleschen Wert zurück. Bei


Anweisung kann es sich auch um eine Verbundanweisung
handeln. Die while-Schleife führt Anweisung wiederholt
aus und wertet vor jedem neuen Durchlauf den
angegebenen Ausdruck aus.

Solange Ausdruck den Wert true ergibt, wird die Ausführung fortgesetzt.

REPEAT-Schleife

Die repeat-Anweisung überprüft die Endbedingung. Nach jedem Durchlauf wird der angegebene
Ausdruck ausgewertet. Liefert Ausdruck den Wert true, wird die repeat-Anweisung beendet. Da
Ausdruck erst am Ende der ersten Iteration ausgewertet wird, wird die Anweisungsfolge mindestens
einmal durchlaufen.

Syntax: repeat Anweisung1; ...; Anweisungn; until Ausdruck

32/49
B
Boorrllaanndd D
Deellpphhii

Bedingte Anweisungen (Alternativen)

Sind Anweisungen, bei denen die Programmfortsetzung von einer Bedingung oder dem Wert eines
Selektors (ist auch eine Bedingung) abhängig gemacht wird.

Alternativen

Einseitige Zweiseitige Mehrseitige


Auswahl Auswahl Auswahl

IF-THEN IF-THEN-ELSE CASE-OF

IF-THEN

Syntax: if Bedingung then Anweisung;

Das Ergebnis von Bedingung ist ein Wert vom Typ Boolean. Anweisung wird nur ausgeführt, wenn die
Bedingung den Wert True ergibt.

Beispiel:

Soll mehr als eine Anweisung abgearbeitet werden, muss diese mit begin und end geklammert
werden.

IF-THEN-ELSE

Syntax: if Bedingung then Anweisung1 else Anweisung2;

Das Ergebnis von Bedingung ist ein Wert vom Typ Boolean. Wenn die Bedingung den Wert True
ergibt, wird Anweisung1 ausgeführt, andernfalls Anweisung2.

Beispiel:

CASE-OF

Die case-Anweisung ist eine Alternative zur if-Anweisung, die aufgrund der besseren Lesbarkeit bei
komplexen Verschachtelungen eingesetzt werden sollte.

Syntax: case SelektorVariable of


CaseListe1: Anweisung1;

CaseListen: Anweisungn;
end;

Hierbei ist SelektorVariable ein beliebiger Ausdruck eines ordinalen Typs (String-Typen sind nicht
zulässig). Für CaseListe kann folgendes angegeben werden:

33/49
B
Boorrllaanndd D
Deellpphhii

• Eine Zahl, eine deklarierte Konstante oder ein anderer Ausdruck, den der Compiler auswerten
kann, ohne dazu das Programm selbst auszuführen. CaseListe muss von einem ordinalen Typ
sein, der zum Typ von SelektorVariable kompatibel ist. 7, True, 4 + 5 * 3, 'A', und Integer('A')
sind demnach als CaseListe zulässig, Variablen und die meisten Funktionsaufrufe dagegen
nicht.
• Ein Teilbereich der Form Erster..Letzter, wobei Erster und Letzter den obigen Kriterien
entsprechen müssen und Erster kleiner oder gleich Letzter sein muss.
• Eine Liste der Form Element1, ..., Elementn, wobei jedes Element den obigen Kriterien
entsprechen muss.

Jeder in einer CaseListe angegebene Wert muss innerhalb der case-Anweisung eindeutig sein.
Teilbereiche und Listen dürfen sich nicht überschneiden. Eine case-Anweisung kann über eine
abschließende else-Klausel verfügen:

Beispiel:

34/49
www.pdfmailer.de
B
Boorrllaanndd D
Deellpphhii

Rekursion

Als Rekursion (auch Rekurrenz oder Rekursivität), von lateinisch recurrere = zurücklaufen,
bezeichnet man den Aufruf oder die Definition einer Funktion durch sich selbst. Die gegenseitige
Rekursion bildet sich durch den gegenseitigen Verweis zweier oder mehrerer Funktionen auf einander.
Wichtig dabei ist eine Abbruchbedingung in dieser Funktion, weil sich das rekursive Programm
sonst (theoretisch) bis in alle Ewigkeit selbst aufrufen würde.

In vielen Fällen ist die Rekursion eine von mehreren möglichen Problemlösungsstrategien, sie führt oft
zu „ eleganten“mathematischen Lösungen.
Rekursion wird in der Regel durch einen Stack implementiert, der die Rücksprungadressen, aber auch
alle lokalen Variablen und evtl. Funktionsergebnisse aufnimmt.

Beispiel für Rekursion:

Ein Beispiel für die Verwendung einer rekursiven Programmierung ist die Berechnung der Fakultät
einer Zahl. Die Fakultät ist das Produkt aller ganzen Zahlen von 1 bis zu dieser Zahl. Die Fakultät von
4 ist also 1 · 2 · 3 · 4 = 24.

Mathematiker definieren die Fakultät meistens so (rekursive Definition):

• Die Fakultät der Zahl 0 ist definitionsgemäß 1.


• Die Fakultät einer ganzen Zahl, die größer als Null ist, ist das Produkt dieser Zahl mit der Fakultät
der nächstkleineren ganzen Zahl.

Die Definition funktioniert so:


• Will man die Fakultät von 4 berechnen, so muss man zunächst die Fakultät von 3 berechnen
und das Ergebnis mit 4 multiplizieren.
o Will man die Fakultät von 3 berechnen, so muss man zunächst die Fakultät von 2
berechnen und das Ergebnis mit 3 multiplizieren.
§ Will man die Fakultät von 2 berechnen, so muss man zunächst die Fakultät von 1
berechnen und das Ergebnis mit 2 multiplizieren.
• Will man die Fakultät von 1 berechnen, so muss man zunächst die
Fakultät von 0 berechnen und das Ergebnis mit 1 multiplizieren.

o Die Fakultät von 0 ist nach Definition 1. Abbruch

• Die Fakultät von 1 ist also 1*1=1


§ Die Fakultät von 2 ist also 2*1=2
o Die Fakultät von 3 ist also 3*2=6
• Die Fakultät von 4 ist also 4*6=24

Allgemein wird eine Rekursion unterteilt in den Hinweg, den Abbruchfall und den Rückweg.

Quelltext:

Man definiert eine Funktion fac, die


einen Wert zahl als Eingabewert
bekommt. Diese Funktion multipliziert
zahl mit dem Rückgabewert von
fac(zahl-1) außer zahl=0, dann liefert
die Funktion das Ergebnis 1
(Abbruchbedingung).

Mit dem Startwert zahl = 4 würde der Computer rechnen: fac(4*fac(3*fac(2*fac(1)))) heraus kommt
dann das richtige Ergebnis, nämlich 24.

35/49
www.pdfmailer.de
B
Boorrllaanndd D
Deellpphhii

Rekursive Programme haben in der Regel keine gute Performance. Durch die wiederholten
Funktionsaufrufe wird immer wieder derselbe Methodeneintrittscode bearbeitet und jedes Mal der
Kontext gesichert, was zu hohem Arbeitsspeicherverbrauch führt. Alle rekursiven Algorithmen lassen
sich jedoch auch durch iterative Programmierung implementieren (und umgekehrt).
Hierbei gilt die Regel, dass für einfache Probleme eine iterative Implementierung häufig effizienter ist.
So sollte z. B. auch die Fakultätsfunktion der Effizienz wegen in der Praxis iterativ implementiert
werden. Bei komplizierten Problemstellungen (z. B. Aufgaben mit Bäumen) hingegen lohnt sich
oftmals der Einsatz einer rekursiven Lösung, da für solche Probleme eine iterative Formulierung
schnell sehr unübersichtlich werden kann.

Iterative Implementierung:

36/49
B
Boorrllaanndd D
Deellpphhii

Felder –ARRAYs

Ein ARRAY ist eine geordnete Menge gleichartiger Datentypen.


Es gibt bestimmte Operationen, die mit geordneten Mengen vorgenommen werden können. Dazu
gehört der Zugriff auf ein bestimmtes Element, das Suchen nach einem bestimmten Element und das
Einfügen und Löschen von Elementen. Eine weitere Operation ist das Sortieren, der Sortiervorgang
besteht aus einer bestimmten Menge von Lösch- und Einfügeoperationen.

Arrays sind dadurch gekennzeichnet, dass die Elemente über einen bestimmten Index angesprochen
werden. Die Elemente liegen hintereinander im Speicher. Arrays können sowohl statisch, d. h. sie
können ihre Größe nicht ändern, als auch dynamisch sein, d .h. ihre Größe wird während der Laufzeit
beeinflusst.

Es gibt ein-, zwei- und mehrdimensionale Felder.

Syntax: var feld: array [0..9] of integer; // statisch //

Dieser Ausdruck erzeugt eine Gruppe von 10 Elementen. Man spricht sie mit feld[0] bis feld[9] an. Die
Nummer des angesprochenen Elementes wird in eckige Klammern gesetzt.
In der Regel trägt das erste Element den Index 0.

feld[0] feld[1] feld[2] feld[3] feld[4] feld[5] feld[6] feld[7] feld[8] feld[9]

Das Belegen der einzelnen Feldelemente erfolgt über Wertzuweisungen wie z. B.

feld[1]:= 7;

oder über eine for-Schleife: for i:= 0 to 9 do


feld[i]:= 2*i;

Mit dieser Schleife wird das Array mit den ersten 10 geraden Zahlen gefüllt.

Syntax: var felddyn: array of real; // dynamisch //

felddyn ist jetzt ein eindimensionales dynamisches Array. Bei der Deklaration wird jetzt kein
Speicherplatz, d. h. keine Länge zugewiesen. Dies muss später mit SetLength geschehen.

Beispiel: SetLength(felddyn, 10);

laenge:= Memo1.Lines.Count;
SetLength(felddyn, laenge);

Auch hier kann jedes Element über eine for-Schleife angesprochen werden. Da die Länge muss
während der Laufzeit dynamisch ermittelt werden. Dies geschieht mit low für das erste Element und
high für das letzte Element.

Beispiel:

Das Array wird mit den


Quadratzahlen von 0 bis 9 gefüllt.

37/49
B
Boorrllaanndd D
Deellpphhii

Es natürlich auch möglich mehrdimensionale dynamische Arrays zu erzeugen. Die Deklaration würde
wie folgt aussehen:

Beispiel: var feld2Ddyn: array of array of integer;

Auch hier muss die Länge wieder dynamisch mit SetLength festgelegt werden. Die Länge muss
allerdings für jede Dimension getrennt ermittelt werden!

Soll die zweite Dimension eines jeden Elements gleich groß sein, empfiehlt sich wieder eine Schleife.
Im folgenden Beispiel wird ein zweidimensionales 10 x 5 Felder großes Array erzeugt.

Beispiel:

Statische Felder können über folgende Deklaration festgelegt werden.

Beispiel: var feld2Dsta: array [0..9,0..4] of integer;

38/49
www.pdfmailer.de
B
Boorrllaanndd D
Deellpphhii

Records

Records entsprechen von der Struktur her dem Datensatz einer Datenbank (aber nur zur Laufzeit
vorhanden). Wenn unterschiedliche Daten vorhanden sind, die logisch aber zusammengehören,
können sie Sinnvollerweise zu einem Record zusammengefasst werden.

Beispiel: Adressdatenbank

Die Variable adresse ist unterteilt in


drei Untervariablen (name, plz,ort)

Der Zugriff auf die einzelnen


Variablen erfolgt wie im Bsp.

Damit Schreibarbeit gespart werden


kann, ist eine Benutzung der with-
Anweisung empfehlenswert.

Eigene Typdefinitionen

Neben den bisher bekannten


Datentypen (integer, real, array,
usw.) können auch eigene Typen
erzeugt werden (z. B. für das obige
Beispiel Adressdatenbank).

Eine Typdefinition besteht aus dem


Schlüsselwort type gefolgt von einer
deklaration, die einer
Variablenvereinbarung ähnelt. Da
aber statt einer Variablen ein Typ
deklariert wird, ist das Folgende
auch kein Variablen- sondern ein
Typname. Typnamen sollten mit
einem großen T beginnen, um auf
einen Typ hinzuweisen.
Statt eines Doppelpunkts muss ein
Gleichheitszeichen verwendet werden.

Der Zugriff erfolgt nach den Regeln für arrays und records.

39/49
BBoorrllaanndd D
Deellpphhii

Objektorientierte Programmierung – Ein erster Zugang

Delphi ist nicht nur eine Entwicklungsumgebung für Pascal, sondern stellt dem Programmierer eine
objektorientierte Umgebung in Form von Libraries und einigen Spracherweiterungen ('Object-Pascal')
zur Verfügung.

Betrachtet man den Object Inspector, so sieht man dass er in zwei Bereiche gegliedert ist, die man
durch einen Reiter umschalten kann - "Properties" und "Events". Im Bereich "Properties" lassen sich
Eigenschaften von Programmkomponenten (wie z.B. Knöpfe) modifizieren, der Bereich "Events" ist für
Ereignisse zuständig, die während des Programmlaufs auftreten können (z.B. wenn der linke
Mausknopf gedrückt wird).

Eigenschaften

Die objektorientierte Programmierung geht von einem Modell aus, das sich sehr an die reale Welt
anlehnt und indem die Daten und nicht so sehr die Vorgänge und Prozesse im Vordergrund stehen.
Das bedeutet dass man reale oder abstrakte Objekte in der Programmiersprache abbildet. Diese
Objekte haben Eigenschaften (properties),
können auf Ereignisse (events) reagieren und
haben meist auch Möglichkeiten, sich selbst
oder andere zu modifizieren oder zu
beeinflussen (methods).

Genau so wie Eigenschaften in der realen Welt


Aussehen und Verhaltensweisen von Objekten
charakterisieren, genau so funktioniert das auch
in Object-Pascal. Über Eigenschaften lassen sich
die Größen, Form, Farben, Beschriftung,
Verhalten, etc. von Komponenten einstellen.

Platzieren Sie probeweise einfach einen Knopf


(Komponente TButton) auf dem Formular und
selektieren Sie ihn mit der Maus. Die
Eigenschaften des Knopfes werden nun im
Object Inspector angezeigt. Verändern Sie im
Object Inspector z.B. die Eigenschaft 'Caption'
indem Sie auf der rechten Hälfte des Object
Inspectors in der Zeile Caption einen Text
eingeben. Sie sehen, dass sich die Beschriftung
des Knopfes ändert.

Hinweis: Die Properties 'Name' und 'Caption'


werden von Anfängern oft verwechselt. Die
Property 'Caption' ist die Beschriftung während
'Name' den Namen der Komponente beschreibt
mit dem die Komponente im Programmcode
angesprochen werden kann

Bei den Eigenschaften unterscheidet man zwei


Arten: Design-Time Properties und Run-Time- Die Properties der Komponente TButton.
Properties. Die erste Art wird im Object
Inspector angezeigt, die zweite nicht. Solche Properties können - wie der Name sagt - nur zur Laufzeit
des Programms benützt werden (sind aber sonst gleichwertig).

40/49
BBoorrllaanndd D
Deellpphhii

Ereignisse

Hätte man nur die Möglichkeit Eigenschaften von Komponenten im Programm zu verändern, so wären
die meisten Programme ziemlich unnütz, da das Programm nur einen fixen Ablauf haben kann und nur
durch Abfragen Parameter von außen bekommen würde. Diese andauernde Abfrage, ob neue
Parameter gelten, würde das Programm ziemlich lähmen. Object-Pascal (wie jede andere
Programmiersprache auch) muss deshalb auf externe Ereignisse reagieren können, und zwar ohne
andauerndes Abfragen.

Dies wird durch sogenannte Events erreicht. Typische Events sind z.B. ein Tastendruck, oder ein
Mausklick. Grundsätzlich werden Events vom Betriebssystem einer bestimmten Komponente
zugeordnet, so dass nur die betroffene Komponente von diesem Event "erfährt". Man sagt auch: "ein
Event ausgelöst wird". Es ist die Aufgabe des Programmierers auf diese Events zu reagieren. Jede
Komponente hat in Delphi unterschiedliche
Events, viele Arten sind aber in allen
Komponenten gleich. Ein OnClick-Event gibt es
deshalb bei fast jeder Komponente und wird
durch einen Mausklick auf die Komponente
ausgelöst.

Events können aber nicht nur durch


Benutzeraktionen ausgelöst werden, sondern
auch durch interne Vorgänge. Dadurch
signalisiert das Programm bestimmte
Zustände. Ein Beispiel eines solchen Events
wäre der Event 'OnShow', der ausgelöst wird
unmittelbar bevor ein Formular auf dem
Bildschirm dargestellt wird. Auf diese Weise
kann man quasi noch in letzter Sekunde das
anzuzeigende Formular ändern.

Per Default (also am Anfang in 'jungfräulichem


Zustand') sind alle Events einer Komponente
leer - es passiert einfach nichts.

Die Ereignisse, die eine Komponente zur Verfügung


stellt, findet man im Object Inspector unter dem Reiter
"Events". Auf der linken Seite sind alle unterstützten
Ereignisse aufgezählt (hier ein Knopf TButton), auf der
rechten Seite wird die entsprechende Routine ('event
handler') eingetragen. Zu Beginn sind alle Eventhandler
undefiniert, die entsprechenden Einträge sind leer.

41/49
BBoorrllaanndd D
Deellpphhii

Wichtige Eigenschaften von Komponenten

Anchors Ankerpunkte, an denen die Komponente bei Größenänderungen des Formulars verankert wird.

Caption Beschriftung einer Komponente (z. B. einer Schaltfläche), die nicht geändert werden kann.

Color Farbe einer Komponente.

Enabled Die Komponente kann Maus- und Tastaturereignisse verarbeiten.

Font Verwendete Schriftart der Komponente.

Height Höhe der Komponente in Pixeln.

Hinweistext, der angezeigt wird, wenn die Eigenschaft ShowHint den Wert True besitzt und die Maus bei der
Hint Programmausführung über die Komponente bewegt wird.

Left Linke Position der Komponente in Pixeln.

Name Über diesen Namen wird die Komponente bei der Programmierung angesprochen.

ShowHint Bei der Auswahl True wird der Text der Eigenschaft Hint angezeigt.

Text Ein änderbarer Standardtext, den die Komponente anzeigt (z. B. eine Edit-Komponente).

Top Obere Position der Komponente in Pixeln.

Visible Legt fest, ob die Komponente zur Programmausführung sichtbar sein soll (True) oder nicht (False).

Width Breite der Komponente in Pixeln.

Diese Eigenschaften stellen lediglich eine geringe


Auswahl dar. Nicht jede Komponente besitzt alle
diese Eigenschaften, bzw. viele Komponenten
besitzen wesentlich mehr.
Wenn die Eigenschaft Name einer Komponente
geändert wird, ist das der neue Name, der die
Komponente künftig bezeichnet, z. B. während der
Programmierung.

42/49
BBoorrllaanndd D
Deellpphhii

Wichtige Ereignisse, die bei Komponenten auftreten können

OnActivate Ein Formular wurde aktiviert.

Es wurde ein linker Mausklick auf die Komponente durchgeführt oder die Komponente anderweitig
OnClick ausgewählt, z. B. über eine Tastenkombination.

OnClose Ein Formular wurde geschlossen.

OnCreate Die Komponente wurde erzeugt.

OnKeyPress Eine Taste wurde betätigt, während die Komponente ausgewählt war.

OnMouseDown Die rechte, linke oder mittlere Maustaste wurde auf der Komponente geklickt.

OnPaint Die Komponente soll sich neu zeichnen, z. B. wenn sie verdeckt war.

OnShow Tritt ein, bevor ein Formular angezeigt, d. h. sichtbar gemacht wird.

Auf Eigenschaften von Komponenten zur Programmausführung zugreifen

Der Zugriff auf Eigenschaften von Komponenten während der Laufzeit des Programms erfolgt über
den Namen der Komponente, welchem der Name der Eigenschaft, getrennt durch einen Punkt folgt.

Der Name einer Komponente sei btnClose, und die Eigenschaften, auf die zugegriffen werden soll, sei
Name und Color. In diesem Fall muss die folgende Schreibweise für den Zugriff auf die
Komponenteneigenschaften während der Laufzeit des Programms verwendet werden:

btnClose.Name …
btnClose.Color …

Anmerkung: Der Name der Komponente muss nicht zwangsläufig geändert werden, z. B. Button1 btnClose.
Oftmals empfiehlt es sich die Namen so zu belassen, wie sie von Delphi vorgegeben werden.

Die Objekthierarchie (Struktur)

Das Fenster Objekt-Hierarchie (Struktur) zeigt die Zugehörigkeit der Komponenten in einem Formular.
Die Komponente Button1 wird beispielsweise
innerhalb der Komponente Panel1 angezeigt.
Wird die Komponente Panel1 verschoben,
werden auch die darin befindlichen
Komponenten Button1 und Button2 verschoben.
Die Komponente Panel1 dient also als so
genannter Container. Man kann eine
Komponente nur innerhalb ihres Containers
verschieben.

Durch einfaches Anklicken der Komponente in


der Struktur werden die Komponenten im
Formular ausgewählt. Über einen Doppelklick
bewegt man sich im Quelltexteditor zu dieser
Komponente.

43/49
BBoorrllaanndd D
Deellpphhii

Instanzen von Komponenten

Beim Einfügen einer Komponente, z. B. einer Schaltfläche, wird eine so genannte Instanzvariable in
den Programmquelltext eingefügt. Die neue Komponente mit Namen
Button1 basiert auf der Komponente TButton, d. h. TButton fungiert als type
Schablone. TForm1 = class(TForm)
Wenn eine Komponente in ein Formular eingefügt wird, erzeugt Delphi Button1: TButton;
automatisch einen Namen für diese Komponente. Der Name setzt sich Button2: TButton;
aus dem Namen der Komponente sowie einer fortlaufenden Button3: TButton;
Nummerierung zusammen, z. B. Button1, Button2, Button3, … für die …
Komponente Button. Der Name kann dann nachträglich im
Objektinspektor in der Eigenschaft Name geändert werden (s. o.).
Die Komponenten haben alle einen bestimmten Typ, wie z. B. die Komponente TButton. Dass sie
einen Typ darstellen, wird durch das Voransetzen des Buchstabens T zum Ausdruck gebracht.

Achtung: Der Bereich, in dem Delphi automatisch Instanzen von Komponenten oder die Deklaration von
Ereignisbehandlungsroutinen einträgt, darf nicht selbständig verändert werden!

Standardkomponenten

In Frames können mehrere Komponenten zusammengefasst und in anderen


Frames Formularen wieder verwendet werden.
Diese Komponente fügt eine Menüleiste in ein Formular ein. Ein Formular kann
TMainMenu mehrere Menükomponenten besitzen, die dann über die Eigenschaft Menu des
Formulars ausgewählt werden können.
Ein Popup-Menü wird häufig als Kontextmenü verwendet, das durch Klicken mit der
TPopupMenu rechten Maustaste angezeigt wird.
Ein Label (Bezeichner) dient der Anzeige von statischem Text, den der Anwender
TLabel nicht ändern kann.
Über Eingabefelder werden Benutzerein- und –ausgaben realisiert, die nur eine Zeile
TEdit benötigen. Verwenden Sie die Eigenschaft Text für die Textein- und –ausgabe.
Ein Memofeld ist ein größeres Textfeld, wie z. B. der Editor Notepad, das mehrere
TMemo Textzeilen verwalten kann. Auf den Text greift man zeilenweise über die Eigenschaft
Lines oder auf den gesamten Text über die Eigenschaft Text zu.
Über Schaltflächen kann der Anwender das Programm steuern, indem er durch das
TButton Betätigen der Schaltfläche eine Aktion auslöst.
Checkboxen dienen als Markierungsfelder, beispielsweise für das Festlegen von
TCheckBox Einstellungen, die an- bzw. ausgeschaltet werden können. Checkboxen setzt man
ein, wenn man sich auf genau einen Zustand bezieht.
Optionsfelder treten im Allgemeinen in Gruppen auf. Dabei wird von mehreren
Möglichkeiten genau eine bzw. keine gewählt, d. h., die Optionen schließen sich
TRadioButton gegenseitig aus. Verwenden Sie Optionsfelder, wenn Sie aus mehreren Einstellungen
nur eine auswählen können.
Listenfelder dienen zum Auflisten von Informationen und können sortiert werden. Die
TListBox Einträge der Listbox können während der Programmausführung nicht bearbeitet
werden. Auf die Einträge einer Listbox greift man über die Eigenschaft Items zu.
Eine Kombinationsbox stellt eine Verbindung aus einer ListBox und einem
Eingabefeld dar. Das Eingabefeld wird über einen Pfeil aufgeklappt und erscheint nun
TComboBox wie eine Listbox. Die Kombinationsbox wird Platz sparend angezeigt, und ihre
Einträge können bearbeitet werden.
Bildlaufleisten dienen zum Blättern oder Scrollen bei längeren Ausgaben, die in einem
TScrollBar Fenster nicht angezeigt werden können.
Die Gruppenbox dient als visuelle Zusammenfassung von Teilen eines Fensters.
TGroupBox Dabei wird ein Rahmen um die jeweiligen Elemente gezogen und eine Beschriftung
eingefügt.
Eine Optionsgruppe arbeitet wie eine Gruppenbox, jedoch mit der zusätzlichen
Eigenschaft, dass bei mehreren eingefügten Optionsfeldern automatisch immer nur
TRadioGroup ein Feld ausgewählt warden kann. Zugegriffen wird über die Eigenschaften Items
und ItemIndex
Dekorationen sind Erhöhungen und Vertiefungen von Teilen eines Fensters, um
TPanel bestimmte Teile optisch hervorzuheben.
Die ActionList dient zur Zentralen Verwaltung von Aktionen
(Ereignisbehandlungsroutinen). Einige Komponenten besitzen eine Eigenschaft Action
TActionList für ihr Standardereignis, mit der Sie dieses Ereignis mit einer Aktion der ActionList
verknüpfen können.

44/49
BBoorrllaanndd D
Deellpphhii

Zusatzkomponenten

Entspricht einer einfachen Schaltfläche, der jedoch zusätzlich eine Grafik über den
TBitBtn Objektinspektor zugeordnet werden kann. Verwenden Sie dazu die Eigenschaft Kind.
Mit der maskierten Eingabe kann die Ein- und Ausgabe von Daten, z. B. von
TMaskEdit Zahlenwerten, formatiert und kontrolliert werden.
Diese Komponente kann Text in Tabellenform darstellen. Auf die einzelnen Felder
TStringGrid kann über die Eigenschaft Cells zugegriffen werden.
Diese Komopnente kann Grafikenim *.ico-, *.bmp-, *.emf-, *.jpg-, *.jepg- und
TImage *.wmf-Format anzeigen. Laden Sie die Grafik über die Eigenschaft Picture.
Hiermit lassen sich Rechtecke, Ellipsen und abgerundete Rechtecke darstellen.
TShape Ändern Sie dazu die Eigenschaft Shape.

45/49
BBoorrllaanndd D
Deellpphhii

Grafikausgabe

Es gibt verschiedene Möglichkeiten der Grafikausgabe. Man kann bereits vorhandene Bilder über
Komponenten anzeigen und bearbeiten. Einige Komponenten können geometrische
Standardelemente, wie Ellipsen, Rechtecke und Linien, anzeigen, und es kann zur Laufzeit eines
Programms über die von Delphi und Windows bereitgestellten Funktionen zur Grafikausgabe
gezeichnet werden. Die einfachste Lösung, ein Bild in einem Delphi-Programm anzuzeigen, bietet die
Image-Komponente, die sich im Register Zusätzlich der Komponentenleiste befindet.

Standardgrafikobjekte

Die Shape-Komponente kann geometrische


Standardobjekte, wie Rechtecke und Kreise,
darstellen. Die Komponente besitzt eine
gleichnamige Eigenschaft Shape, über die das
jeweilige geometrische Objekt eingestellt wird.
Es können Farbe, Füllmuster und Stift
eingestellt werden (Pen, Brush).

Shapes dienen der grafischen Aufwertung


eines Formulars.

Wenn mehrere Shape-Komponenten in einem


Formular übereinander platziert sind, verdeckt
die zuletzt eingefügte die vorherigen
Komponenten. Über das Kontextmenü der
einzelnen Komponenten kann das Element nach vorne bzw. nach hinten gesetzt werden.

Koordinatensystem (Windows)

Windows verwendet ein Koordinatensystem mit dem Ursprung in der oberen linken Ecke, beginnend
mit 0, 0. Die Maßeinheit auf dem Bildschirm ist ein Bildpunkt (Pixel).
X

Y 0, 0 1024, 0

0, 768 1024, 768 Bsp. für Koordinatensystem

Unter Windows heißt ein Ausgabebereich Gerätekontext. Ein Gerätekontext wird immer für ein
bestimmtes Gerät (Bildschirm, Drucker) angelegt. Über diesen Kontext können dann
Zeichenoperationen durchgeführt werden. Zu beachten ist dabei, dass zwar die Ausgabefunktionen
identisch sind, diese aber unterschiedliche Koordinatensysteme verwenden können.

Grafik unter Delphi

In Delphi besitzen die Komponenten die Eigenschaft Canvas (Leinwand), über die Grafikausgaben
realisiert werden können. Bei einem Formular zeichnet man über das Canvas z. B. auf den
Formularinhalt. Um zu zeichnen, braucht man keine weiteren Einstellungen vorzunehmen. Ein Canvas
beherrscht die wichtigsten Funktionen der Grafikausgabe, die Windows durch das GUI (Graphical User
Interface – Grafische Benutzerschnittstelle) zur Verfügung stellt.

46/49
BBoorrllaanndd D
Deellpphhii

Achtung: Auf die Leinwand einer Komponente kann nur zur Laufzeit eines Programms zugegriffen werden. Der
Eigenschaft Canvas kann nichts zugewiesen werden; sie ist eine Nur-Lese-Eigenschaft. Folgende Zuweisung
ist z. B. nicht möglich: Form1.Canvas := Form2.Canvas;

Die Leinwand (Canvas)

Die Eigenschaft Canvas besitzt Zeichenfunktionen, mit denen man sofort zeichnen kann. Im Gegensatz
zu den normalen Windows-Funktionen benötigt man keine Initialisierungen und keine Funktionen zum
Beenden der Grafikausgabe. Die Untereigenschaften von Canvas besitzen eine Standardinitialisierung.

Brush Diese Eigenschaft legt das Füllmuster fest, wie es z. B. bei Methoden wie RectAngle angewendet wird.

Font Festlegung der Schriftart bei Textausgaben.

Pen Festlegung des Zeichenstiftes beim Zeichnen von Linien und Umrahmungen.

Bestimmt die aktuelle Position des Zeichenstiftes. Die Position kann über die Methode MoveTo verändert
PenPos werden.

Pixels Über diese Eigenschaft kann jeder einzelne Bildpunkt des Bildschirmes bearbeitet werden.

Die Leinwand besitzt mehrere Methoden, die über Canvas.Methode(Parameter); aufgerufen


werden. Die Parameter X1 und Y1 stellen den Startpunkt, X2 und Y2 den Endpunkt bei allen
Zeichenfunktionen dar.

Methode Beschreibung Parameter Beispiel

RectAngle Zeichnet ein gefülltes Rechteck. X1, Y1, X2, Y2 RectAngle (10, 10, 100, 100);

Ellipse Zeichnet Kreise und Ellipsen X1, Y1, X2, Y2 Ellipse (10, 10, 100, 100);

MoveTo Setzt den Startpunkt des Stiftes X, Y MoveTo (10, 10);

Zieht eine Linie, die beim aktuellen Startpunkt beginnt


LineTo und bei dem als Parameter angegebenen Wert endet.
X, Y LineTo (100, 100);

Setzt einen Bildpunkt in der angegebenen Farbe an die


Pixels entsprechende Koordinate.
X, Y Pixels [10, 10] := clRed;

Der Zeichenstift

Der Zeichenstift (Pen) der Leinwand dient zum


Zeichnen von Linien und Rändern
geometrischer Objekte. Seine Darstellung wird
über die vier Eigenschaften Color, Mode, Style
und Width beeinflusst.

Wichtige Eigenschaften:

Color Legt die Zeichenfarbe des Stiftes fest.

Legt die Verknüpfung der Linie mit dem Hintergrund fest. Wird z. B. der Modus transparent eingestellt, bleibt
Mode der Hintergrund bei gestrichelten Linien erhalten.
Durch den Stil kann ein bestimmter Linientyp ausgewählt werden. Alle Typen außer psSolid können nur mit
Style einer Breite von einem Punkt gezeichnet werden.

Width Legt die Breite des Stiftes in Pixeln fest.

47/49
BBoorrllaanndd D
Deellpphhii

Programm zum obigen Formularbeispiel:

Mithilfe der with-Anweisung wird auf die


Eigenschaften von Canvas direkt
zugegriffen, statt in jeder Zeile
Canvas.Methode zu schreiben.

Der Pinsel (Brush)

Der Pinsel legt das Aussehen und die Farbe des Füllmusters fest (z. B. zum Füllen von Rechtecken
oder des Formularhintergrundes). Eigene Bitmaps können als Füllmuster verwendet werden. Diese
müssen eine Größe von 8 x 8 Pixeln besitzen.

Wichtige Eigenschaften:

Bitmap Mittels einer 8 x 8 großen Bitmap kann


das Füllmuster festgelegt werden.
Color Farbe für das Füllmuster, wenn kein
Bitmap verwendet wurde.
Style Legt den Typ fest, z. B. Diagonallinien
oder ein Kreuzmuster.

48/49
BBoorrllaanndd D
Deellpphhii

Farben

Windows verwaltet die Farben über ein RGB-Modell (Rot-Grün-Blau), d. h. alle Farben setzen sich aus
einer Kombination dieser Farben zusammen. Über die Funktion RGB kann eine Farbe ausgewählt
werden, indem drei Zahlenwerte im Bereich von 0..255 übergeben werden.
Ein Farbwert besteht aus 4 Bytes. Das erste Byte gibt die verwendete Palette an, die restlichen stehen
für die drei Farbwerte.

Hier Beispiele für die Farbzuweisung einer Schriftart:

Font.Color := $00FF0000; // Blau


Font.Color := $0000FF00; // Grün
Font.Color := $000000FF; // Rot

Eine weitere Möglichkeit, eine Farbe auszuwählen, besteht in der Zuweisung der Farbe über eine
Farbauswahl in der ColorDialog-Komponente.

Font.Color := RGB(255, 55, 5);


// oder
Font.Color := ColorDialog.Color;

Delphi besitzt zahlreiche vordefinierte Farben, die mit dem Kürzel cl beginnen. Weitere Konstanten
befinden sich in der Unit Graphics.

clRed Rot clBlack Schwarz clGreen Grün

clBlue Blau clGray Grau clSilver Silbergrau

Farbe, die in der Systemsteuerung


clWhite Weiß clYellow Gelb clWindow für den Fensterinhalt eingestellt ist.

49/49

Das könnte Ihnen auch gefallen