Embed Size (px)
Citation preview
Delphi
Informatik-AG
Übersicht • Pascal Syntax
• Konstanten
• Variablen
• Typen
• Prozeduren/Funktionen
• Schleifen
• Verzweigungen
Grundlegende Pascal-Syntax
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
Strichpunkte
Jeder Pascal-Befehl 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.
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
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.
Grundlegende Pascal-Syntax
Kommentare
In vielen Fällen möchte man sich im Programmcode Notizen machen.
Grundsätzlich erlaubt Delphi drei 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
Program Test;
begin
// Das wird ein Programm
{ Mehrer Zeilen können über die geschweiften Klammern
als Kommentare gekennzeichnet werden }
(* alternativ ist auch diese Schreibweise möglich *)
Grundlegende Pascal-Syntax
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):
Program/Function/Procedure
// Declarationen (Type, Const,Var)
begin
end;
Grundlegende Pascal-Syntax
Deklaration von Konstanten
Nach dem Programm- bzw. Unterprogrammnamen folgt die Definition der verwendeten
Konstanten, die mit dem Schlüsselwort const eingeleitet wird. Der Bereich der
Konstantendeklaration gilt so lange bis ein anderer Bereich definiert wird (z.B. die Deklaration der
Variablen) oder der (Unter-)Programmkörper beginnt. Konstanten werden formal folgendermaßen
deklariert:
Name = Konstante;
Als Konstante können beliebige einfache Datentypen verwendet werden. Für zusammengesetzte
Konstanten (wie z.B. Records gelten etwas andere Regeln).
Für die Konstantendefinition haben sich zwei Stilregeln eingebürgert, die die Lesbarkeit eines
Programms stark verbessern: 1) Pro Konstante wird eine Programmzeile verwendet. 2) Die
Bezeichner der Konstanten werden mit Großbuchstaben geschrieben. Damit kann man an
beliebigen Stellen des Programms immer erkennen, ob ein Bezeichner einer Konstanten
entspricht oder einer Variablen.
Beispiel: const NAME = 'Lohninger';
MAX_MONTH = 12; // Höchster Monat
SPEC_LENGTH = 512; // Länge der Spec
Grundlegende Pascal-Syntax
Warum überhaupt Konstanten?
Betrachtet man Konstanten aus logischer Sicht, so sind sie überflüssig, da man jedes Vorkommen
einer Konstanten im Programmcode durch ihren Wert ersetzen kann. Allerdings haben Konstanten
folgende Vorteile:
Verbesserung der Wartungsfreundlichkeit eines Programms: Muss ein konstanter Wert geändert
werden, so reicht bei Verwendung von Konstanten die Modifikation einer einzigen
Konstantendefinition.
Verbesserung der Lesbarkeit: Der Bezeichner MAX_LENGTH sagt einfach mehr aus als etwa die
anonyme Zahl 150.
Bessere Gliederung: Die Definition der Konstanten stehen an wohldefinierter Stelle und sind
deshalb leichter zu finden. Eventuell erzeugt man sogar eine eigene Unit, in der alle globalen
Konstanten (und Typen und Variablen) definiert sind.
Datentypen
• Pascal ist eine streng typisierte Sprache. Darunter versteht man eine Sprache, bei der der Programmierer gezwungen wird, die einzelnen Datentypen zu deklarieren und die Verwendung dieser Typen nur typgerecht durchzuführen. Damit kann man z.B. das Alter eines Werkstücks nicht zur Bezeichnung des Werkstücks addieren (auch wenn das Werkstück als Bezeichnung eine Nummer trägt).
• Pascal unterstützt einige vordefinierte, einfache Datentypen, die im Folgenden beschrieben werden:
• ganze Zahlen: integer, word, byte, longint, shortint, cardinal, smallint, int64
• Gleitkommazahlen: single, double, extended • logische Typen: boolean • Zeichen und Zeichenketten: char, string
Ganze Zahlen
Eigentlich gibt es ja (zumindest in der Mathematik) nur einen Typ von ganzen Zahlen; trotzdem bieten die meisten Programmiersprachen unterschiedliche Ganzzahltypen an, die sich im Wertebereich den sie abdecken unterscheiden. Der Grund dafür liegt darin, dass eine Zahl, die einen kleineren Wertebereich abdeckt auch weniger Speicherplatz verbraucht. Allerdings sind einige Typen gleich und eine Unterscheidung ist nur historisch gesehen gerechtfertigt. Die folgende Tabelle gibt einen Überblick zu den ganzzahligen Datentypen.
In der Praxis verwendet man meist nur byte, word, integer und int64.
Typ Bereich Speicherbedar
f (Byte)
Byte 0 bis 255 1
Word 0 bis 65535 2
Shortint -128 bis 127 1
Smallint -32768 bis
32767
2
Integer -2147483648
bis
2147483647
4
Longint -2147483648
bis
2147483647
4
Cardinal 0 bis
4294967295
4
Longword 0 bis
4294967295
4
Int64 -2^63 bis
2^63-1
8
Gleitkommazahlen
Gleitkommazahlen können reelle Zahlen mit einer bestimmten Präzision und innerhalb eines bestimmten Wertebereichs darstellen. Die folgende Tabelle gibt einen Überblick dazu:
Typ Bereich Präzision Speicherbedarf
(Byte)
Single 1.5*10^-45 .. 3.4*10^38 7 4
Double 5.0*10^-324 .. 1.7*10^308 15 8
Extended 3.6*10^-4951 .. 1.1*10^4932 19 10
Boolean (logischer Datentyp)
Der Boole'sche Datentyp kennt nur zwei Werte, nämlich true (wahr) und false (falsch). Im Rechner werden die beiden Werte als 1 und 0 gespeichert.
Zeichen und Zeichenketten
Zeichen werden in Pascal als ‚Char‘ bezeichnet. Eine Variable vom Typ Char kann genau 1 Zeichen aufnehmen.
Mehrere Zeichen werden in Variablen des Typs String gespeichert. In Delphi kann ein String etwa 2 Milliarden Zeichen lang sein.
VariablenVariable sind eines der zentralen Elemente jeder Programmiersprache. Sie sind als "Datencontainer" aufzufassen, die man benützt um z.B. Ergebnisse zwischenzuspeichern.
Die Einsatzmöglichkeiten von Variablen sind so vielfältig, dass an dieser Stelle nur auf die grundlegenden Aspekte eingegangen werden kann.
Deklaration von Variablen
Variable kann man nach ihrem Geltungsbereich in globale und lokale Variable unterscheiden. Die Deklaration ist für beide Arten syntaktisch gleich, allerdings wird man lokale Variable anders einsetzen als globale. Die Deklaration von einer oder mehreren Variablen erfolgt immer außerhalb des eigentlichen Programmcodes (der durch ein begin-end-Paar eingeklammert ist) und wird mit dem Schlüsselwort var eingeleitet. Die Syntax einer Variablendeklaration sieht folgendermaßen aus:
Name : Typ;Der Name einer Variablen kann beliebig gewählt werden, er darf sich nur nicht mit den von Pascal reservierten Wörtern decken. Nach dem Namen steht der Typ der Variable, abgeschlossen durch einen Strichpunkt. Man darf Variable des gleichen Typs auch durch Beistriche getrennt in einem Statement deklarieren.
Beispiel: var ShoeSize : integer; Age : double; i, j, k : longint;
VariablenVerwendung von Variablen
Der Einsatz von Variablen im Programmcode ist ziemlich einfach - man verwendet an der passenden Stelle den entsprechenden Namen.
Grundsätzlich dürfen an einer bestimmten Stelle im Programm nur Variable eingesetzt werden, die vom passenden Typ sind - man kann also nicht eine floating point-Variable (z.B. double) einer Boole'schen Variablen (boolean) zuweisen. Allerdings sorgt der Compiler für eine automatische Umwandlung des Variablentyps, falls das sinnvoll und möglich ist (ohne Veränderung des Inhalts der Variablen). Es können also z.B. integer-Variable an floating point-Variable zugewiesen werden, aber nicht umgekehrt. Im ersten Fall wird der Inhalt der Variablen nicht verändert (eine Gleitkommazahl kann ja auch ganzzahlig sein), im zweiten Fall müsste man die Gleitkommazahl zuerst runden, bevor sie der ganzen Zahl zugewiesen werden kann. Die Rundung muss aber vom Programmierer explizit (Funktion round) durchgeführt werden.
Beispiel: var x1 : double;
x2 : integer;
begin
x1 := 3*x2; // das ist erlaubt
x2 := 3*x1; // das ist nicht erlaubt
x2 := round(3*x1); // ist wieder erlaubt
end;
Operatoren
Arithmetische Operatoren
Arithmetische Operatoren verknüpfen zwei Werte (in Form von Konstanten oder Variablen) und liefern das entsprechende Resultat zurück. Wichtig ist, dass der Typ des Ergebnisses von den Eingangstypen und von der Operation abhängt. Für ganzzahlige Berechnungen gibt es zwei spezielle Operatoren, div und mod. Operator Operation Eingangstypen Ergebnistyp
+ Addition ganzzahlig, reell ganzzahlig, reell
- Subtraktion ganzzahlig, reell ganzzahlig, reell
* Multiplikation ganzzahlig, reell ganzzahlig, reell
/ Division ganzzahlig, Reell reell
div Division Ganzzahlig ganzzahlig
mod Rest der Division Ganzzahlig ganzzahlig
Hinweis: Der Plus-Operator (+) hat für Strings noch eine eigene Bedeutung: sind beide
Variablen Zeichenketten, so hängt der +Operator diese zu einem String zusammen
Operatoren
Logische Operatoren
Logische Operatoren verknüpfen eine oder zwei Eingangsvariablen nach den jeweiligen logischen Verknüpfungsregeln.
Sowohl die Eingänge als auch die Ausgänge sind Boole'sche Werte (true oder false).
Hinweis: Logische Operatoren lassen sich auch auf ganze Zahlen anwenden. In diesem Fall werden sämtliche Bits jeweils einzeln der logischen Verknüpfung unterworfen.
Operator Operation
Not true true Negation
fals
e
false
And true False Logisches and
true true false
fals
e
false false
Or true false Logisches or
true true true
fals
e
True false
XOr true false Logisches xor
true Fals
e
true
fals
e
True false
Operatoren
Vergleichsoperatoren
Mit Vergleichsoperatoren können jeweils typ-gleiche Operanden verglichen werden. Als Ergebnis wird ein logischer Wert zurückgeliefert (true oder false). Vergleichsoperatoren können nicht nur auf numerische Werte angewendet werden, sondern auch auf logische Werte und auf Zeichen und Strings. Beim Vergleich von Zeichen wird die zugrundeliegende Codierung als Basis des Vergleichs herangezogen.
Operator Operation
= Gleich
<> Ungleich
< Kleiner
<= Kleiner
gleich
> Größer
>= Größer
gleich
Hinweis: Die Anwendung von '=' und '<>' auf reelle Zahlen ist zwar prinzipiell erlaubt, allerdings kaum sinnvoll, da reelle Zahlen meist Rundungsfehler in der letzten signifikanten Stelle aufweisen. Dies führt dazu, dass ein Vergleich die falschen Ergebnisse liefert. So setzt das Statement test := (0.001*100000 = 100); die boole'sche Variable test nicht auf TRUE, obwohl die beiden Werte mathematisch gesehen gleich sind (der linke Ausdruck 0.001*100000 ergibt bei doppelter Genauigkeit 100.0000000000000021).
Operatoren
Präzedenz (Rangfolge) von Operatoren
Wenn man einen komplizierten arithmetischen oder logischen Ausdruck auswertet, hängt das Ergebnis von der Reihenfolge der Anwendung der einzelnen Operatoren ab. Die Reihenfolge kann man gezielt durch Einsatz von Klammern kontrollieren. Setzt man keine Klammern, so ergibt sich eine Default-Einstellung, die als Operator-Präzedenz bezeichnet wird. Grundsätzlich gilt hier, dass Vorzeichen und Negation vor Multiplikation und Division berechnet werden; diese kommen wiederum vor Addition und Subtraktion, und zum Schluss werden erst die Vergleichsoperatoren ausgewertet.
Persönl. Anmerkung:
Es ist keine Schande und kostet auch keine Rechenzeit, wenn man mehr Klammern als nötig setzt. Ich tendiere dazu, eher mehr Klammern als notwendig zu setzen; dies gilt vor allem für komplizierte logische Ausdrücke, für die ein paar Klammern mehr eventuell Stunden an Fehlersuche ersparen können.
Programmflusskontrolle
Mit diesen fünf Konstrukten
• der Anweisungsblock
• zwei Entscheidungsblöcke
• zwei Schleifentypen
- lässt sich jedes beliebige Programm
schreiben.
Programmflusskontrolle
Anweisungsblock
Der Anweisungsblock dient dazu, mehrere Statements zu einem "Verbund-Statement" zusammen zu hängen. Ein solcher Anweisungsblock wird mit begin eingeleitet und mit end; abgeschlossen. Der gesamte Anweisungsblock verhält sich wie ein einzelnes Statement und kann überall dort wo ein Statement syntaktisch erwartet wird eingegeben werden.
begin
…..
…..
….
end;
Programmflusskontrolle
Zweifachentscheidung
Die Zweifachentscheidung wird immer dann eingesetzt, wenn eine Frage nur zwei sich gegenseitig ausschließende Antworten zulässt. Die entsprechenden Schlüsselworte sind if, then und else. Falls die Bedingung (z.B. ein Vergleich) erfüllt ist, wird der then-Zweig ausgeführt, andernfalls der else-Zweig.
if (Bedingung = true) then
begin
…..
end
else
begin
…..
…..
end;
Programmflusskontrolle
Mehrfachentscheidung
Im Prinzip könnte man Mehrfachverzweigungen, bei denen auf eine Frage mehr als zwei Antworten möglich sind, auch durch Zweifachverzweigungen aufbauen. Allerdings führt das zu unschönen Konstruktionen, die überdies noch schlecht zu lesen sind. Abhilfe schafft hier das case-Konstrukt.
case (Bedingung) of
c1: begin end;
c2: begin end;….
else begin end;end;
Programmflusskontrolle
Schleifen
Schleifen bestehen immer aus zwei
Elementen - dem Schleifenkörper und
dem Abbruchkriterium.
Der Schleifenkörper ist ein
Anweisungsblock.
Als Abbruchkriterium muss ein Ausdruck
verwendet werden, der als Ergebnis
entweder true oder false liefert.
Programmflusskontrolle
Schleife mit Abbruchkriterium am Ende
Bei diesem Typ von Schleife wird der Schleifenkörper zumindest einmal ausgeführt, da das Abbruchkriterium erst am Ende der Schleife überprüft wird. Die Schleife wird mit repeat eingeleitet und wird solange wiederholt bis die Bedingung in der until-Zeile erfüllt ist.
repeat
….
….
until (bedingung = true);
Hinweis:Die repeat-until-Schleife benötigt für den Schleifenkörper keinen Anweisungsblock, es können mehrere Anweisungen ohne Klammer mit begin und end; in die Schleife geschrieben werden.
Programmflusskontrolle
Schleife mit Abbruchkriterium am Anfang
Bei dieser Schleifenart wird zuerst die Überprüfung durchgeführt, ob der Schleifenkörper ausgeführt oder die Schleife verlassen werden soll. Das kann dazu führen, dass der Schleifenkörper eventuell gar nicht ausgeführt wird.
while (bedingung = true) dobegin
….
….
end;
Hinweis:Für den Anfänger ist es meist schwierig zu entscheiden, welcher Typ von Schleife verwendet werden soll. In den meisten Fällen kann das durch die Frage, wie oft der Schleifenkörper mindestens ausgeführt werden muss, entschieden werden. Ist die Antwort 0, so muss man eine while-Schleife einsetzen.
Programmflusskontrolle
Schleife mit Schleifenzähler
Sehr häufig tritt die Notwendigkeit auf, eine bereits zu Beginn bekannte Zahl von Schleifendurchläufen absolvieren zu müssen. Für diesen Spezialfall wurde ein spezielles Schleifenkonstrukt geschaffen, das mehrere Schritte in einem Statement durchführt. Dieses oft auch „for-Schleife“ genanntes Konstrukt erlaubt es, mit einer einzigen Zeile eine Laufvariable ("Schleifenzähler") von einem vorgegebenen Startwert bis zu einem bestimmten Endwert n-mal zu durchlaufen. Nach jedem Durchlauf wird der Schleifenzähler automatisch um 1 erhöht. Der Schleifenzähler muss eine Variable vom Ordinaltyp sein (ganzzahlig oder Aufzählungstyp).
var sz: integer;
…..
for sz := Startwert to Endwert dobegin
…
…
end;
Unterprogramme - Prozeduren und
Funktionen • Professionelles Programmieren bedeutet immer
auch mit möglichst wenig Aufwand den maximalen Erfolg zu erzielen. Eine der Strategien, möglichst hohe Effizienz beim Programmieren zu erzielen, ist der Einsatz von wieder verwendbarem Code.
• Die Idee hinter Unterprogrammen ist einfach: wenn man einen Programmteil so gestaltet, dass dieser nur über eine definierte Schnittstelle benützt werden kann und keine Nebenwirkungen auftreten, so kann dieser Programmcode in verschiedenen Situationen immer wieder aufgerufen werden.
Unterprogramme - Prozeduren und Funktionen
Aus der Sicht des Programmierers gibt es zwei Arten von Unterprogrammen: Prozeduren und Funktionen. Der Unterschied zwischen diesen beiden Arten liegt darin, dass Funktionen einen Rückgabewert haben und Prozeduren keinen. Man kann also Funktionen in Ausdrücke syntaktisch genau so einbauen wie Konstanten. Allerdings liefern diese "Konstanten" keinen konstanten Wert sondern eben den jeweils berechneten Funktionswert.
Die klare Unterscheidung von Prozeduren und Funktionen ist eine Eigenart von Pascal, andere Programmiersprachen kennen nur Funktionen.
Prozeduren
Wie schon erwähnt, haben Prozeduren keinen Rückgabewert - das heißt aber nicht, dass man aus Prozeduren keine dort berechneten Werte zurückgeben kann, sondern nur, dass der Prozedurname nicht wie eine Konstante in den Code eingebaut werden kann. Eine Prozedur weist folgende Struktur auf:
Procedure Name (Parameterliste); Prozedurkopf var lokale variablen ….. begin ….. Prozedurkörperend;
In der Kopfzeile werden der Name der Prozedur und eventuelle Parameter deklariert. Werden keine Parameter übergeben, so lässt man die Klammer einfach weg. Die Übergabe der Parameter kann auf zweierlei Art erfolgen: Entweder als Konstante, oder als Variable. Soll ein Parameter variabel sein, so muss dies durch ein vorgestelltes var-Statement deklariert werden. In diesem Fall kann die Prozedur diesen Wert ändern und die Änderung wird nach außen auch sichtbar. Die Parameterliste entspricht syntaktisch einer normalen Variablendeklaration, es dürfen auch mehrere Variablen gleichen Typs mit Komma getrennt zusammengefasst werden. Fast jedes Unterprogramm benötigt Variablen zur Durchführung der Aufgabe. Hilfsvariablen, die nur während der Ausführung der Prozedur notwendig sind, werden als lokale Variablen deklariert. Diese werden zwischen Prozedurkopf und Prozedurkörper deklariert und sind nur während der Abarbeitung des Unterprogramms vorhanden und gültig. Lokale Variablen verlieren ihren Wert zwischen zwei Aufrufen der Prozedur.
Prozeduren
Die folgenden drei Prozeduraufrufe zeigen drei verschiedene aber typische Einsatzfälle von Prozeduren.
procedure LoadStandardPalette; Diese Prozedur lädt einen Satz von vordefinierten Farben. Parameter sind nicht
nötig, daher wird die Klammer weggelassen.
procedure MarkAllItems (ItemID: ItemType; ClassNumber: byte);
Hier werden zwei Parameter übergeben, die dazu dienen, im Prozedurkörper die notwendigen Informationen zur Bearbeitung der Aufgabe zur Verfügung zu haben.
procedure M2R (xin,yin: longint; var xout,yout: double); Bei diesem Aufruf werden nicht nur Parameter an die Prozedur übergeben,
sondern es wird auch ein Ergebnis zurückgegeben. Die Parameter xout und yout haben nach dem Aufruf der Prozedur einen von der Prozedur veränderten Wert.
Funktionen
Für Funktionen gilt im Wesentlichen dasselbe wie für Prozeduren. Zusätzlich gibt eine Funktion einen Wert zurück, der dem Namen der Funktion zugewiesen wird. Darum muss im Kopf einer Funktion der Typ des Rückgabewerts deklariert werden (vor dem abschließenden Strichpunkt, durch Doppelpunkt und Typbezeichner). Im Körper der Funktion existiert eine (undeklarierte) Variable mit dem Namen „result“. Dieser Variablen muss der Rückgabewert zugewiesen werden.
function Name (Parameterliste): type; Prozedurkopf var lokale variablen ….. begin ….. Prozedurkörper result := Rueckgabewert;end;
Hinweis:
In Standartpascal hat die Rückgabevariable den gleichen Namen wie die Funktion selbst. Delphi unterstützt auch diesen Syntax noch. Allerdings ist die Benutzung des „result“ verständlicher.
FunktionenBeispiel:
Im Folgenden ist die Deklaration und die Anwendung einer einfachen Funktion gezeigt, die immer den größeren von zwei Werten zurück liefert:
function CalcMax (v1, v2: double): double;
begin
if v1 > v2
then result := v1
else result := v2;
end;
...
var gewicht : double;
begin
...
gewicht := CalcMax(gewicht, 50);
…
Die Zuweisung der Funktion CalcMax zur Variablen FillWeight setzt diese auf den Wert von Weight falls Weight größer als 50 ist, ansonsten wird der Wert 50 zugewiesen.
Funktionen
Man kann jede Funktion aber auch in beliebigen Ausdrücken einsetzen: z.B.:
if sqr(CalcMax(Preis1, Preis2)) > Grenzwert then
...
Hier wird zuerst die Funktion CalcMax aufgerufen, um das Maximum der beiden Preise Price1 und Price2 zu ermitteln, dann wird das Resultat quadriert und dann das Quadrat des größeren Preises mit dem Wert Grenzwert verglichen.
Eingebaute Funktionen
Delphi besitzt eine ganze Menge von vordefinierten Funktionen und Prozeduren. Diese alle sind übrigens nicht einfach so vorhanden, sondern wurden wiederum in Pascal programmiert. Hier sollen einige wichtige aufgeführt werden.
In einem späteren Kapitel werden Klassen und Objecte besprochen. Kurz gesagt bieten diese die Möglichkeit Variablen und Prozeduren/Funktionen zusammenzufassen.
Nimmt man die „Standardfunktionen“ und die der Objekte zusammen (zumal man noch viele viele dazukaufen oder auch selber programmieren kann), so kommt man auf tausende Funktionen die uns Delphi (und auch Windows) anbietet.
Kein Programmierer der Welt kann dies alles im Kopf behalten. Deshalb ist eines der wichtigsten Instrumente beim Programmieren die „Hilfe-Taste“ F1.
Steht man auf einem Wort, so wird direkt zu einer Auswahl von möglichen Hilfstexten verwiesen.
Eingebaute Funktionen
Abs Absolutwert Length Gibt die Länge einer Zeichenkette zuück
Arctan Arcustangens Ln Logarithmus
Chr ASCII-Code eines Zeichens Ord Ordnungsnummer eines Typelementes
Copy Kopiert einen Teil eines Strings Pre Vorhergehender Wert
Cos Cosinus Random Zufallszahl
Dec Decrementieren Round Rundet einen Zahlenwert
floattos
tr
Wandelt eine reelle Zahl in einen String Sin Sinus
Frac Liefert die Nachkommastellen einer
reellen Zahl
Sqr Quadrat
Inc Increment Sqrt Wurzel
Insert Fügt einen Teilstring in einen anderen
String ein
Succ Nächster Wert
Int Liefert den ganzzahligen Teil einer
reellen Zahl (durch abschneiden)
StrToInt Eine Zeichenkette in eine Ganzzahl
wandeln
inttostr Wandelt eine ganzzahl in einen String StrtoFloat Eine Zeichenkette in eine reelel Zahl
wandeln
Die Tabelle zeigt eine klitzekleine Auswahl von wichtigen Delpi-Funktionen
Komplexe Datentypen - Felder
Möchte man mehrere Variablen vom gleichen Typ anlegen und stehen diese Variablen ín einer Beziehung zu einander, so bieten sich dazu Felder an. Unter einem Feld versteht man die regelmäßige Anordnung von Variablen des gleichen Typ, in einer Art und Weise, dass die einzelnen Variablen über einen Index angesprochen werden können. Felder können eine oder mehrere Dimensionen aufweisen. Die Deklaration eines Feldes geht nach folgendem Schema:
Name : array[Index1..Index2] of AType;
Wobei Index1 und Index2 ganzzahlige Konstanten sein müssen. Der Typ AType kann beliebig sein, er muss nur bereits deklariert sein. Die beiden Punkte in der Deklaration sind nicht willkürlich, sondern sind Teil der Syntax (lies: "bis"). Mehrdimensionale Felder werden deklariert, indem man die entsprechenden Indexbereiche durch Beistriche getrennt in die eckigen Klammern schreibt:
Name : array[von1..bis1, von2..bis2, von3..bis3] of AType;
Um auf einzelne Werte eines Feldes zugreifen zu können, verwendet man den Variablenname gefolgt von eckigen Klammern, in denen die entsprechenden Indizes stehen. So adressiert zum Beispiel der Ausdruck MeinFeld[2,8] das Element des Feldes MeinFeld in der 2. Spalte und der 8. Zeile. Die Zahl der Indizes muss immer mit der Deklaration übereinstimmen.
Komplexe Datentypen - Felder
Felder werden immer dann eingesetzt, wenn viele gleichartige Werte gespeichert werden müssen. So könnte man beispielsweise die Noten der Schüler einer Klasse in einem eindimensionalen Feld speichern.
Durch den Einsatz eines Feldes kann man also mit nur einer Variablen (dem Feld eben) auf jede Note zugreifen. Angenommen, man möchte den Durchschnitt errechnen, so könnte man das einfach mit einem Feld und einer for-Schleife machen:
const SCHUELER = 28;
var Noten : array[1..SCHUELER] of integer;
i : integer;
durchschnitt : double;
begin
durchschnitt := 0;
for i := 1 to SCHUELER do durchschnitt := durchschnitt + Noten[i];
durchschnitt := durchschnitt / SCHUELER;
end;
Diese Beispiel hat wohl keine praktische Bedeutung, zeigt aber die Syntax von und den Umgang mit Feldern auf einfache Weise.
Komplexe Datentypen - RecordsOft steht man vor der Aufgabe Variable unterschiedlichen Typs zu einer gemeinsamen Datenstruktur zu verbinden. So könnte man zum Beispiel Schülerdaten wie Name, Geburtsdatum und Schuhgröße zusammenfassen.
Für solche Zusammenfassungen verwendet man Records. Diese werden folgendermaßen deklariert:
Name : record Variable1 : Typ1; Variable2 : Typ2; ...
end;
Die einzelnen Variablen können nun einen beliebigen Typ haben. Der Zugriff auf den Inhalt eines Records erfolgt über den Punkt Operator. Dabei wird zuerst der Name des Records geschrieben und dann mit einem Punkt dazwischen der Name der betreffenden Variablen.
Beispiel: Im folgenden Beispiel wird ein Record zur Speicherung von Schülerdaten deklariert:
type TSchueler : record
Name : string;
Gewicht : double;
end;
var Schueler : TSchueler;
begin
Schueler.Name := ‚Lea März‘; // Ähnlichkeiten mit am Kurs teilnehmenden Schülern wären rein zufällig
Schueler.Gewicht := 52;
end;
TCanvas
Pen• Color: Gibt die Farbe für den Pen in TColor an • Width: Gibt die Breite an, in der der Rahmen oder eine Linie gezogen wird (Mindestwert=1) • Style: Erlaubt es, Linien gestrichelt zu zeichnen. Im Allgemeinen sollte dieser Wert auf der Standarteinstellung
psSolid belassen werden. Nur in dem Fall, dass man eine Figur ohne Rahmen zeichnen will, sollte man psClear benutzen, da es nichts nutzt, Width auf 0 zu setzen
• Mode: TPenMode erlaubt eine Menge Einstellungen, wie denn der Pen nun genau gezeichnet werden soll. Hierbei gilt das gleiche wie bei CopyMode von TCanvas: Die Standarteinstellung der Eigenschaft (pmCopy) sollte in 99% aller Fälle beibehalten werden. Nur für spezielle grafische Effekte sollte man umschalten.
Brush• Color: Diese Eigenschaft (natürlich wieder vom Typ TColor) regelt die Füllfarbe für den Hintergrund • Style: Mit Hilfe dieser Eigenschaft kann man auch den Hintergrund nicht komplett füllen lassen, sondern ein Muster
verwenden. Die Standarteinstellung ist bsSolid, bei der der komplette Hintergrund gefüllt wird. Wird bsClear verwendet, wird der Hintergrund Transparent gezeichnet, ein häufig praktischer Effekt. Die anderen Füllmuster sind von wenig wichtiger Bedeutung. Das 1. Problem ist die mangelnde Anzahl an Muster, die sich aber durch das verwenden einer Bitmap (s.u.) lösen lässt. Andererseits hat man keinen direkten Einfluss auf die Hintergrundfarbe, da die 2. Farbe, die verwendet wird, immer transparent ist. Um einen Hintergrund mit 2 Farben zu verwenden, muss man also vorher füllend mit der anderen Farbe zeichnen
• Bitmap: Diese Eigenschaft macht es möglich, nicht nur mit einer Farbe oder einem Vorgegebenen Muster zu füllen, sondern auch eigene Füllungen zu verwenden. Dabei sind aber einige Einschränkungen vorhanden, da das Bild genau 8*8 Pixel groß sein muss.
• Abschließend muss noch die Eigenschaft Handle erwähnt werden, die häufig für die GDI-Funktionen der API benötigt wird und das Handle des Brush zurückgibt
Font• Hier wird die verwendete Schriftart für die Ausgabe von Text verwendet. Font ist vom gebräuchlichen Typ TFont. Die
hier eingegeben Werte wirken sich nur auf wenige Canvas-Methoden aus (TextExtent, TextHeight, TextOut, TextRect, TextWidth).
TCanvas Flächenmethoden
• ChordZeichnet eine Ellipse, die durch eine Gerade getrennt ist. Die 8 Parameter sind jeweils vom Typ Integer und geben Koordinaten an. Die ersten 4 sind jeweils zu Paaren die Eckpunkte des die Ellipse umschließenden Rechteckes (also der 1. Wert der x-Wert der ersten Eckpunktes , der 2. Wert der y-Wert des ersten Eckpunktes...). Die Größe der Ellipse ist durch dieses Rechteck beschränkt. Die Parameter 5-8 geben die Linie an, die die Ellipse trennt. Der fünfte und sechste Parameter sind x- und y-Wert des einen Punktes, der siebte und achte des anderen Punktes.
• EllipseZeichnet, wie der Name schon sagt, eine Ellipse. Die Ellipse ist durch ein Rechteck beschränkt und füllt dieses Rechteck möglichst voll aus. Das Rechteck selber ist durch 4 Parameter gegeben, die 2 gegenüberliegende Eckpunkte des Rechtecks angeben.
• FillRectFüllt ein Reckeck mit der Farbe, die in Brush angegeben ist. Ein Rand wird nicht gezeichnet. Das Rechteck ist durch 4 Koordinaten angegeben, die wie üblich 2 gegenüberliegende Eckpunkte des Rechtecks darstellen. Zu beachten ist, dass die beiden Begrenzungslinien (die in der Brush-Farbe gezeichnet werden), die an den ersten Punkt angrenzen, mitgezeichnet werden, die an den zweiten Punkten angrenzen, werden jedoch nicht mitgezeichnet. Bei dieser Methode gibt es nur einen Parameter vom Typ TRect, der ein Recheck darstellt. Will man trotzdem mit 4 einzelnen Koordinaten arbeiten, sollte man die Funktion Rect verwenden, die 4 Koordinaten in ein TRect umwandelt.
• FrameRectZeichnet nur den Rahmen eines Rechtecks mit der Farbe aus dem Brush (!!!). Der Rahmen ist immer genau einen Pixel breit. Die innere Fläche des Rechtecks wird transparent gezeichnet. Der das Rechteck angebende Parameter ist wieder vom Typ TRect.
• PieZeichnet ein Kuchenstück, also den Teil einer Ellipse. Die Ellipse ist durch ein Rechteck angegeben (erste 4 Parameter). Vom Mittelpunkt der Ellipse trennen 2 Linien (Endpunkte sind die Parameter 5-8) die Ellipse. Der Bereich der im Uhrzeigersinn zwischen dem ersten und dem 2. Punkt liegt, wird nun gezeichnet. Der Rand sind die Linien, die vom Mittelpunkt der Ellipse ausgehen, und der Rand der Ellipse.
• ArcZeichnet, ähnlich wie Pie, den Ausschnitt einer Ellipse, aber keine Fläche, sondern nur einen Ausschnitt des Randes der Ellipse. Die Parameter sind die gleichen wie bei Pie.
• PolygonDiese Procedure zeichnet ein Polygon. Der einzige Parameter ist ein (beliebig) großes Array von Typ TPoint. Alle Punkte werden nacheinander miteinander verbunden, die Linien mit dem Pen gezeichnet und der Raum dazwischen mit dem Brush gefüllt.
• RectangleZeichnet ein Rechteck. Die Begrenzungslinien, wie üblich, mit Pen und die Fläche mit dem Brush. Als Parameter die 4 Integerwerte, die die Eckpunkte des Rechtecks angeben. In neueren Delphiversionen kann man die 4 Integerwerte auch durch ein TRect ersetzen.
• RoundRectZeichnet, genau wie Rectangle, ein Rechteck. Der einzige Unterschied ist, dass die Ecken leicht abgerundet sind.
• Anmerkung: Hier ist häufig von Ellipsen die Rede. Sollte ein Kreis gezeichnet werden, muss das umgebende Rechteck nur ein Quadrat sein.
TCanvas Methoden, um Bitmaps aufzutragen oder herauszukopieren
• BrushCopyZeichnet einen Teil (3. Parameter: TRect) eines Bitmap (2. Parameter: TBitmap) auf die Zeichenfläche. Der Bereich, in den gezeichnet werden soll, ist durch den ersten Parameter (TRect) gegeben. Dabei wird gegebenenfalls die Grafik verzerrt, was aber nicht immer schön aussieht und daher vermieden werden sollte. Eine Farbe (4. Parameter: TColor) des Bitmaps wird nicht mitgezeichnet, sondern diese Pixel werden mit der Brush-Farbe des Ziels gezeichnet. Dies kann verwendet werden, um transparent zu zeichnen oder andere Effekte zu erzielen. BrushCopy ist sehr langsam (Draw und StretchDraw sind ca. 200 mal so schnell) und sollte daher nicht zum normalen zeichnen verwendet werden.
• CopyRectZeichnet in einem Bereich (1. Parameter: TRect) auf dem aktuellen Canvas einen Bereich (3. Parameter: TRect) von einem anderen Canvas (2. Parameter: TCanvas). Mit Hilfe von Einstellungen bei CopyMode lässt sich eine direkte Änderung des Bildes realisieren. Wenn beide Rechtecke nicht gleich groß sind, wird der Bereich gestretcht ausgegeben, was nicht unbedingt gut aussieht.
• DrawZeichnet eine Grafik (3. Parameter: TGraphic) an eine Stelle (1. und 2. Parameter: Integer) des aktuellen Canvas. Da alle wichtigen Grafiktypen (wie TBitmap oder TJPEGImage) von TGraphic abgeleitet sind, lässt sich praktisch jede Grafik auf den Canvas zeichnen. Dabei wird die Graphik in voller Größe (wenn sie nicht Größer als die Zeichenfläche ist) ausgegeben und kann nicht größenverändert werden.
• StretchDrawZeichnet ebenfalls eine Graphik (2. Parameter: TGraphic) auf die Zeichenfläche. Aber der komplette Bereich, in dem gezeichnet wird, ist durch den ersten Parameter (TRect) angegeben, so dass das Bild gestretcht wird, falls es nicht die exakte Größe des Rechtecks hat.
• DrawFocusRectZeichnet einen Rahmen (wie er bei fokkusierten Komponenten üblich ist) um das Rechteck, das mit dem Parameter (TRect) gegeben ist. Dabei wird eine Form des Zeichnens mit XOR verwendet, der Rahmen verschindet also bei erneutem aufrufen. Ist eigentlich nur bei der Programmierung von Komponenten von Bedeutung.
TCanvas Textmethoden
• TextWidthBenötigt als Parameter einen String. Es wird mit dieser Funktion nichts gezeichnet, sondern ermittelt, wie viele Pixel der Übergebene Text bei den aktuellen Fonteinstellungen breit ist. Dieser Wert wird als Integer zurückgegeben. Diese wird benötigt, um evtl. andere Objekte neben dem Text anzuordnen.
• TextHeightÄhnlich wie TextWidth, nur wird die Höhe des Textes zurückgegeben.
• TextExtentTextHeight und TextWidth in einem. Aus dem String-Parameter wird die Höhe und Breite bei den aktuellen Font-Einstellungen ermittelt und in einem Typ TSize (Mit den Integerwerten cx und cy) zurückgegeben. Ist etwas schneller, als TextHeight und TextWidth für den gleichen Text aufzurufen.
• TextOutGibt einen Text (3. Parameter: String) an einer Position (1. und 2. Parameter: Integer) aus. Der Hintergrund wird dabei in der Brush-Farbe gezeichnet.
• TextRectGibt einen Text (4. Parameter: String) an einer Position (2. und 3. Parameter: Integer) aus. Jeglicher Text, der nicht innerhalb eines angegebenen Rechtecks (1. Parameter: TRect) liegt, wird nicht dargestellt. Die Hintergrundfarbe des Rechtecks wird mit dem Brush gezeichnet. Im Allgemeinen sollte die Position des Textes mit der linken, oberen Ecke des Rechtecks übereinstimmen. Vor allen Dingen praktisch, falls der Text eine bestimmte Größe nicht überschreiten darf (ich stelle mir einem Button vor, bei dem die Caption über den Rahmen geht).
TCanvas Andere Methoden
• FloodFillFüllt einen Bereich mit der im Brush angegebenen Farbe. Die ersten beiden Parameter (jeweils Integer) geben den ersten Punkt an, von dem ausgehend gefüllt wird. Der 4. Parameter erlaubt 2 Einstellungen: Ob solange gefüllt wird, bis die im dritten Parameter (Typ: TColor) angegebene Farbe erreicht wird, diese also eine Grenze der Füllung bildet. Dafür muss der Parameter den Wert fsBorder haben. Soll solange gefüllt werden, bis die Farbe wechselt, muss im dritten Parameter die Farbe an der entsprechenden Position angegeben werden und im vierten Parameter der Wert fsSurface. Dies entspricht dann dem Farbfüller von Paint.
• MoveToSetzt die aktuelle Stiftposition auf den angegeben Punkt (2 Parameter: Integer). Dies ist wichtig für LineTo. Die Stiftposition lässt sich auch mit einer Zuweisung an PenPos (Typ: TPoint) regeln, und mit PenPos lässt sich die Position auslesen.
• LineToZeichnet von der aktuellen Stiftposition (siehe MoveTo) eine Linie an die durch die beiden Integerparameter angegebene Position. Der letzte Pixel (also die bei LineTo angegebene Position) wird nicht (!!!!) mitgezeichnet. Dies ist aber auch nicht immer notwendig, da LineTo die Stiftposition auf dieses Pixel setz und man so direkt von dort eine neue Linie zeichnen kann.
• PolyLineZeichnet mehrere Linien. Der Endpunkt der ersten Linie ist der Anfangspunkt der zweiten Linie etc. Die einzelnen Punkte werden an PolyLine durch ein Array of TPoint übergeben. Wichtig bei dieser Methode: die Stiftposition wird nicht benutzt oder verändert. Mit PolyLine lässt sich außerdem ein Polygon zeichnen, wenn man der ersten und letzten Punkt als identisch angibt. Beinhaltet das Array nur einen Punkt, wird nichts gezeichnet, beinhaltet es 2 Punkte, wird eine Linie gezeichnet.
