Aus Wikibooks

Inhaltsverzeichnis

1 Vorwort
2 Pascal

2.1 Grundlagen

2.1.1 Aufbau eines Delphi-Programms

2.1.2 Das erste Programm

2.1.3 Datentypen

2.1.3.1 Grundlegende Datentypen

2.1.3.2 Erweiterte Datentypen

2.1.4 Variablen und Konstanten

2.1.5 Operatoren

2.1.6 Eingabe und Ausgabe

2.1.7 Verzweigungen

2.1.8 Schachtelungen

2.1.9 Schleifen

2.1.10 Prozeduren und Funktionen

2.2 Fortgeschritten

2.2.1 Typdefinition

2.2.2 Typumwandlung

2.2.3 Methodenzeiger

2.2.4 Rekursion

2.3 Objektorientierung

2.3.1 Klassen

2.3.2 Konstruktoren und Destruktoren

2.3.3 Eigenschaften

2.3.4 Vererbung

2.3.5 Zugriff auf Klassen

2.3.6 Interfaces

2.3.7 Exceptions

3 Schnelleinstieg

3.1 Einstieg

3.2 Datentypen

3.3 Pointer

3.4 Dynamische Datenstrukturen

3.5 DLL-Programmierung

3.6 Assembler und Delphi

4 RAD-Umgebung

4.1 Warum eine RAD-Umgebung

4.2 Der Debugger

4.3 Grundsätze

4.3.2 Weitergabe

4.3.3 Mehrere Formulare erstellen

4.3.4 Komponenten dynamisch erstellen

4.4 Fortgeschrittene Themen

4.4.1 Grafiken

4.4.2 Menüs

4.4.3 Toolbars

4.4.4 Statuszeilen

4.4.5 Vorlagen

4.4.6 Dialoge

4.4.7 Formatierter Text

4.5 Weitere Themen

4.5.1 Drucken

4.5.2 Tabellen

4.5.3 Aufteilung des Formulars

4.5.4 Trackbar und Scrollbar

4.5.5 GroupBox, RadioGroup und Checkbox

4.5.6 Fortschritt anzeigen

4.5.7 Anwendungsoptionen

4.5.8 WinXP-Themes

4.5.9 Arbeit mit Tasten

4.5.10 Fremdkomponenten installieren

4.6 Komponentenentwicklung

5 Multimediafunktionen
6 Anhänge

6.1 Der (richtige) Programmierstil

6.2 Befehlsregister

6.3 Glossar

6.4 Autoren

6.5 Lizenz

[Bearbeiten] Vorwort

[Bearbeiten] Delphi, was ist das?

Gut, so wird wohl keiner fragen, der sich bis hierher durchgeklickt hat, aber trotzdem sollen hier einige Begrifflichkeiten geklärt werden:

Delphi, oder noch korrekter "Object Pascal" bzw. "Delphi Language" (seit Erscheinen von Delphi 7), ist eine Programmiersprache, die auf der in den 70ern entwickelten Sprache "Pascal" basiert. Pascal wurde dabei, wie der Name "Object Pascal" schon vermuten lässt, um die objektorientierte Programmierung (OOP) erweitert.

Für Object Pascal gibt es mehrere Compiler mit integrierter Entwicklungsumgebung. Die meisten Programmierer benutzen je nachdem, ob sie Windows oder Linux benutzen die Compiler von Borland "Delphi" oder "Kylix". Ein weiterer Compiler stammt vom Open Source-Project Free Pascal, die Entwicklungsumgebung dazu ist Lazarus.

[Bearbeiten] Aufbau des Buches

Dieses Buch soll sowohl Anfängern den Einstieg in die Programmierung mit Pascal, als auch Umsteigern von anderen Sprachen (z.B.: C) einen schnellen Einstieg in Pascal ermöglichen. Um dies zu gewährleisten, teilt sich das Buch in 3 Bereiche auf:

[Bearbeiten] Die Grundlagen

Dieser Abschnitt richtet sich an totale Programmieranfänger und führt schrittweise und anhand von Beispielen in die Pascal-Programmierung ein. Neben der Einführung in die Sprache Pascal werden grundlegende Prinzipien des allgemeinen Programmierens anhand von praktischen Beispielen vermittelt.

[Bearbeiten] Der Schnelleinstieg

Wer schon eine andere Programmiersprache beherrscht und/oder seine Pascal-Kenntnisse ein bisschen auffrischen will, sollte mit diesem Abschnitt beginnen. Er erläutert alle Features der Sprache und ihrer Syntax, setzt dabei aber grundlegendes Verständnis voraus.

[Bearbeiten] Die RAD Umgebung

In diesem Abschnitt geht es um die Programmierumgebungen Delphi und Lazarus. Es soll ein Einstieg in die Entwicklung graphischer Oberflächen und die damit verbundenen Programmiertechniken gegeben werden, die allerdings das Verständnis von Pascal voraussetzen. Weiterhin werden der Aufbau und die dahinter liegenden Prinzipien der graphischen Klassenbibliotheken (VCL,LCL) erläutert.

[Bearbeiten] Warum Pascal?

Pascal wurde speziell zu Lernzwecken entwickelt. Insofern kann Pascal für Programmieranfänger empfohlen werden. Eine der hervorstehensten Eigenschaften von Pascal ist die gute Lesbarkeit des Quellcodes, verglichen mit Programmiersprachen wie z.B. C oder C++. Von der Geschwindigkeit der ausführbaren Programme her zieht Pascal fast mit C++ gleich. Obwohl bereits 1970 der erste Pascal-Compiler verfügbar war, gelang Pascal erst mit Borlands Turbo Pascal Mitte der 80er Jahre der Durchbruch. Seit Turbo Pascal 5.5 gibt es auch Möglichkeiten für die objektorientierte Programmierung. Der bekannteste aktuelle, kostenlose Pascalcompiler FreePascal ist in vielen Punkten nicht nur zu Turbo Pascal 7, sondern sogar zu Delphi kompatibel und wird ständig weiterentwickelt. Pascal ist also keine tote Sprache, obwohl dies oft behauptet wird.

[Bearbeiten] Warum Delphi?

Es gibt viele Gründe, Delphi zu benutzen. Es gibt aber wahrscheinlich auch genauso viele dagegen. Es ist also mehr Geschmackssache, ob man Delphi lernen will oder nicht. Wenn man allerdings Gründe für Delphi sucht, so fällt sicher zuerst auf, dass Delphi einfach zu erlernen ist, vielleicht nicht einfacher als Basic aber doch viel einfacher als C/C++. Für professionelle Programmierer ist es sicher auch wichtig zu wissen, dass die Entwicklung von eigenen Komponenten unter Delphi einfach zu handhaben ist. Durch die große Delphi-Community mangelt es auch nicht an Funktionen und Komponenten.

Ein besonderer Vorteil von Delphi ist hohe Typsicherheit. Viele Fehler werden also schon beim Kompilieren bemerkt und müssen nicht durch langwieriges Debuggen entdeckt werden.

Erstellt man größere Projekte mit Borlands Delphi Compiler, so ist die Geschwindigkeit beim Kompilieren sicher ein entscheidender Vorteil. Auch die einfache Modularisierung durch Units, Functions und Procedures ist sicherlich ein Vorteil der Sprache gegenüber einfachen Sprachen wie Basic.

Mit Delphi lässt sich zudem so ziemlich alles entwickeln, auch sehr hardwarenahe Programme.

[Bearbeiten] Pascal

[Bearbeiten] Grundlagen

[Bearbeiten] Aufbau eines Delphi-Programms

Delphi ist, anders als andere Programmiersprachen, strenger in Abschnitte eingeteilt. So dürfen zum Beispiel Variablen nicht an fast beliebigen Stellen deklariert werden, sondern nur an dafür vorgesehenen.

[Bearbeiten] Aufbau des Hauptprogramms

Ein einfaches Konsolenprogramm (ein Textprogramm, das auf der Eingabeaufforderung läuft), besteht aus einem Programmkopf und einem Programmrumpf. Der Kopf besteht dabei aus dem Schlüsselwort program gefolgt von dem Programmnamen und einem Semikolon. Im Rumpf werden alle Variablen, Konstanten, Typen und Funktionen deklariert, danach folgt das Hauptprogramm zwischen den Schlüsselwörtern begin und end. Nach dem abschließenden end. dürfen keinerlei Anweisungen mehr folgen, "das Programm ist beendet, Punktum."

program Testprogramm;      }- Kopf

{ Deklarationen }          ┒
                           ┠ Rumpf
begin                      ┃
end.                       ┚

Die Deklaration von Variablen wird durch das Schlüsselwort var eingeleitet, wovon mehrere Abschnitte möglich sind. Nach diesem Schlüsselwort folgt der Name der Variablen (bei mehreren durch Kommata getrennt), gefolgt von einem Doppelpunkt, dem Datentyp und einem Semikolon:

var
  i: Integer;
  r, d: Double;

Konstanten und Typen werden ähnlich deklariert:

const
  NAME = 'Dieter Meier';
  VERSION = 1.0;

type
  TDateiname = string;

Prozeduren und Funktionen bestehen ebenfalls aus einem Prozedurkopf und einem Prozedurrumpf. Beim Kopf wird hierbei unterschieden, ob es sich um eine Prozedur (procedure, gibt keinen Wert zurück) oder um eine Funktion (function, besitzt einen Rückgabewert) handelt. In abstrakter Form sieht dies so aus:

procedure Name;
procedure Name(Parameter: Typ);
procedure Name(Parameter1: Typ; Parameter2: Typ);
function Name: Typ;
function Name(Parameter: Typ): Typ;

Funktionen enden immer auf : Typ;, wobei hiermit der Datentyp des Rückgabewerts angegeben wird.

Direkt nach dem Prozedurkopf können lokale, also nur innerhalb der Funktion verwendbare Datentypen, Variablen und Konstanten deklariert werden. Dann folgt, eingeschlossen in einen begin...end;-Block der Prozedurrumpf mit den entsprechenden Anweisungen, die in der Prozedur/Funktion ausgeführt werden sollen. Beispiel:

procedure SchreibeName;        }- Kopf
const                          ┒
  NAME = 'Dieter Meier';       ┃
begin                          ┠ Rumpf
  WriteLn(NAME);               ┃
end;                           ┚

Mehr zur Verwendung von Prozeduren und Funktionen erfahren Sie später.

[Bearbeiten] Aufbau von Units

Neben dem Hauptprogramm können weitere Programmteile in so genannte Units ausgelagert werden. Units sind ähnlich wie das Hauptprogramm aufgebaut, haben jedoch einen signifikanten Unterschied: Es gibt einen öffentlichen und einen nicht-öffentlichen Programmteil.

Eine Unit wird mithilfe des Schlüsselworts unit gefolgt vom Unitnamen und einem Semikolon eingeleitet. Direkt darauf wird der öffentliche Abschnitt mit dem Wort interface eingeleitet. Hierin erfolgen alle Deklarationen von Programmteilen, auf die wiederum von anderen Programmteilen (z.B. Hauptprogramm oder anderen Units) aus zugegriffen werden soll. Prozeduren werden in diesem Abschnitt jedoch nicht vollständig deklariert, sondern nur der Prozedurkopf. Die Programmierung des Prozedurrumpfs erfolgt im nicht-öffentlichen Teil der Unit.

Der nicht-öffentliche Teil beginnt direkt nach den erfolgten Deklarationen durch das Schlüsselwort implementation. Hier müssen alle im Interface-Abschnitt angegebenen Prozeduren und Funktionen ausgearbeitet werden. Es muss also der Prozedurkopf wiederholt und anschließend der Prozedurrumpf programmiert werden. Im Implementation-Abschnitt können wieder, wie in den anderen Abschnitten, Typen, Variablen und Konstanten deklariert werden, auf die dann nur in diesem Abschnitt zugegriffen werden kann. Ähnlich wie im Hauptprogramm können auch neue Prozeduren erstellt werden, die dann nur von den nachfolgenden Prozeduren dieses Implementation-Abschnitts aufgerufen werden können. Der Implementation-Abschnitt wird mit einem end. abgeschlossen und beendet damit auch die gesamte Unit. Hier einmal eine Beispiel-Unit; über den verwendeten Datentyp erfahren Sie später im Kapitel Records mehr:

unit Beispiel;

interface

{ öffentlicher Teil }

type
  TPerson = record    // ein öffentlicher Datentyp
    Vorname: string;
    Nachname: string;
  end;

procedure SetzeName(Vorname, Nachname: string);
procedure SchreibeName;

implementation

{ nicht-öffentlicher Teil }

var
  Name: TPerson;    // eine nur in diesem Abschnitt verwendbare Variable

procedure SetzeName(Vorname, Nachname: string);
begin
  Name.Vorname := Vorname;    // den Vornamen in der nicht-öffentlichen Variable speichern
  Name.Nachname := Nachname;  // den Nachnahmen speichern
end;

procedure SchreibeName;
begin
  WriteLn(Name.Vorname + ' ' + Name.Nachname);  // die gespeicherten Werte auslesen und auf den Bildschirm schreiben
end;

end.

Um eine Unit verwenden zu können, muss diese im entsprechenden Programmteil eingebunden werden. Dies geschieht durch die Uses-Klausel, direkt nach program, interface oder implementation. Die darin öffentlich gemachten Programmteile können anschließend verwendet werden, als wären Sie im Hauptprogramm oder in der anderen Unit selbst deklariert worden:

program Testprogramm;
uses Beispiel;

{ eventuelle Deklarationen }

begin
  SetzeName('Dieter', 'Meier');
  SchreibeName;
end.

[Bearbeiten] Reihenfolge der Deklarationen

Bei der Reihenfolge ist darauf zu achten, dass die Variablen, Konstanten, Datentypen und Prozeduren immer nur "in Leserichtung" bekannt sind. Dies bedeutet, alles was weiter oben im Programmtext steht, ist weiter unten auch bekannt. Anders herum gilt, dass z.B. weiter unten deklarierte Programminhalte nicht in den Prozeduren darüber verwendet werden können. Ganz oben, direkt nach program ... angegebene Variablen sind in allen darauffolgenden Prozeduren, sowie im Hauptprogramm "sichtbar".

Sie brauchen sich hierüber jedoch keine großen Sorgen machen. Wenn mal etwas an der falschen Stelle steht, wird das Programm gar nicht erst kompiliert. Delphi bricht dann bereits mit einer entsprechenden Fehlermeldung ab.

Direkt im Programmrumpf deklarierte Variablen heißen globale Variablen. Da auf diese von allen nachfolgenden Prozeduren und vom Hauptprogramm gleichermaßen zugegriffen werden kann, werden diese (leider oftmals nicht nur von Programmieranfängern) gern zum Datenaustausch eingesetzt. Zum Beispiel wird im Hauptprogramm ein Wert abgelegt, den ein Unterprogramm auswertet und gegebenenfalls überschreibt. Dies sollte strengstens vermieden werden! Das Programm lässt sich dadurch zwar eventuell schneller schreiben, jedoch erschwert diese Art des Datenaustauschs die Fehlersuche. Man weiß dann oftmals nicht, welchen Wert einer Variable man in welchem Programmabschnitt erwarten kann. Daher sollte man globale Variablen nach Möglichkeit nur zum Beispiel zur Konfiguration des Programms verwenden und nur in einer einzigen Prozedur Änderungen an den Werten vornehmen.

[Bearbeiten] Das erste Programm

[Bearbeiten] Die Konsole

Obwohl die schnelle Entwicklung einer grafischen Oberfläche (engl. Graphical User Interface, Abk. GUI) eine der größten Stärken von Delphi ist, eignet sie sich nur bedingt zum Einstieg in die Programmierung, da die GUI-Entwicklung ein eher komplexeres und vielseitiges Thema ist. Außerdem setzt sie ein grobes Verständnis allgemeiner Programmiertechniken (wie z.B. objektorientierte Programmierung) voraus. In diesem Buch wird als Einstieg die Konsolenprogrammierung genutzt, um Sie auf einfache Art und Weise in die verschiedenen Sprachelemente des Software Engineerings einzuführen. Unter Windows auch als „DOS-Fenster“ bekannt, stellt eine Konsole grundlegende Methoden zur Ein- und Ausgabe von Daten dar, die heutzutage zwar oft als veraltet gilt, aber dennoch nicht wegzudenken ist.

[Bearbeiten] Die Programmvorlage

Startet man Delphi, so öffnet es direkt ein leeres Projekt zur Erstellung eines grafischen Programms. Da wir zunächst aber ein Konsolenprogramm erstellen wollen, müssen wir dieses Projekt schließen und ein anderes erstellen.

Delphi:

Datei->Neu->Weitere...->Konsolen-Anwendung

[1]  program Project1;
[2]
[3]  {$APPTYPE CONSOLE}
[4]
[5]  uses
[6]    SysUtils;
[7]
[8]  begin
[9]    { TODO -oUser -cConsole Main : Hier Code einfügen }
[10] end.

Dies ist nun die Vorlage für unser erstes Programm. Zeile 1: Jedes Programm beginnt mit dem Schlüsselwort program gefolgt von dem Programmnamen (der übrigens identisch mit dem Dateinamen sein muss) gefolgt von einem Semikolon.

Die Zeilen 3–6 sollen uns zunächst nicht interessieren, sie sorgen für die nötigen Rahmenbedingungen, die unser Programm benötigt.

In Zeile 8 leitet das begin nun den Hauptanweisungsblock ein, in dem sich später unser Quelltext befinden wird. In Zeile 10 endet sowohl der Anweisungsblock mit end.. Dieser Anweisungsblock wird beim Programmstart ausgeführt und danach beendet sich das Programm wieder.

Zeile 9 enthält nur einen Kommentar, der für uns unwichtig ist und bedenkenlos entfernt werden kann.

Unter Lazarus sieht der Programmrumpf ähnlich aus, wobei wir auch hier die Zeilen 3–10 zunächst nicht weiter beachten:

Datei->Neu...->Project->Program

 [1] program Project1;
 [2]  
 [3] {$mode objfpc}{$H+}
 [4]
 [5] uses
 [6]   {$IFDEF UNIX}{$IFDEF UseCThreads}
 [7]   cthreads,
 [8]   {$ENDIF}{$ENDIF}
 [9]   Classes
[10]   { add your units here };
[11]
[12] begin
[13] end.

[Bearbeiten] Der Befehl Readln

Delphi stellt mit der Programmvorlage ein zwar funktionierendes aber funktionsloses Programm zur Verfügung. Wenn wir einmal dieses Programm starten (mittels F9), so sehen wir im besten Fall für den Bruchteil einer Sekunde ein Konsolenfenster. Denn da unser Programm noch leer ist, wird es sofort beendet. Um dies zu verhindern, fügen wir den Befehl Readln ein:

begin
  Readln;
end.

Readln steht für „read line“ (deutsch: lies Zeile). Das heißt, Readln macht nichts anderes als eine Zeile Text von der Konsole zu lesen. Die Eingabe einer Zeile wird mit der ENTER-Taste beendet. Bis die ENTER-Taste gedrückt wurde, liest der Readln-Befehl alle Zeichen, die man eingibt, ein. Also müsste unser Konsolen-Fenster nun solange geöffnet bleiben, bis wir die ENTER-Taste drücken.

Wie man die durch Readln eingelesenen Zeichen verarbeitet, erfahren Sie später.

[Bearbeiten] Die Ausgabe

Nachdem unser Programm nun geöffnet bleibt, damit wir die Ausgaben des selbigen betrachten können, wird es nun Zeit Ausgaben hinzuzufügen. Dazu verwenden wir den Befehl Writeln:

begin
  Writeln('Hello World');
  Readln;
end.

Analog zu Readln steht Writeln für „write line“ (deutsch: schreibe Zeile). Wie sich daher bereits erahnen lässt, führt dieser Befehl dazu, dass der Text „Hello World“ auf der Konsole ausgegeben wird.

[Bearbeiten] Exkurs: Zeichenketten

In Pascal werden Zeichenketten durch ein einfaches Apostroph (') gekennzeichnet und im Allgemeinen als String bezeichnet. Will man allerdings ein ' in seinem String verwenden so ist dies durch '' möglich.

Näheres siehe Strings.

Nun lassen sich selbstverständlich noch beliebig viele weitere Ausgaben hinzufügen. Allerdings entbehrt die reine Ausgabe von Text auf der Konsole, dem eigentlichen Sinn von Programmen, die ja Informationen verarbeiten können sollen. Genau dies ist also Thema des nächsten Kapitels: Wenn Dann Sonst, aber zunächst beschäftigen wir uns erst mal mit den Datentypen.

[Bearbeiten] Datentypen

[Bearbeiten] Grundlegende Datentypen

[Bearbeiten] Allgemeines

Um in Pascal programmieren zu können, muss man wissen, dass verschiedene Datentypen existieren. Pascal ist dabei eine sehr genaue bzw. strikte Sprache, die jede falsche Verwendung von Datentypen mit einer Fehlermeldung ahndet. Doch was sind nun Datentypen?

Die von einem Programm verwendeten Daten werden in einer Bitfolge im Speicher abgelegt. Je nachdem, wie diese Bitfolge wieder ausgelesen wird, können sich wieder völlig andere Daten ergeben. Um hier keine ungewollten Programmabstürze zu produzieren, wird jedem Speicherbereich ein bestimmter Datentyp zugeordnet. Mit den Datentypen können verschiedene Operationen durchgeführt werden, zum Beispiel kann man mit Zahlen rechnen, mit Buchstaben jedoch nicht. Durch die strikte Verwendung von Datentypen ist sichergestellt, dass die gespeicherten Daten nur ihrer Bestimmung gemäß verwendet werden. Nun ja, fast immer, denn keine Regel ohne Ausnahme. Aber dazu später mehr.

[Bearbeiten] Texttypen

Für die Bearbeitung von Text gibt es zwei verschiedene Zeichentypen: für einzelne Zeichen und für Zeichenketten. Ein Zeichen ist dabei im Grunde alles das, was Sie mit Ihrer Tastatur auf den Bildschirm zaubern können, also Buchstaben, Ziffern (mit denen man aber nicht rechnen kann), Interpunktions- und andere Sonderzeichen usw.

[Bearbeiten] Der Typ Char

Der Typ Char dient dazu, ein einzelnes ASCII-Zeichen zu speichern.

var
  c: Char;
begin
  c := 'a'; // c den Buchstaben a zuweisen
end.

Um nicht druckbare Zeichen in einem Char zu speichern, oder einfach ein Zeichen mit einem bestimmten ASCII-Code einzufügen, kann das #-Zeichen, gefolgt von einer Ganzzahl genutzt werden:

var
  c: Char;
begin
  c := #64; // c das Zeichen mit dem ASCII-Code 64 zuweisen (= '@')
end.

[Bearbeiten] Der Typ String

Der Typ String bezeichnet eine Zeichenkette mit variabler Länge. Das heißt, er kann keine Zeichen, ein Zeichen oder auch mehrere beinhalten.

Strings müssen im Quelltext immer von Apostrophen umschlossen werden, dies wird von Delphi standardmäßig blau hervorgehoben:

var
  s: string;
begin
  s := 'Dies ist ein String';
end.

Mehrere Strings lassen sich miteinander mit Hilfe des +-Operators zu einem größeren Text verknüpfen (konkatenieren). Wenn wir beispielsweise an "Dies ist ein String" noch " und wird in s gespeichert." hängen wollen, so können wir das mit dem so genannten Verknüpfungs- oder Verkettungsoperator tun. Dieser Operator ist ein Pluszeichen (+). Doch genug zur Theorie. Unser Beispiel sähe so aus:

s := 'Dies ist ein String';             // s = "Dies ist ein String"
s := s + ' und wird in s gespeichert.'; // s = "Dies ist ein String und wird in s gespeichert."

Auch Steuerzeichen können genauso wie bei Char verwendet werden:

s := s + #10;  // Linefeed an s anhängen (Dezimale Schreibweise)
s := s + #$20; // Leerzeichen an s anhängen (Hexadezimale Schreibweise)

So wird im Prinzip jedes Zeichen im String gespeichert. Dies erklärt auch, warum man mit Zahlen in einem String nicht rechnen kann, obwohl sie im String gespeichert werden können.

Um ein einzelnes Zeichen eines Strings anzusprechen, genügt es, in eckigen Klammern dahinter zu schreiben, welches Zeichen man bearbeiten oder auslesen möchte.

Writeln('Der erste Buchstabe des Strings ist ein "'+s[1]+'".');

[Bearbeiten] Verwendung beider Typen untereinander

Die Datentypen Char und String sind in gewisser Weise kompatibel. Man kann z.B. ein Char an einen String anhängen oder ein Zeichen aus einem String in einem Char speichern:

c := 'X';                      // c = "X"
s := 'Hier ein Zeichen: ' + c; // s = "Hier ein Zeichen: X"
c := s[3];                     // c = "e"

[Bearbeiten] Ganzzahlige Typen

Ganzzahlige Variablen können, wie der Name schon sagt, ganze bzw. natürliche Zahlen speichern. Der am häufigsten gebräuchliche Typ in dieser Variablenart ist "Integer". Mit diesen Zahlen lässt sich dann auch rechnen.

[Bearbeiten] Datentypen zum Umgang mit natürlichen Zahlen

Eine Variable vom Typ „Integer“ bezeichnet eine 32 Bit große Ganzzahl mit Vorzeichen, es können somit Werte von -2³¹ bis 2³¹-1 dargestellt werden.

Das nachfolgende Beispiel zeigt einige Möglichkeiten zur Verwendung von Variablen. Nach jedem Schritt wird mittels Writeln der Name der Variable und danach der Wert der selbigen ausgegeben.

var
  i, j: Integer;
begin
  i := 10;
  WriteLn('i ', i);
  j := i;
  WriteLn('j ', j);
  i := 12;
  WriteLn('i ', i);
  WriteLn('j ', j);
  ReadLn;
end.

Ausgabe:

i 10
j 10
i 12
j 10

Hier wird deutlich, dass bei der Zuweisung einer Variablen an eine andere nur der Wert übertragen (kopiert) wird.

Außerdem kann wie gewohnt mit +, - und * gerechnet werden. Eine Division wird für Ganzzahltypen durch div dargestellt. Um den Rest einer Division zu erhalten, wird der mod-Operator verwendet. Der Compiler beachtet auch Punkt-vor-Strich Rechnung und Klammerung.

i := 10;        // i ist jetzt 10
i := i * 3 + 5; // i ist jetzt 35
i := 10 div 3;  // i ist jetzt 3
i := 10 mod 3;  // i ist jetzt 1

[Bearbeiten] Weitere ganzzahlige Datentypen

[Bearbeiten] Gleitkommazahlen

[Bearbeiten] Die Datentypen Single, Double und Extended

Mit den ganzzahligen Datentypen lassen sich nur gerundete Divisionen durchführen. Brüche wie ¹/₂ sind daher nicht sinnvoll auszuwerten. Um auch Nachkommastellen berechnen zu können, existieren in Pascal die Gleitkommatypen Single, Double und Extended. Der Unterschied zwischen diesen Typen besteht in der Genauigkeit, mit der die Daten gespeichert werden. Die folgende Tabelle zeigt den jeweiligen Wertebereich der einzelnen Typen:

Daneben existieren unter Delphi noch die folgenden besonderen Typen:

• Extended bietet zwar die höchste Genauigkeit, ist aber stark an das System gebunden. Wenn Daten in diesem Format gespeichert werden und auf anderen Rechnern verwendet werden sollen, kann dies zu Problemen führen.
• Real48 ist veraltet und sollte nur noch zur Kompatibilität mit alten Pascal-Programmen verwendet werden.
• Real sollte ebenfalls nicht unbedingt verwendet werden, da dieser Typ keine festgelegte Genauigkeit besitzt. In älteren Programmen war dieser Typ gleichbedeutend mit Real48, heute mit Double.
• Comp ist ein „Mischtyp“ zwischen ganzen Zahlen und Gleitkommazahlen und ebenfalls veraltet (genaueres in der Hilfe von Delphi)
• Currency ist ein spezieller Typ einer Festkommazahl zur Verwendung mit Währungen. Er weist ebenfalls ein besonderes Verhalten bei der Wertzuweisung auf, näheres in der Delphi-Hilfe.

Die Division können Sie nun mit Hilfe des Operators „/“ statt mit div durchführen. Als Zähler und Nenner können sowohl Ganzzahl- als auch Gleitkommavariablen verwendet werden. Bei der direkten Zuweisung eines gebrochenen Wertes wird die englische Schreibweise verwendet, sprich: das Komma wird durch einen Punkt ersetzt:

x := 1.34;

[Bearbeiten] Wahrheitswerte

[Bearbeiten] Der Datentyp Boolean

Der Typ Boolean ermöglicht es, einen Wahrheitswert zu speichern. Mögliche Werte sind true (wahr) und false (falsch). Auch der Wert kann wiederum der Variable zugewiesen werden:

var
  a: Boolean;
begin
  a := True;
end.

Auf diesen Variablentyp wird im Kapitel Verzweigungen näher eingegangen.

[Bearbeiten] Erweiterte Datentypen

[Bearbeiten] Zeiger

[Bearbeiten] Was sind Zeiger?

Ein Zeiger bzw. Pointer ist eine Variable, die auf einen Speicherbereich des Computers verweist. Zum besseren Verständnis hier ein kleines Beispiel:

Nehmen wir einmal an, wir haben einen Schrank mit 50 verschiedenen Fächern. Jedes Fach ist mit einer Nummer gekennzeichnet, dazu hat er in jedem Fach einen Gegenstand.

Im Sinne von Zeiger in einer Programmiersprache ist der Schrank der Speicherbereich des Computers, welcher dem Programm zur Verfügung gestellt wird. Jedes einzelne Fach des Schrankes repräsentiert eine Adresse auf diesem Speicher. Die Nummer des Faches entspräche der Speicheradresse, der Inhalt der Lade dem Wert des Objektes, auf das der Zeiger verweist. Auf jedem Speicher kann nun auch eine beliebige Bitreihenfolge abgespeichert werden.

[Bearbeiten] Wozu dienen Zeiger?

Es gibt mehrere Gründe, warum man Zeiger benötigt. Zum einen sind hinter den Kulissen von Pascal sehr viele Zeiger versteckt, die große dynamische Speicherblöcke benötigen. Beispielsweise ist ein String ein Zeiger, wie auch eine Klasse nur ein einfacher Zeiger ist.

In vielen Fällen sind aber auch Zeiger dazu da, um die strikte Typisierung von Pascal zu umgehen. Dazu benötigt man einen untypisierten Zeiger, der nur den Speicherblock enthält, ohne Information dazu, was sich auf dem Speicherblock befindet.

Weiterhin kann man Zeiger dazu verwenden, um Speicher zu sparen. Dabei fordert man vom System immer nur genau soviel Speicherplatz an, wie man gerade für seine Daten benötigt. Das ist vor allem in den (zugegebenermaßen seltenen) Fällen sinnvoll, wenn man bei der Entwicklung eines Programms noch nicht weiß, welcher Art diese Daten sind und damit natürlich auch nicht weiß, wie groß die Datenmenge sein wird. Hierfür wird sich jedoch meistens eine elegantere Lösung finden. Man kann durch Zeiger auch Speicher sparen, wenn man ihn immer nur dann anfordert, wenn man ihn benötigt. Ein nicht zugewiesener Zeiger erfordert nämlich immer nur 4 Byte! Ein großes Record kann dagegen auch völlig unbenutzt mehrere KByte belegen.

[Bearbeiten] Anwendung

[Bearbeiten] Deklaration

Es gibt zwei Arten, wie man einen Zeiger deklarieren kann. Eine typisierte und eine untypisierte Variante.

 var
   Zeiger1: ^Integer;  // typisiert
   Zeiger2: Pointer;   // untypisiert

[Bearbeiten] Speicheradresse auslesen

Im Code kann man nun entweder die Adresse oder den Inhalt des Speicherblockes auslesen. Das Auslesen der Adresse des Speicherblockes funktioniert gleich bei der un- wie auch bei der typisierten Variante.

 begin
   Zeiger2 := @Zeiger1;
   Zeiger2 := Addr(Zeiger1);
 end.

Wie ihr seht, gibt es für das Auslesen der Adresse zwei Varianten. Entweder den @-Operator oder auch mit der Funktion Addr(), wobei zu bemerken ist, dass der @-Operator schneller ist. Hinter einem @-Operator kann jede beliebige Variable stehen, aber nur einem untypisierten Pointer kann jede Adresse jedes Speicherblocks zugeordnert werden, ohne auf den Typ zu achten.

[Bearbeiten] Inhalt auslesen

Hier gibt es einen Unterschied zwischen typisierten und untypisierten Zeiger.

 var
   i, j: Integer;
   p1: ^Integer;
   p2: Pointer;
 begin
   i := 1;
   {typisiert}
   p1 := @i;     // dem Pointer wird die Adresse der Integer-Variable übergeben
   p1^ := p1^+1; // hier wird der Wert um eins erhöht
   j := p1^;     // typisiert: der Variable j wird 2 übergeben
   {untypisiert}
   p2 := @i;     // analog oben
   Integer(p2^) := i+1;
   j := Integer(p2^);
 end.

Bei einem untypisierten Zeiger muss immer der Typ angegeben werden, welcher aus dem Speicher ausgelesen werden soll. Dies geschieht durch die so genannte Typumwandlung: Typ(Zeiger).

siehe hierzu auch Schnelleinstieg: Pointer

[Bearbeiten] Aufzählungen

Oftmals dienen Variablen dazu, aufgrund ihres Wertes bestimmte Aktionen im Programmablauf auszulösen. Als einfachstes dient das Beispiel einer Ampel:

Ampel rot:  Anhalten
Ampel gelb: Fahrbereitschaft herstellen
Ampel grün: Losfahren

Dabei stehen die Farben der Ampel in einer logischen Reihenfolge zueinander. Ohne einen Aufzählungstyp zu verwenden, könnte man z.B. jeder Farbe eine Zahl zuweisen, wie rot=0, gelb=1, grün=2. Das macht den Programmtext jedoch am Ende schwer zu lesen und schwer zu warten, da immer auch die Bedeutung der Zahl bekannt sein muss. Alternativ könnte man entsprechend benannte Konstanten verwenden, was aber ebenfalls kein schöner Programmierstil ist. Eine weitere Möglichkeit wäre es, die Farbe als Text in einem String zu speichern. Mal abgesehen von der Größe des Programms kann dies zu Abstürzen wegen Tippfehlern führen, der Speicherbedarf erhöht sich und das Programm wird langsamer ausgeführt.

[Bearbeiten] Aufzählungen mit automatischen Positionen

Da wir nun wissen, was wir nicht tun sollten, wie umgehen wir die Probleme?

In Pascal gibt es dafür so genannte Aufzählungstypen. Dabei wird ein Typ definiert, der Elemente in einer angegebenen Reihenfolge besitzt. Als „Werte“ werden dabei Bezeichner eingesetzt, die bisher noch nicht im Programm verwendet werden:

type
  TAmpel = (rot, gelb, gruen);

var
  Ampel: TAmpel;

Die Aufzählung sollte nicht direkt hinter der Variablendefinition angegeben, sondern möglichst immer als eigenständiger Typ definiert werden. Einzige Ausnahme: man verwendet in dem Programm tatsächlich nur genau diese eine Variable mit der Aufzählung.

Um nun der Ampel eine Farbe zu geben, weist man einfach den entsprechenden Bezeichner zu:

Ampel := gruen;

Da es sich bei diesem Typ, wie der Name schon sagt, um eine Aufzählung handelt, kann man die Werte inkrementieren (erhöhen) und dekrementieren (erniedrigen), sowie den Vorgänger bzw. Nachfolger bestimmen oder auch in einer case-Verzweigung auswerten. Dies ist möglich, da den Bezeichnern intern automatisch eine Position zugewiesen wird. Das erste Element hat immer die Position 0, das zweite die Position 1 usw. Man kann diese Position mit der Funktion Ord auslesen. Andersherum kann man mittels Typumwandlung aus einer Zahl wieder die Position im Aufzählungstyp ermitteln:

var
  b: Byte;
  a: TAmpel;

begin
  a := gelb;
  b := Ord(a);     // b = 1;

  b := 2;
  a := TAmpel(b);  // a = gruen;
end.

[Bearbeiten] Aufzählungen mit definierten Positionen

Wem die Regel 0, 1, 2,... zu starr ist und wer eine andere Einteilung benötigt, kann hinter jedem Element eine Position vorgeben. Diese lässt sich auch aus den anderen Positionen errechnen. Ebenso sind mehrfach benannte Positionen möglich:

type
  TAmpel = (rot = 1, gelb = 2, gruen = 4);
  TArbeitstage = (Mo = 1, Di = 2, Mi = Mo + Di, Don = 4, Fr = Di + Mi);  // Mi = 1+2=3, Fr = 2+3=5
  TDoppelt = (Bez1 = 1, Bez2 = 2, Bez3 = 3, Bez4 = 2);  // sowohl Bez2 als auch Bez4 ergeben mit Ord = 2

In diesem Beispiel von TAmpel wurden die Positionen 0 und 3 übersprungen und nicht benannt. Das heißt, dass man diese Positionen nicht namentlich zuweisen kann. Aber sie existieren trotzdem und lassen sich zuweisen! Das ermöglicht die Typumwandlung:

a := TAmpel(3);
b := Ord(a);        // b = 3
a := TAmpel(1024);  // ebenfalls zulässig!

// ACHTUNG!
a := gelb;          // Ord(a) = 2
a := Succ(a);       // Ord(a) = 3 und nicht 4!

Inwiefern dies jedoch in einem Programm sinnvoll ist, muss jeder für sich selbst entscheiden.

Die Anzahl der möglichen Positionen, die auch nach der zuletzt benannten zugewiesen werden können, richtet sich nach ebendieser. Ist die letzte benannte Position kleiner als 256, ergibt eine Zuweisung von 256 gleich 0, da die Zählung wieder von vorne beginnt. Ebenso hat a im oberen Beispiel den Wert 0, da 1024 = 256 × 4. Ist die letzte Position 256 oder höher, können Werte bis 65535 angegeben werden usw. Auch negative Werte sind möglich, wenn entsprechende benannte Positionen definiert werden.

[Bearbeiten] Sets

Bei einem Set handelt es sich um einen Datentyp, der eine Menge von Werten eines Basistyps speichert. Ein Set speichert dabei zu jedem möglichen Wert des Basistyps, ob dieser enthalten ist. Der Basistyp muss ein Typ sein, der höchstens 256 verschiedene Werte annehmen kann, also etwa Byte, Char oder ein selbst definierter Aufzählungstyp. Möglich sind natürlich auch Teilbereichstypen dieser Typen. Ein Set benötigt für jeden möglichen Wert des Basistyps ein Bit, hat also eine Größe von 32 Byte.

Mengen sind z.B. nützlich, um Programmeinstellungen oder auch bestimmte kumulative Eigenschaften von Objekten zu speichern. Anders als beim Array spielt die Reihenfolge der Elemente keine Rolle, und jedes Element kann auch nur einmal enthalten sein.

[Bearbeiten] Deklaration

Ein Mengentyp wird durch die Angabe von set of deklariert:

type
  TMenge = set of <Aufzählungstyp>;

Um einer Mengenvariablen Werte zuzuweisen, setzt man diese in eckige Klammern [] und trennt die einzelnen Werte mit einem Komma. Für eine leere Menge geben Sie nur die eckigen Klammern an. Mit dem Operator in fragt man ab, ob ein Element in einer Menge enthalten ist.

Zur Verdeutlichung ein Beispiel zur Ziehung der Lottozahlen:

type
  TLottozahlen = 1..49;

var
  Lottozahlen: set of TLottozahlen = [];  // leere Menge
  i: Byte;
  z: TLottozahlen;

begin
  { Zufallszahlen initialisieren }
  Randomize;

  { Ziehung 1 bis 6 }
  for i := 1 to 6 do begin
    { Eine Zufallszahl ziehen und prüfen, ob diese bereits vorhanden ist }
    repeat
      z := Random(49) + 1;
    until not (z in Lottozahlen);
    { Zahl der Ziehung hinzufügen }
    Lottozahlen := Lottozahlen + [z];
  end;

  { alle Lottozahlen sortiert ausgeben }
  for z in Lottozahlen do
    Writeln(z);
end.

Die Gesamtmenge aller gültigen Lottozahlen reicht von 1 bis 49. Hierzu deklarieren wir uns einen entsprechenden Typ. Da wir aus dieser Gesamtmenge 6 Zahlen zufällig auswählen, benötigen wir noch eine Zählschleife, die den Vorgang nach der 6. Ziehung beendet. Da wir ja keine echten Kugeln herausnehmen können, kann es passieren, dass eine Zahl mehrfach gezogen wird. Um dies zu vermeiden, prüfen wir, ob die Zahl eventuell bereits vorhanden ist und ziehen in diesem Fall eine neue. Eine Menge speichert zwar (im Gegensatz zu einem Array) jeden Wert nur einmal, allerdings würde die for...to Schleife beendet werden, bevor 6 unterschiedliche Zahlen gezogen wurden.
Anschließend fügen wir die gezogene Zahl unserer Teilmenge hinzu. Da wir auch wissen wollen, ob wir richtig getippt haben, geben wir dann alle Lottozahlen auf dem Bildschirm aus. Da es sich bei den Lottozahlen um einen Aufzählungstyp handelt, sind diese automatisch von der kleinsten zur größten sortiert. Die Zusatzzahl dürften wir nicht in unsere Menge aufnehmen, sondern müssten diese gesondert speichern, da aus einer sortierten Liste nicht mehr die zuletzt gezogene Zahl zu erkennen wäre.

Für die Ziehung wäre auch der folgende Code möglich. Dieser zählt eine Zahl nur dann als gezogen, wenn es sich dabei um eine neue handelt:

i := 0;
repeat
  z := Random(49) + 1;
  if not (z in Lottozahlen) then begin
    Inc(i);
    Lottozahlen := Lottozahlen + [z];
  end;
until i = 6;

Mehr über die Verwendung von Schleifen erfahren Sie später.

Genauso, wie Sie über den Plus-Operator + Elemente in eine Menge aufnehmen können, entfernt der Minus-Operator - diese. Dabei können Sie jeweils auch mehrere Elemente gleichzeitig angeben. Normalerweise sollte man jedoch statt des Plus- und des Minusoperators die Funktionen include und exclude verwenden, weil diese effizienteren Code erzeugen. Mehrere direkt aufeinanderfolgende Elemente können mit dem Aufzählungszeichen .. angegeben werden:

Lottozahlen := [2, 3, 5];
Lottozahlen := Lottozahlen + [7, 11, 13];  // ergibt [2, 3, 5, 7, 11, 13]
Lottozahlen := Lottozahlen - [3, 7];       // ergibt [2, 5, 11, 13]
Lottozahlen := [1..4, 8, 16];              // ergibt [1, 2, 3, 4, 8, 16]

Mehrfaches Entfernen desselben Elementes ist dabei genauso ohne Fehlermeldung möglich wie mehrfaches Hinzufügen.

Verwechseln Sie Sets bitte nicht mit Arrays. Beide benutzen die eckigen Klammern, jedoch zu einem anderen Zweck. Man kann zum Beispiel bei einem Set nicht das dritte Element erfragen, indem man

z := Lottozahlen[3];

eingibt.

[Bearbeiten] Arrays

[Bearbeiten] Was sind Arrays?

Ein Array ist vereinfacht gesagt, eine Liste von Variablen.

[Bearbeiten] Arrays anlegen

Wir wollen eine Gästeliste mit 10 Gästen anfertigen. Bisher hätten wir in etwa folgendes gemacht:

var
  gast1, gast2, gast3, gast4, gast5, gast6, gast7, gast8, gast9, gast10: string;

Der Nachteil dieses Verfahrens liegt auf der Hand - spätestens wenn zwanzig Gäste kommen.

Nun erzeugen wir einfach ein Array vom Datentyp String mit 10 Elementen:

var
  gast: array[1..10] of string;

Die genaue Struktur der Array Deklaration ist:

array [startindex .. endindex] of Datentyp;

startindex..endindex ist dabei eine so genannte Bereichsstruktur mit dem wir den Bereich zwischen Startwert und Endwert angeben (Randwerte werden mit eingeschlossen). Näheres siehe Typdefinition. Es ist auch möglich, einen Bereich wie -3..5 anzugeben.

[Bearbeiten] Auf Arrays zugreifen

Um nun auf die einzelnen Elemente zuzugreifen, verwenden wir folgende Syntax:

gast[1] := 'Axel Schweiß';
gast[2] := 'Peter Silie';
gast[3] := 'Jack Pot';
...

Die Zahl in den eckigen Klammern ist der so genannte Index. Er gibt an, auf welche Variable des Arrays wir zugreifen wollen. Gültige Werte sind hier die Zahlen 1 bis 10. Ein weiterer Vorteil von Arrays ist, dass wir anstatt eines fixen Indexes auch einen ordinalen Datentyp angeben können. Das heißt z.B. eine Integer-Variable. Die Abfrage der Namen von 10 Gästen ließe sich also so sehr einfach implementieren:

var
  index: Integer;
  gast: array[1..10] of string;
begin
  for index := 1 to 10 do
  begin
    Writeln('Bitte geben Sie den Namen des ', index, '. Gastes ein:');
    Readln(gast[index]);
  end;
end.

[Bearbeiten] Dynamische Arrays

Ändern wir unser Szenario so ab, dass wir eine Gästeliste erstellen wollen, aber nicht wissen, wieviele Gäste diese beinhalten soll. Nun könnten wir zwar ein Array erzeugen, das auf jedenfall groß genug ist um alle Gäste aufzunehmen. Allerdings wäre dies eine Verschwendung von Speicher und nicht gerade effektiv. Hier kommen uns die dynamischen Arrays zu Hilfe. Dabei handelt es sich, wie man vielleicht vermuten kann, um Arrays, deren Länge man zur Laufzeit verändern kann. Erstellt werden sie praktisch genauso wie normale Arrays, nur geben wir diesmal keinen Wertebereich an:

var
  gast: array of string;

Der Wertebereich eines dynamischen Arrays ist zwar dynamisch, aber er beginnt zwingend immer mit 0. Zu Beginn hat dieser Array die Länge 0, d.h. er beinhaltet momentan keine Variablen.

[Bearbeiten] Länge des Arrays verändern

Nun verändern wir die Länge des Arrays auf 10:

SetLength(gast, 10);

Unser Array hat nun eine Länge von 10. Das bedeutet, wir können 10 Strings in ihm verstauen. Allerdings hat das höchste Element im Array den Index 9. Das liegt daran, dass das erste Element den Index 0 hat und wir daher mit dem Index 9 schon 10 Elemente zusammen haben.

Nun könnten wir zum Einlesen unserer Gästeliste so vorgehen:

var
  index, anzahlgaeste: Integer;
  gast: array of string;
begin
  Writeln('Bitte geben Sie die Anzahl der Gäste ein:');
  Readln(anzahlgaeste);
  SetLength(gast, anzahlgaeste);
  for index := 0 to anzahlgaeste-1 do
  begin
    Writeln('Bitte geben Sie den Namen des ', index + 1, '. Gastes ein:');
    Readln(gast[index]);
  end;
end.

Dies würde zwar zum gewünschten Erfolg führen, allerdings benötigen wir so ständig eine weitere Variable, die die Länge unseres Arrays angibt. Um dies zu umgehen, bedienen wir uns der Routinen High() und Low().

[Bearbeiten] Erster und letzter Index

Die Routine High() liefert den höchsten Index des übergeben Arrays zurück:

SetLength(gast, 10);
Writeln(High(gast));  // Ausgabe: 9
 
SetLength(gast, 120);
Writeln(High(gast));  // Ausgabe: 119

Die Methode Length() gibt, wie sich vermuten lässt, die Länge des Arrays zurück:

SetLength(gast, 10);
Writeln(Length(gast));  // Ausgabe: 10

Die Methode Low() liefert den ersten Index des übergebenen Arrays zurück. Bei einem dynamischen Array wäre dies immer 0. Daher benötigt man diese Methode in einem realen Programm eigentlich nicht. Lediglich bei Arrays mit festen Wertebereichen erhält diese Funktion einen tieferen Sinn.

Nun können wir unser Programm ein weiteres bisschen vereinfachen:

var
  index, anzahlgaeste: Integer;
  gast: array of string;
begin
  Writeln('Bitte geben Sie die Anzahl der Gäste ein:');
  Readln(anzahlgaeste);
  SetLength(gast, anzahlgaeste);
  for index := 0 to High(gast) do
  begin
    Writeln('Bitte geben Sie den Namen des ', index + 1, '. Gastes ein:');
    Readln(gast[index]);
  end;
end.

Der entstehende Vorteil ist hier zugegebener Maßen eher gering, aber in der Praxis erspart man sich so leidige Tipparbeit.

[Bearbeiten] Array freigeben

Da wir beim Erstellen des Arrays Speicher belegt haben, müssen wir diesen noch freigeben. Das geschieht ganz einfach mittels:

SetLength(gast, 0);

Dabei wird die Länge des Arrays wieder auf 0 gesetzt und er beansprucht so keinen weiteren Platz im Speicher mehr. Dies sollte man allerdings immer dann ausführen, wenn der verwendete Array nicht mehr benötigt wird. Unser finales Programm sieht also so aus:

var
  index, anzahlgaeste: Integer;
  gast: array of string;
begin
  Writeln('Bitte geben Sie die Anzahl der Gäste ein:');
  Readln(anzahlgaeste);
  SetLength(gast, anzahlgaeste);
  for index := 0 to High(gast) do
  begin
    Writeln('Bitte geben Sie den Namen des ', index + 1, '. Gastes ein:');
    Readln(gast[index]);
  end;
  SetLength(gast, 0);
end.

[Bearbeiten] Mehrdimensionale Arrays

Bis jetzt haben wir uns nur mit eindimensionalen Arrays beschäftigt. Wir haben in Pascal aber auch die Möglichkeit, mehrdimensionale Arrays anzulegen. Z.B. wollen wir nun den Vornamen und den Nachnamen auf unserer Gästeliste getrennt voneinander abspeichern. Dazu erzeugen wir zuerst ein Array mit zwei Elementen, eins für den Vornamen eins für den Nachnamen:

type
  TName = array[0..1] of string; // Index 0 = Vorname; 1 = Nachname

var
  gast: array of TName;

Und so einfach haben wir einen mehrdimensionalen Array erzeugt. Man kann sich diesen Array nun auch als Tabelle vorstellen. Es gibt eine Spalte für den Vornamen und eine weitere für den Nachnamen. Die Anzahl der Einträge (Zeilen) in dieser Tabelle ist dabei beliebig, da der zweite Array dynamisch ist.

Natürlich können wir das Ganze auch in einer einzelnen Zeile deklarieren:

var
  gast: array of array[0..1] of string;

Nun wollen wir unsere Gästeliste erneut einlesen:

var
  index, anzahlgaeste: Integer;
  gast: array of array[0..1] of string;
begin
  Writeln('Bitte geben Sie die Anzahl der Gäste ein:');
  Readln(anzahlgaeste);
  SetLength(gast, anzahlgaeste);
  for index := 0 to High(gast) do
  begin
    Writeln('Bitte geben Sie den Vornamen des ', index + 1, '. Gastes ein:');
    Readln(gast[index, 0]);
    Writeln('Bitte geben Sie den Nachnamen des ', index + 1, '. Gastes ein:');
    Readln(gast[index, 1]);
  end;
  SetLength(gast, 0);
end.

Wie zu erkennen ist, werden die Indizes innerhalb der Array-Klammern durch ein Komma getrennt.

[Bearbeiten] Records

[Bearbeiten] Was sind Records?

Records ermöglichen es, mehrere Variablen zu gruppieren. Dies ist beispielsweise dann hilfreich, wenn oft die gleiche Menge an Variablen benötigt wird, oder eine Menge Variablen logisch zusammengefasst werden soll. Eine weitere Situation in der Records unverzichtbar sind ist, wenn im Programm mehrere Datensätze gespeichert und verwaltet werden sollen, beispielsweise in einem Adressbuch

[Bearbeiten] Wie funktionieren Records?

Um zu unserem Beispiel vom Adressbuch zurückzukommen: Wir wollen alle Daten, also Vorname, Nachname, etc. in einem Record speichern. Dazu legen wir einen neuen Typ TPerson an, in dem wir alle Variablen auflisten:

type
  TPerson = record
    Vorname: string;
    Nachname: string;
    Anschrift: string;
    TelNr: string;
  end;

Wenn jetzt eine Variable vom Typ TPerson deklariert wird, enthält diese all diese Variablen:

var
  Person: TPerson;
begin
  Person.Vorname := 'Hans';
  Person.Nachname := 'Müller';
  ...
end;

Die Variablen im Record verhalten sich genauso wie „normale“ Variablen. Benötigt man ein Record nur zur einmaligen Strukturierung von Daten, ist es nicht nötigt, einen Verbund-Typ anzulegen:

var
  Datei: record
    Name, Pfad: string;
  end; 

[Bearbeiten] Die with-Anweisung

Falls Sie mit mehreren Record-Feldern nacheinander arbeiten wollen, ist es sehr mühselig, immer den Namen der Variablen vornweg zu schreiben. Diese Aufrufe lassen sich mithilfe der with-Anweisung ebenfalls logisch gruppieren:

with Person do
begin
  Vorname := 'Hans';
  Nachname := 'Müller';
  Anschrift := 'Im Himmelsschloss 1, 12345 Wolkenstadt';
  TelNr := '03417/123456';
end;

Es ist auch möglich, die With-Anweisung auf mehrere Records anzuwenden. Dazu müssen die Bezeichner zwischen with und do mit Kommas getrennt aufgezählt werden. Natürlich müssen die Records zum gleichen Typ gehören.

[Bearbeiten] Variante Teile in Records

Ein Record kann so genannte variante Teile enthalten. Dies sind Felder eines Records, die den gleichen Speicherplatz belegen, aber unterschiedliche Typen haben und/oder in verschiedener Anzahl vorhanden sind. Je nach verwendetem Bezeichner werden beim Schreiben und Lesen die Daten im Speicher entsprechend seines Typs anders interpretiert.

[Bearbeiten] Deklaration

Der variante Teil eines Records ähnelt dabei einer case-Anweisung bei der verzweigten Datenverarbeitung (siehe Abschnitt „Verzweigungen“). Der variante Teil wird ebenfalls mit case eingeleitet und steht immer am Ende der Record-Deklaration. Ein solches Record ist daher so aufgebaut:

type
  Typname = record
    Feld_1: Typ_1;
    Feld_2: Typ_2;
    ...
    Feld_n: Typ_n;
    case [Markierung:] Typ of
      Wert_1: (Feldliste_1);
      Wert_2: (Feldliste_2);
      ...
      Wert_n: (Feldliste_n);
  end;

Von Feld_1 bis Feld_n erstreckt sich der statische Teil des Records wie in den oberen Abschnitten beschrieben. Vom Schlüsselwort case bis zum abschließenden end; folgt der variante Teil. Anders als bei den Verzweigungen schließt hierbei das end sowohl den varianten Teil als auch das gesamte Record ab. Daraus ergibt sich, dass die varianten Teile immer am Ende stehen und keine statischen Teile mehr folgen können.

Die Markierung muss hierbei nicht angegeben werden. Sie dient zur Unterscheidung, welche der varianten Feldlisten die gültigen Daten enthält und kann daher wie die statischen Felder mit einem Wert belegt werden. Man sollte der Markierung immer einen eindeutigen Wert für die jeweilige Liste zuweisen, sobald man das Record mit Daten füllt. Beim Auslesen der Daten entscheidet dann der Wert der Markierung, welche varianten Felder abgefragt werden. In manchen Fällen werden Sie vielleicht keine Markierung benötigen, Sie können dann den Bezeichner und den Doppelpunkt weglassen. Ein Typ und eine Wertliste muss aber in jedem Falle (sozusagen fiktiv) angegeben werden, wobei Sie jeden Aufzählungstyp verwenden können, also auch selbst definierte.

Die Feldlisten werden für jeden Wert von Klammern eingeschlossen. Diese Liste selbst unterscheidet sich nicht von anderen Felddeklarationen, sie entspricht also der Form

VarFeld_1: Typ_1;
VarFeld_2: Typ_2;
...
VarFeld_n: Typ_n;

Dabei müssen Sie jedoch beachten, dass kein Typ mit variabler Größe verwendet werden darf, da der variante Teil immer einen festen Speicherplatz belegt. Es ist daher kein string (mit Ausnahme von ShortString), dynamisches Array und keine Varianten (Datentyp Variant) erlaubt. Es darf auch kein Record verwendet werden, dass einen solchen Typ enthält. Sie können stattdessen jedoch einen Zeiger auf solche Typen verwenden, da Zeiger immer eine feste Größe von 4 Byte haben.

[Bearbeiten] Speicherbelegung

Die Größe des varianten Teils bestimmt sich nach der größten Feldliste. Um Anordnung und Größe der Daten zu verstehen, betrachten Sie bitte folgendes Beispiel:

type
  TVarRecord = record
    StatischesFeld1: Byte;
    StatischesFeld2: Boolean;
    case Byte of
      0:
        (VariantesFeld1: Byte;
         VariantesFeld2: Integer);
      1:
        (VariantesFeld3: array[1..10] of Char);
      2:
        (VariantesFeld4: Double;
         VariantesFeld5: Boolean);
  end;

Dieses Record wird im Speicher folgendermaßen abgelegt:

Falls Sie eine Markierung verwenden, wird diese zwischen dem letzten statischen und dem Beginn der varianten Feldliste gespeichert, das Record vergrößert sich entsprechend dem Typ der Markierung.

Wichtig ist für die Verwendung von varianten Records auch, dass zu jeder Zeit jedes der varianten Felder gelesen und geschrieben werden kann. Es kann daher immer nur eine der Feldlisten gültige Werte enthalten; Sie können also nicht die verschiedenen Werte gleichzeitig speichern. Sobald Sie im obigen Beispiel VariantesFeld3 mit Daten füllen, ändert sich automatisch der Wert aller anderen varianten Felder. Sie müssen daher besonders aufpassen, dass Sie keine benötigten Daten mit ungültigen überschreiben, weil Sie versehentlich einen falschen Feldnamen benutzen. Delphi wird Sie hiervor weder bei der Kompilierung noch bei der Ausführung Ihres Programms warnen!

Geben Sie zur Verdeutlichung einmal folgendes Programm ein und starten Sie es. Die Ausgabe wird Sie überraschen!

program VariantRecord;

{$APPTYPE CONSOLE}

type
  TVarRec = packed record
    case Byte of
      0:
        (FByte: Byte;
         FDouble: Double);
      1:
        (FStr: ShortString);
  end;

var
  rec: TVarRec;

begin
  rec.FByte := 6;
  rec.FDouble := 1.81630607010916E-0310;

  // Der Speicherbereich von FByte und FDouble
  // wird jetzt als Zeichenkette interpretiert.
  Writeln(rec.FStr);
  Readln;
end.

Hinweis: Das Schlüsselwort packed sorgt dafür, dass die Felder des Records lückenlos im Speicher aneinander gereiht und nicht für einen schnelleren Zugriff optimiert abgelegt werden.

[Bearbeiten] Beispiel

In einem Adressbuch gibt es leider keine voneinander abhängigen Einträge, daher wenden wir uns wieder unserer Gastliste zu und erweitern diese.

Statt nur den Namen des Gastes zu speichern, wollen wir auch aufnehmen, ob der jeweilige Gast eingeladen ist, welche Gastnummer und welcher Platz ihm in diesem Falle zugewiesen wurde, oder ob sein Besuch andernfalls erwünscht ist. Wir können davon ausgehen, dass ein eingeladener Gast in jedem Fall erwünscht ist, benötigen hierzu also keine Information. Andererseits kann ein nicht eingeladener Gast keinen Platz und keine Gastnummer zugewiesen bekommen haben.

Diese Situation können wir in einem varianten Record darstellen:

type
  TGast = record
    Name, Vorname: string;  // bei statischen Feldern erlaubt
    case eingeladen: Boolean of
      True:
        (Platz, Gastnummer: Byte);
      False:
        (erwuenscht: Boolean);
  end;

  TGastListe = array of TGast;

var
  GastListe: TGastListe;
  Zaehler: Integer;
  Gast: TGast;

Name, Vorname und eingeladen sind bei jedem Gast vorhanden, die anderen Felder sollen (und dürfen) nur abhängig vom Wert des Feldes eingeladen verwendet werden. Nun können wir einige Gäste erfassen:

// Anzahl der Gäste festlegen
SetLength(GastListe, 4);

GastListe[0].Name := 'Schweiss';
GastListe[0].Vorname := 'Axel';
GastListe[0].eingeladen := False;
GastListe[0].erwuenscht := False;

GastListe[1].Name := 'Silie';
GastListe[1].Vorname := 'Peter';
GastListe[1].eingeladen := True;
GastListe[1].Platz := 42;
GastListe[1].Gastnummer := 1;

GastListe[2].Name := 'Pot';
GastListe[2].Vorname := 'Jack';
GastListe[2].eingeladen := False;
GastListe[2].erwuenscht := True;

GastListe[3].Name := 'Schluepfer';
GastListe[3].Vorname := 'Rosa';
GastListe[3].eingeladen := True;
GastListe[3].Platz := 14;
GastListe[3].Gastnummer := 2;

Anschließend wollen wir noch einen Türsteher beauftragen, die Meute am Eingang zu sortieren. Dazu schreiben wir in den Programmrumpf eine Funktion, die prüft, ob der Gast eingelassen werden kann (Hinweis: Zu der Verwendung von Funktionen, Schleifen und Verzweigungen erfahren Sie später mehr. Mit ein paar grundlegenden Englischkenntnissen lässt sich jedoch herausfinden, was die einzelnen Anweisungen bewirken.)

// Gast nur einlassen, wenn er eingeladen oder als nicht Eingeladener erwünscht ist
function GastEinlassen(AGast: TGast): Boolean;
begin
  if AGast.eingeladen then
    Result := True
  else
    Result := AGast.erwuenscht;
end;

Wenn der Gast eingeladen wurde, gibt diese Funktion True zurück, wenn er nicht eingeladen wurde, entsprechend, ob er erwünscht ist oder nicht.

Im Hauptprogramm läuft dann eine Schleife, die alle Gäste prüfen lässt und uns anzeigt, was unser Türsteher festgestellt hat.

// GastListe von Index 0 bis 3 durchlaufen
for Zaehler := 0 to 3 do begin
  Gast := GastListe[Zaehler];
  Writeln('Name: ', Gast.Vorname, ' ', Gast.Name);
  if GastEinlassen(Gast) then
    Writeln('einlassen: ja')
  else
    Writeln('einlassen: nein');
  if Gast.eingeladen then begin
    Writeln('Gastnummer: ', Gast.Gastnummer);
    Writeln('Sitzplatz: ', Gast.Platz);
  end;
  Writeln;
end;

Vergessen Sie nicht, am Ende des Programms den vom dynamischen Array verwendeten Speicher wieder freizugeben, indem Sie SetLength(GastListe, 0); aufrufen.

Wenn Sie das Programm ausführen, werden Sie folgende Ausgabe erhalten:

Name: Axel Schweiss
einlassen: nein

Name: Peter Silie
einlassen: ja
Gastnummer: 1
Sitzplatz: 42

Name: Jack Pot
einlassen: ja

Name: Rosa Schluepfer
einlassen: ja
Gastnummer: 2
Sitzplatz: 14

Wie Sie sehen, erlaubt diese Art von Records größere Flexibilität für die Programmierung. Sie birgt jedoch auch die Gefahr schwer zu entdeckender Fehler, wenn man nicht sorgfältig genug programmiert.

[Bearbeiten] Varianten

[Bearbeiten] Was sind Varianten?

Varianten sind dynamische Variablentypen. Das heißt, eine Variante kann verschiedene Variablentypen (Integer, String, usw.) annehmen. Strukturierte Datentypen, wie Records, Mengen, statische Arrays, Dateien, Klassen, Klassenreferenzen und Zeiger können jedoch nicht zugewiesen werden.

[Bearbeiten] Verwendung

Varianten werden häufig eingesetzt, wenn während der Entwicklung von Programmen der Datentyp einer Variable nicht bekannt ist oder sich während der Laufzeit ändert. Varianten bieten demnach die größtmögliche Flexibilität, jedoch verbrauchen sie mehr Speicher und verhalten sich während Operationen deutlich langsamer als statische Variablentypen.

Eine Variante benötigt 16 Bytes im Speicher und besteht aus einem Typencode und einem Wert oder einem Zeiger auf einen Wert, dessen Typ durch den Code festgelegt ist. Wenn eine Variante leer ist, bekommt sie den speziellen Wert Unassigned. Der Wert Null weist auf unbekannte oder fehlende Daten hin.

Um Varianten verwenden zu können, muss man die Unit Variants in die Uses-Klausel einbinden, falls diese dort noch nicht vorhanden ist. Die Zuweisung von Varianten erfolgt wie bei allen Variablen.

procedure Zuweisung;
var
  vExample: Variant;
begin
  vExample := 'Hallo';      // Stringzuweisung
  vExample := 3.141592;     // Gleitkommazuweisung
  vExample := 666;          // Integerzuweisung
end;

Beim Auslesen von Varianten wird es schon komplizierter. Zur Vereinfachung stellt Delphi die Funktion VarType zur Verfügung. Dem Befehl VarType muss die betreffende Variante mitgegeben werden. Auch wenn es sich um flexible Variablen handelt, muss man dennoch diverse Umwandlungsoperationen verwenden, wenn man z.B. eine Integer-Zahl als String ausgeben will.

procedure Auswertung(vExample: Variant);
begin
  case VarType(vExample) of
    varWord:   ShowMessage('Es ist ein Word: ' + IntToStr(vExample));
    varString: ShowMessage('Es ist ein String: ' + vExample);
    varDouble: ShowMessage('Es ist ein Double: ' + FloatToStr(vExample));
  end;
end;

Bei der Zuweisung von Ganzzahlen verwendet Delphi immer automatisch den kleinstmöglichen Datentyp. Im oberen Beispiel weisen wir die Zahl 666 zu. Diese hat kein Vorzeichen und ist größer als ein Byte. Da der nächstgrößere Datentyp ohne Vorzeichen Word ist, erhält die Variante den Typ varWord. Über die anderen ganzzahligen und ebenfalls passenden Datentypen, wie varInteger, lässt sich diese Variable dann nicht auswerten.

Eine vollständige Liste der von Delphi mitgelieferten Rückgabewerte von VarType(vExample) erhält man in der Delphi-Hilfe.

[Bearbeiten] Probleme

Unzulässige Operationen erzeugen bei statischen Variablen während des Kompilierens Fehler und können bereinigt werden. Bei Varianten treten jedoch erst zur Laufzeit Fehler auf, was die Fehlersuche und -bereinigung erschwert.

[Bearbeiten] Variablen

Eine Variable ist eine Möglichkeit, Daten innerhalb eines Programms zu speichern und zu verwenden. Eine Variable steht repräsentativ für einen Bereich im Speicher, in dem der Wert der Variablen gespeichert ist. Über den Variablennamen kann dann einfach auf diese Speicherstelle zugegriffen werden. Eine Variable besteht in Delphi also immer aus einem Namen, einem Typ und einer Adresse im Speicher.

Die Größe dieses Bereichs hängt vom Typ der Variablen ab. Es gibt vordefinierte (eingebaute) Variablentypen wie Integer, Real oder String und auch die Möglichkeit selbst neue Variablentypen zu definieren. Variablen müssen deklariert, d.h. bekannt gemacht werden, bevor sie im Programm verwendet werden können. Dies geschieht im sogenannten Deklarationsabschnitt (vor begin), der mit dem Schlüsselwort var eingeleitet wird:

var
  s: string;
begin
  ...
end.

Dies würde die Variable s vom Typ String erzeugen. Nun können wir mittels s auf die Zeichenkette zugreifen.

Es ist ebenfalls möglich, mehrere Variablen eines Typs gleichzeitig zu deklarieren, indem die Namen der Variablen mit Kommata getrennt werden.

var
  s, s2: string;
  i: Integer;
begin
  ...
end.

Dies deklariert sowohl zwei Variablen vom Typ String (s und s2), als auch eine (i) vom Typ Integer.

[Bearbeiten] Werte zuweisen und auslesen

Um mit Variablen arbeiten zu können, müssen diesen im Programmablauf Werte zugewiesen werden. Dies geschieht mit dem Operator :=. Dabei steht auf der linken Seite des Operators die Variable, die einen Wert erhalten soll und auf der rechten Seite der entsprechende Wert. Zuweisungen können nur im Anweisungsblock erfolgen:

begin
  s := 'Ich bin eine Zeichenkette!';
  i := 64;
end.

Der Wert einer Variablen lässt sich auslesen, indem man den Variablenbezeichner an jeder Stelle einsetzt, an dem auch der Wert direkt eingesetzt werden kann. Man kann also den Wert einer Variablen auf dem Bildschirm ausgeben, oder auch mit ihr Berechnungen anstellen:

begin
  s := 'Kannst du das lesen?';
  Writeln(s);      // Gleichbedeutend mit Writeln('Kannst du das lesen?');
  i := 17;
  i := i * 2;      // anschließend ist i = 34
end.

[Bearbeiten] Initialisierung von Variablen bei der Deklaration

Es ist sogar möglich (und auch ziemlich elegant) Variablen schon bei ihrer Deklaration einen Startwert mitzugeben. Damit kann man sich große Initialisierungsorgien nach dem begin ersparen.

var
  i: Integer = 42;
begin
  ...
end.

Die Initialisierung ist allerdings nur bei globalen Variablen möglich. Lokale Variablen von Prozeduren und Funktionen können dagegen auf diese Weise nicht mit Startwerten belegt werden.

[Bearbeiten] Konstanten

Falls man ungewollten Änderungen eines Wertes im Laufe des Programms vorbeugen will oder sich der Wert per definitionem niemals ändern wird, sollte man Konstanten anstelle von Variablen verwenden. Diese werden ähnlich wie initialisierte Variablen deklariert. Statt des Schlüsselwortes var wird jedoch const benutzt. Der Typ einer Konstanten ergibt sich aus automatisch aus deren Wert:

const
  Zahl = 115;       // Konstante vom Typ Integer
  Text = 'Wort';    // Konstante vom Typ String
  Buchstabe = 'B';  // sowohl als String wie auch als Char einsetzbar

Konstanten können überall dort verwendet werden, wo Sie auch Variablen einsetzen können. Es gibt jedoch einige Funktionen, die Variablen als Parameter erfordern, da sie deren Wert bei der Ausführung ändern. Diesen Funktionen bzw. Prozeduren können dann keine Konstanten übergeben werden.

var
  i: Integer = 1;

const
  c = 1;

begin
  Inc(i);  // erhöht i um 1
  Inc(c);  // Fehlermeldung, da c kein neuer Wert zugewiesen werden darf
end.

[Bearbeiten] Typisierte Konstanten

Typisierten Konstanten wird, wie der Name schon sagt, ein definierter Typ zugewiesen (statt dass der Typ aus dem Wert entnommen wird). Damit ist es möglich, einer Konstanten z.B. auch Records und Arrays zuzuweisen. Sie werden genau wie initialisierte Variablen definiert:

const
  a: Boolean = False;
  {konstantes Array der ersten 6 Primzahlen}
  Prim6: array[1..6] of Byte = (2, 3, 5, 7, 11, 13);

Standardmäßig werden typisierte Konstanten wie normale Konstanten behandelt, d.h. dass diese während der Laufzeit nicht geändert werden können. Man kann Delphi jedoch mit der Compiler-Direktive {$J+} anweisen, diese ähnlich wie Variablen zu behandeln. Free Pascal unterstützt Zuweisungen an typisierte Konstanten ohne weiteres.

[Bearbeiten] Operatoren

Wie kann man nun mit den vorhandenen Werten, Variablen und Konstanten arbeiten, also zum Beispiel rechnen, Werte übertragen oder vergleichen? Dazu benötigt man Operatoren. Einige davon haben Sie in den vorherigen Beispielen bereits kennen gelernt.

In diesem Kapitel erfahren Sie, welche Operatoren existieren und für welche Zwecke Sie diese verwenden können.

[Bearbeiten] Verwendete Begriffe

Im Zusammenhang mit Operatoren werden bestimmte Begriffe verwendet. Rätselraten ist nicht jedermanns Sache, deswegen wollen wir diese vorher klären.

Zum einen unterscheiden sich die Operatoren in binäre und unäre. Binär (aus dem lateinischen bini, „je zwei“ bzw. bina, „paarweise“) werden solche Operatoren genannt, die jeweils zwei Operanden benötigen, also z.B. X + Y oder 3 * a. Daneben gibt es noch die unären Operatoren (lat. unus „ein, einer“), welche nur einen Operanden haben. Hiermit sind die Vorzeichen + und - gemeint, die in Delphi ebenfalls direkt vor einer Zahl oder einer Variablen stehen, z.B. -21, +15.9 oder -X. Weitere unäre Operatoren sind der Wahrheits- und logische Operator not, der Adressoperator @, sowie der Zeigeroperator ^, der ausnahmsweise hinter dem Operanden steht.

[Bearbeiten] Allgemeine Operatoren

[Bearbeiten] Zuweisungsoperator :=

Wie in den vorangegangen Beispielen schon kurz beschrieben, ist der Operator := für Zuweisungen von Werten an Variablen bestimmt. Hierbei steht auf der linken Seite die Variable, die einen Wert erhalten soll (hier sind nur Variablen, Klasseneigenschaften, sowie - mit entsprechender Kompilierung (siehe vorheriges Kapitel) - zuweisbare typisierte Konstanten erlaubt). Auf der rechten Seite können z.B. feste Werte stehen, Konstanten, andere Variablen, Klasseneigenschaften, Funktionsaufrufe und so weiter. Der Datentyp auf der rechten Seite muss dabei kompatibel zum Datentyp der Variablen auf der linken Seite sein.

const
  Konstante = 255;

var
  Fliesskomma: Double;
  Ganzzahl: Integer;
  Text: string;
  Zeichen: Char;

begin
  Fliesskomma := 6.5;  // erlaubt
  Fliesskomma := 20;   // erlaubt
  Ganzzahl := 5;       // erlaubt
  Ganzzahl := 17.385;  // nicht erlaubt, da nicht kompatibel
  Text := 'Hallo';
  Zeichen := 'Z';      // erlaubt, da nur 1 Zeichen
  Zeichen := 'Hallo';  // nicht erlaubt, da mehrere Zeichen = Zeichenkette
end.

[Bearbeiten] Adressoperator @

Mit dem Adressoperator @ lässt sich die Speicheradresse jeder Variablen, Routine oder Klassenmethode ermitteln. Nicht erlaubt sind Typen, Konstanten, Interfaces und konstante Werte. Der Adressoperator gibt einen generischen Zeiger (Typ Pointer) auf die jeweilige Speicheradresse zurück.

[Bearbeiten] Arithmetische Operatoren

Die arithmetischen Operatoren verwenden Sie für Berechnungen. Wie im „echten Leben“ gilt auch hier die Regel: Punktrechnung geht vor Strichrechnung. Wenn Sie also keine Klammern setzen, wird immer zuerst multipliziert und geteilt, bevor Addition und Subtraktion erfolgen. In Delphi gibt es außerdem noch weitere Operatoren, daher erfahren Sie am Ende dieses Kapitels, in welcher Rangfolge diese zueinander stehen.

Folgende arithmetische Operatoren gibt es:

Der Ergebnistyp richtet sich nach den Datentypen der Operanden. Ist mindestens einer davon ein Fließkommatyp, so trifft dies auch auf das Ergebnis zu. Nur, wenn ausschließlich ganzahlige Typen verwendet werden, ist auch das Ergebnis ganzzahlig. Bei der Gleitkommadivision mittels / erhalten Sie, wie der Name schon sagt, immer eine Gleitkommazahl als Ergebnis. Bei div und mod erhalten Sie hingegen immer eine Ganzzahl, daher wird bei div das Ergebnis immer auf die nächste Ganzzahl abgerundet.

[Bearbeiten] Wahrheitsoperatoren

Die Wahrheitsoperatoren werden nach dem englischen Mathematiker George Boole auch Boolesche Operatoren genannt. Diese verknüpfen verschiedene Wahrheitswerte miteinander und geben als Ergebnis wieder einen Wahrheitswert zurück. Als Operanden sind daher nur solche Ausdrücke erlaubt, die sich sozusagen mit „wahr“ oder „falsch“, bzw. „ja“ oder „nein“ beantworten lassen. Es sind auch Vergleiche als Operanden möglich, diese müssen dann in Klammern gesetzt werden.

• Die Verneinung not kehrt den Wert des Operanden um.
• Die Und-Verknüpfung and ergibt nur dann „wahr“, wenn beide Operanden wahr sind.
• Die Oder-Verknüpfung or ergibt „wahr“, wenn mindestens 1 Operand wahr ist.
• Die exklusive Oder-Verknüpfung xor ergibt hingegen nur „wahr“, wenn genau 1 Operand wahr ist.

Eine Und-Verknüpfung ergibt immer „falsch“, sobald ein Operand falsch ist. Aus diesem Grund bietet Delphi die Möglichkeit, alle weiteren Prüfungen abzubrechen, wenn bereits der erste Operand „falsch“ ist. Diese vollständige Auswertung kann mit {B-} deaktiviert werden, was bei Delphi bereits voreingestellt ist.

[Bearbeiten] Logische Operatoren

Die logischen Operatoren verwendet man zum bitweisen Auswerten und Ändern von Ganzzahlen. Sie verhalten sich so ähnlich wie die Wahrheitsoperatoren. Bei den Wahrheitsoperatoren wird immer nur 1 Bit bearbeitet und dieses als „wahr“ oder „falsch“ interpretiert. Die logischen Operatoren hingegen verwenden mehrere Bits gleichzeitig, das Ergebnis ist dann jeweils wieder eine neue Zahl.

Exkurs: binäres Zahlensystem

Um mit der bitweisen Verschiebung zu arbeiten, muss man sich im binären Zahlensystem auskennen. Jede Zahl setzt sich dabei aus den einzelnen Zahlwerten 2⁰, 2¹, 2²,...2ⁿ zusammen. Die 2 bedeutet hierbei, dass es nur zwei Möglichkeiten gibt, also 0 oder 1. „n“ ist das für den Zahltyp höchstmögliche Bit. Das kleinste Bit steht dabei ganz rechts, das höchste links.

Ein kurzer Überblick, bezogen auf ein Byte:

Die 17 hat damit den Binärcode 00010001 und errechnet sich aus 1*2⁴ + 1*2⁰. 17 shl 2 ergibt somit 01000100 = 1*2⁶ + 1*2² = 64 + 4 = 68.

Merke: Es gibt nur 10 Typen von Menschen - solche, die Binärcode lesen können, und solche, die es nicht können!

[Bearbeiten] Vergleichsoperatoren

Wie der Name schon sagt, dienen diese Operatoren dazu, zwei Werte miteinander zu vergleichen. Die Datentypen auf beiden Seiten des Operators müssen zueinander kompatibel sein. Als Ergebnis erhält man immer einen Wahrheitswert, also true oder false.

[Bearbeiten] Zeichenkettenoperatoren

Bis auf die Vergleichsoperatoren gibt es für Zeichenketten nur den Operator +, mit dem man zwei Zeichenketten oder eine Zeichenkette mit einem einzelnen Zeichen verketten kann.

Beispiele:

'Hallo' + ' Welt' ergibt 'Hallo Welt'

'Hallo Welt" + Chr(33) ergibt 'Hallo Welt!'

[Bearbeiten] Mengenoperatoren

Mengen können ebenfalls auf einfache Weise bearbeitet werden. Hierfür stehen folgende Operatoren zur Verfügung:

Hinweis: Bei in muss der erste Operand ein Einzelwert vom Typ der Elemente der geprüften Menge sein. Alle anderen Operatoren erfordern Mengen auf beiden Seiten.

[Bearbeiten] Zeigeroperatoren

Für die Arbeit mit Zeigern sind die folgenden Operatoren bestimmt:

Bei der Addition und Subtraktion können immer nur Zeiger auf Zeichen verwendet werden, also PChar, PAnsiChar und PWideChar. Es kann immer nur eine Ganzzahl zu einem solchen Zeiger addiert werden, was bedeutet, dass die Adresse um diese Anzahl Zeichen nach hinten verschoben wird. Die Subtraktion funktioniert hierbei genauso, verschiebt den Zeiger jedoch nach vorne. Man kann auch zwei Zeichenzeiger voneinander subtrahieren. In diesem Falle erhält man eine Ganzzahl, die die Differenz zwischen beiden Zeigeradressen angibt (den so genannten Offset).

Die Dereferenz ist bei allen typisierten Zeigern möglich, man erhält damit den Zugriff auf die Daten, die an dieser Speicheradresse liegen. Da beim generischen Typ Pointer die Art der Daten an dessen Speicheradresse nicht bekannt ist, kann bei Variablen dieses Typs keine Dereferenzierung verwendet werden.

Der Vergleich zweier Zeiger mittels = und <> erfolgt nur in Bezug auf die Speicheradresse, auf die diese zeigen, nicht auf den Inhalt der Daten an diesen Adressen. Also nur, wenn bei beiden Zeigern die Speicheradresse identisch ist, gibt der Operator = den Wert true zurück. Ein kleines Beispiel:

var
  p1, p2: ^Integer;

begin
  New(p1);            // Speicher für den 1. Zeiger reservieren
  New(p2);            // Speicher für den 2. Zeiger reservieren
  p1^ := 200;         // an beiden Speicheradressen werden dieselben Daten abgelegt
  p2^ := 200;         // oder: p2^ := p1^;
  Writeln(p1 = p2);   // Ausgabe: FALSE
  Writeln(p1 <> p2);  // Ausgabe: TRUE
  Dispose(p2);        // Speicher des 2. Zeigers freigeben
  p2 := p1;           // Adresse des 2. Zeigers auf die des 1. setzen
  Writeln(p1 = p2);   // Ausgabe: TRUE
  Writeln(p1 <> p2);  // Ausgabe: FALSE
  Dispose(p1);
end.

[Bearbeiten] Klassenoperatoren

Um mit Klassen zu arbeiten, können folgende Operatoren verwendet werden:

Bei den Vergleichen mittels = und <> müssen zwei Klasseninstanzen als Operanden angegeben werden. Da es sich bei Klasseninstanzen intern um Zeiger handelt, funktionieren diese beiden Operatoren genau wie oben bei den Zeigeroperatoren beschrieben.

Mit dem Operator is kann geprüft werden, ob eine Klasseninstanz von einem bestimmten Klassentyp bzw. von diesem abgeleitet ist. Links steht dabei die Klasseninstanz, rechts der zu prüfende Klassentyp.

Mittels as lässt sich eine Klasseninstanz wie ein anderer Klassentyp interpretieren. Der Klassentyp auf der rechten Seite muss dabei ein Nachfahre der Instanz auf der linken Seite sein und die Instanz muss als dieser Typ erstellt worden sein. Daher muss vorher mittels is geprüft werden, ob die Instanz auch den benötigten Typ hat.

Da sich alle Klassen von TObject ableiten, kann man hiermit generisch verschiedene Klassen in seiner Anwendung „herumreichen“. Je nachdem, welcher Typ dann tatsächlich vorliegt, können die entsprechenden Methoden aufgerufen werden. Das Thema Klassenoperationen wird ausführlich in einem späteren Kapitel behandelt.

[Bearbeiten] Rangfolge der Operatoren

Die verschiedenen Operatoren werden in einer bestimmten Reihenfolge ausgeführt. Wenn man nichts anderes benötigt, gilt auch in Delphi der Satz „Punktrechnung vor Strichrechnung“. Hier ist eine kleine Übersicht, in welcher Rangfolge alle Operatoren zueinander stehen.

Die höherwertigsten Operationen werden immer zuerst ausgeführt, gleichrangige von links nach rechts. Um die Reihenfolge zu ändern, muss man die gewünschten vorrangigen Operationen in Klammern setzen (z.B. 1 + 2 * 3 ergibt 7, (1 + 2) * 3 hingegen 9).

[Bearbeiten] Eingabe und Ausgabe

Um mit dem Benutzer zu kommunizieren, muss der Computer die eingegebenen Daten (Input) speichern, verarbeiten und dann später ausgeben (Output). Um das Verarbeiten kümmert sich das nächste Kapitel; in diesem Kapitel dreht sich alles um das Ein- und Ausgeben von Daten.

[Bearbeiten] Eingaben erfassen

Kommen wir nun zu unserem eigentlichen Ziel, dem Einlesen und Verarbeiten von Eingaben auf der Konsole. Unser Ausgangs-Programm:

program Eingabeerfassung;
  
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
var
 ...
begin
  ...
  Readln;
end.

Nun erweitern wir den Anweisungsblock um die Ausgabe der Nachricht: 'Bitte geben Sie ihren Vornamen ein:'; Dies sollte kein größeres Problem darstellen. Als nächstes legen wir eine Variable an, in der wir den Vornamen des Benutzers speichern wollen. Wir fügen also

Vorname: string;

in den "Var-Abschnitt" ein. Nun wollen wir den Vornamen von der Konsole einlesen und in der Variable Vorname speichern dies geschieht mittels:

Readln(Vorname);

Vorname wird hier der Methode Readln als Parameter übergeben. Da es sich bei der Methode Readln um eine sehr spezielle Funktion handelt, gehen wir nicht näher auf dieses Konstrukt ein. Uns genügt die Tatsache, dass sich der in die Konsole eingegebene Text, nach dem Ausführen des Befehls in der Variable Vorname befindet.

[Bearbeiten] Variablen ausgeben

Ähnlich der Eingabe mit Readln, kann man mit Writeln Variablen ausgeben. Beispielsweise so:

Writeln(Vorname);

Nun wird der gerade eingegebene Vorname auf dem Bildschirm ausgegeben.

Schreiben wir jetzt das erste Programm, das aus der Eingabe eine Ausgabe „berechnet“, denn dazu sind Programme im Allgemeinen da.

Unser Programm soll den Benutzer fragen, wie er heißt und ihn dann mit dem Namen begrüßen, und zwar so, dass er die Begrüßung auch sieht.

program Eingabeerfassung;
  
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
var
  Vorname: string;

begin
  Writeln('Wie heisst du?');
  Readln(Vorname);
  Writeln('Hallo '+Vorname+'! Schoen, dass du mal vorbeischaust.');
  Readln;
end.

Hier wird deutlich, dass Writeln irgendeinen String benötigt. Dabei ist es egal, ob dieser aus einer Variablen stammt, direkt angegeben wird oder wie hier eine Kombination von beidem darstellt.

Alternativ zum Verketten von Strings kann man übrigens auch folgende Schreibweise nutzen:

Writeln('Hallo ', Vorname, '! Schoen, dass du mal vorbeischaust.');

[Bearbeiten] Verzweigungen

In diesem Kapitel wollen wir uns mit dem Verarbeiten von Benutzer-Eingaben mittels If-Abfragen beschäftigen.

[Bearbeiten] If-Abfrage (Wenn-Dann-Sonst)

[Bearbeiten] Aufbau

Bisher hat der Computer auf jede Eingabe in gleicher Art reagiert. Nun wollen wir beispielsweise, dass der Computer nur Hugo begrüßt. Dazu brauchen wir eine so genannte „If-Abfrage“. Dabei überprüft der Computer, ob ein bestimmter Fall wahr (true) oder falsch (false) ist. Die Syntax sieht, da in Pascal ja alles im Englischen steht, so aus:

if Bedingung then Anweisung

Die Bedingung ist dabei eine Verknüpfung von Vergleichen, oder ein einzelner Wahrheitswert. Aber dazu später mehr. Erstmal wollen wir uns dem Vergleichen widmen:

Es gibt in Delphi die folgenden sechs Vergleichsoperatoren:

[Bearbeiten] Einfache if-Abfragen

Nun aber erstmal wieder ein Beispiel, bevor wir zu den Verknüpfungen weitergehen:

Wir wollen jetzt nachgucken, ob Hugo seinen Namen eingegeben hat. Dazu setzen wir vor den Befehl Writeln('Hallo '+Vorname+'! Schoen, dass du mal vorbeischaust.'); die folgende If-Abfrage:

if Vorname = 'Hugo' then

Der Fall ist hier gegeben, wenn der eingegebene Vorname „Hugo“ ist. Dabei steht Vorname nicht in Apostrophen, da es der Name der Variablen ist. Hugo ist jedoch der Wert, mit dem die Variable verglichen werden soll, so dass hier die Apostrophe zwingend sind.

Das gesamte Programm sieht jetzt also so aus:

program Eingabeerfassung;
  
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
var
  Vorname: string;

begin
  Writeln('Wie heisst du?');
  Readln(Vorname);
  if Vorname = 'Hugo' then
    Writeln('Hallo '+Vorname+'! Schoen, dass du mal vorbeischaust.');
  Readln;
end.

[Bearbeiten] Erweiterte if-Abfragen mit „sonst“

Wer dieses Programm einmal getestet hat, wird festgestellt haben, dass es keine weitere Ausgabe gibt, wenn der eingegebene Name ungleich „Hugo“ ist. Dies wollen wir nun ändern. Dazu erweitern wir unsere Syntax ein klein wenig:

if Bedingung then Anweisung else Anweisung

Die auf else folgende Anweisung wird dann aufgerufen wenn die Bedingung der if-Abfrage nicht zutrifft (also false ist). Unser so erweitertes Programm sieht nun also in etwa so aus:

program Eingabeerfassung;
  
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
var
  Vorname: string;

begin
  Writeln('Wie heisst du?');
  Readln(Vorname);
  if Vorname = 'Hugo' then
    Writeln('Hallo '+Vorname+'! Schoen, dass du mal vorbeischaust.')
  else
    Writeln('Hallo '+Vorname+'! Du bist zwar nicht Hugo, aber trotzdem willkommen.');
  Readln;
end.

[Bearbeiten] Zusammenhang mit dem Typ Boolean

If-Abfragen hängen eng mit dem Typ Boolean zusammen: So können Booleans den Wahrheitswert der Abfrage speichern, indem ihnen die Bedingung „zugewiesen“ wird:

var
  IstHugo: Boolean;
  ...
begin
  ...
  IstHugo := Vorname = 'Hugo';
  ...
end.

Diese Variable kann jetzt wiederum in if-Abfragen verwendet werden:

if IstHugo then
  ...

Für Boolean-Variablen ist also kein Vergleich nötig, da sie bereits einen Wahrheitswert darstellen.

[Bearbeiten] Verknüpfung von Bedingungen

Wollen wir jetzt mehrere Bedingungen gleichzeitig abfragen, wäre es natürlich möglich, mehrere if-Abfragen zu schachteln:

program Eingabeerfassung2;
  
{$APPTYPE CONSOLE}
 
uses
  SysUtils;
 
var
  Vorname, Nachname: string;
begin
  Writeln('Wie ist dein Vorname?');
  Readln(Vorname);
  Writeln('Wie ist dein Nachname?');
  Readln(Nachname);
  if Vorname = 'Hugo' then
    if Nachname = 'Boss' then
      Writeln('Hallo '+Vorname+' '+Nachname+'! Schoen, dass du mal vorbeischaust.');
  Readln;
end.

Hier fallen aber gleich mehrere Probleme auf:

• Für komplizierte Abfragen wird dies sehr unübersichtlich
• Wollten wir eine Nachricht an alle abgeben, die nicht „Hugo Boss“ heißen, müssten wir für jede der if-Abfragen einen eigenen else-Zweig erstellen.

Um diese Probleme zu lösen, wollen wir die beiden Abfragen in eine einzelne umwandeln. Dazu bietet Delphi den and-Operator, mit dem wir zwei Vergleiche mit „und“ verknüpfen können. Alles was wir tun müssen, ist um jeden der Vergleiche Klammern und ein „and“ dazwischen setzen:

  ...
  if (Vorname = 'Hugo') and (Nachname = 'Boss') then
    Writeln('Hallo '+Vorname+' '+Nachname+'! Schoen, dass du mal vorbeischaust.')
  else
    Writeln('Hallo '+Vorname+' '+Nachname+'! Du bist zwar nicht Hugo Boss, aber trotzdem willkommen.')
  ...

and ist nicht der einzige Operator:

[Bearbeiten] Fallunterscheidung (case)

If-Abfragen können schnell unübersichtlich werden, wenn man mehrere Werte unterschiedlich behandeln möchte. Für solche Fälle steht das Werkzeug für die Fallunterscheidung zur Verfügung, die Case-Abfrage. Mit ihrer Hilfe wird nur einmal der Wert einer Variablen abgerufen und das Programm springt dann direkt an die Stelle, die für den entsprechenden Wert ausgeführt werden soll. Eine Case-Abfrage ist folgendermaßen aufgebaut:

case <Variable> of
  Wert1:
    <Anweisung>
  Wert2:
    <Anweisung>
  Wert3, Wert4:
    <Anweisung>
  ...
else
  <Anweisung>
end;

Mehrere Anweisungen können in einen begin...end Block eingeschlossen werden.

Sollen bei verschiedenen Werten die gleichen Aktionen ausgeführt werden, können diese Werte mit Kommata von einander getrennt werden. Ebenfalls möglich ist die Angabe eines ganzen Wertebereichs in der Form Wert1..Wert4. Hierbei ist jedoch zu beachten, dass immer nur ein einzelner Wert einer einzelnen Variablen ausgewertet wird. Eine Verknüpfung wie bei der If-Abfrage ist so nicht möglich, dies ginge nur in einer weiteren verschachtelten Case- oder If-Abfrage.

Die Angabe eines else-Abschnitts ist optional. Besitzt die Variable einen Wert, der nicht angegeben wurde, werden die Anweisungen hinter else ausgeführt. Fehlt else, wird die Abfrage ohne weitere Aktionen verlassen.

Ein anderer (großer) Nachteil der Case-Abfrage liegt darin, dass diese nur Aufzählungsdatentypen verarbeiten kann. Der sehr häufig abgefragte Datentyp string kann nicht mit case verwendet werden. Unser obiges Beispiel lässt sich daher nicht auf Case-Abfragen umstellen, wir nehmen also ein neues: Die Auswertung von Zeichen.

var
  Zeichen: Char;

begin
  Write('Geben Sie bitte ein Zeichen ein: ');
  Readln(Zeichen);

  Write('Das Zeichen war ');
  case Zeichen of
    #0..#31:
      Writeln('ein Steuerzeichen.');
    'a'..'z':
      Writeln('ein Kleinbuchstabe.');
    'A'..'Z':
      Writeln('ein Grossbuchstabe.'); 
    '0', '2', '4', '6', '8':
      Writeln('eine gerade Ziffer.');
    '1', '3', '5', '7', '9':
      Writeln('eine ungerade Ziffer.');
    '.':
      Writeln('ein Punkt.');
    ',':
      Writeln('ein Komma.');
  else
    Writeln('eines, auf das ich nicht programmiert bin.');
  end;
  Readln;
end.

Das Programm fordert wieder zur Eingabe auf und erwartet diesmal ein einzelnes Zeichen. Sollte mehr eingegeben werden, „ignoriert“ Readln einfach den Rest. Bei der anschließenden Auswertung springt das Programm nun an die entsprechende Stelle der Case-Abfrage. Ist dort das eingegebene Zeichen nicht aufgelistet, wird der Text unter else ausgegeben.

Zu den Aufzählungstypen zählt neben Ganzzahlen und Zeichen im Übrigen auch Boolean. Solche Variablen können Sie daher auch in einer Case-Abfrage verarbeiten.

[Bearbeiten] Schachtelungen

Bisher haben wir bei unseren Abfragen immer nur einen einzelnen Befehl ausgeführt. Natürlich ist es aber auch möglich, mehrere Befehle nacheinander auszuführen, wenn die Bedingung erfüllt ist.

Dabei wäre es unübersichtlich, für jeden Befehl eine neue If-Abfrage zu starten, wie hier:

if IstHugo then Writeln('Hallo Hugo!');
if IstHugo then Writeln('Wie geht es dir?');

Man kann die Befehle, die zusammen gehören auch schachteln. Dann ist nur noch eine If-Abfrage nötig.

Die zu schachtelnden Befehle werden dabei zwischen ein begin und ein end geschrieben. Diese Schachtel wird nun als ein eigenständiger Befehl angesehen. Deshalb muss das end oftmals mit einem Semikolon geschrieben werden.

Beispiel:

var
  ErsterAufruf: Boolean;
begin
  ...

  if ErsterAufruf then
  begin
    WriteLn('Dies ist der erste Aufruf!');
    ErsterAufruf := False;
  end;
 
  ...
end.

In diesem Fall wird, sofern "ErsterAufruf" wahr (True) ist, eine Nachricht ausgegeben und ErsterAufruf auf False gesetzt. Schachtelungen werden vor allem in Zusammenhang mit if-Abfragen und Schleifen angewandt.

Wie man in dem Beispiel auch erkennen kann, ist es üblich, die geschachtelten Befehle einzurücken, um die Übersichtlichkeit zu verbessern.

[Bearbeiten] Schleifen

[Bearbeiten] Die while-Schleife (Kopfgesteuerte-Schleife)

Die while-Schleife ermöglicht es, einen Programmcode so oft auszuführen, solange eine Bedingung erfüllt ist. Ist die Bedingung schon vor dem ersten Durchlauf nicht erfüllt, wird die Schleife übersprungen.

while <Bedingung> do
  <Programmcode>

Hierbei wird vor jedem Durchlauf die Bedingung erneut überprüft.

Beispiel:

var
  a, b: Integer;
begin
  a := 100;
  b := 100;
  while a >= b do
  begin
    WriteLn('Bitte geben Sie einen Wert < ', b, ' ein.');
    Readln(a);
  end;
end.

Die Schleife wird mindestens einmal durchlaufen, da zu Beginn die Bedingung 100 = 100 erfüllt ist.

[Bearbeiten] Die repeat-until-Schleife

Die repeat-until-Schleife ähnelt der while-Schleife. Hier wird die Bedingung jedoch nach jedem Durchlauf überprüft, so dass sie mindestens einmal durchlaufen wird.

repeat
  <Programmcode>
until <Bedingung>;

Des Weiteren wird die repeat-until-Schleife im Gegensatz zur while-Schleife so lange durchlaufen, bis die Bedingung erfüllt ist.

Das obere Beispiel:

var
  a, b: Integer;
begin
  b := 100;
  repeat
    WriteLn('Bitte geben Sie einen Wert < ', b, ' ein.');
    Readln(a);
  until a < b;
end.

Hier ist dieser Schleifentyp von Vorteil, da die Initialisierung von a entfällt, weil die Schleife mindestens einmal durchlaufen wird.

Ein weiterer Vorteil der repeat-until-Schleife ist, dass sie die einzige Schleife ist, die ohne Schachtelung auskommt, da der Programmcode von repeat und until bereits eingegrenzt ist. Bei den anderen Schleifen folgt der Programmcode immer der Schleifendeklaration.

[Bearbeiten] Die for-to-/for-downto-Schleife

Im Gegensatz zu den anderen beiden Schleifentypen basiert die for-Schleife nicht auf einer Bedingung, sondern auf einer bestimmten Anzahl an Wiederholungen.

 for variable := <untergrenze> to <obergrenze> do
   <Programmcode>

 for variable := <obergrenze> downto <untergrenze> do
   <Programmcode>

Der Unterschied zwischen den beiden Schleifen liegt darin, dass die erste von unten nach oben, die zweite jedoch von oben nach unten zählt. Falls die Untergrenze größer als die Obergrenze ist, wird jedoch nichts ausgeführt. (Beinahe) derselbe Effekt lässt sich mit einer while-Schleife erreichen:

Beispiele:

for i := 0 to 4 do
  WriteLn(i);

Ausgabe:
0
1
2
3
4

for i := 4 downto 0 do
  WriteLn(i);

Ausgabe:
4
3
2
1
0

for i := 4 to 3 do
  WriteLn(i);

Ausgabe:
-keine-

for i := 4 to 4 do
  WriteLn(i);

Ausgabe:
4

Es ist auch möglich, als Ober- und/oder Untergrenze Variablen anzugeben:

for i := a to b do
  WriteLn(i);

Die Schleife verhält sich hierbei genauso wie die Variante mit Konstanten.

Als Variablentyp ist nicht nur Integer erlaubt: for-Schleifen unterstützen alle Ordinalen Typen, also Integer, Aufzählungen und Buchstaben.

Beispiele:

var
  i: Integer;
begin
  for i := 0 to 10 do
    WriteLn(i);
end.

var
  c: Char;
begin
  for c := 'a' to 'z' do
    WriteLn(c);
end.

type
  TAmpel = (aRot, aGelb, aGruen);
var
  ampel: TAmpel;
begin
  for ampel := aRot to aGruen do
    WriteLn(Ord(ampel));
end.

Im Gegensatz zu while- und repeat-until-Schleifen darf in einer for-Schleife die Bedingungsvariable nicht geändert werden. Daher führt folgender Abschnitt zu einer Fehlermeldung:

for i := 0 to 5 do
begin
  i := i - 1;  // <-- Fehler
  WriteLn(i);
end;

[Bearbeiten] Die for-in-Schleife

Bei dieser, erst in neueren Delphi-Versionen vorhandenen Schleifenart, handelt es sich um eine aus Listen auswählende Schleife. Diese geht alle Elemente einer Liste durch und übergibt an die Laufvariable jeweils den aktuellen Listeneintrag. Die Anzahl der Durchläufe bestimmt sich durch die Länge der Liste. Die for-in-Schleife ist folgendermaßen aufgebaut:

for variable in liste do
  <Anweisung>;

Der Begriff „Liste“ ist hierbei recht weit gefasst. Als Listenvariable kann sowohl ein Array, wie auch ein Set oder ein String verwendet werden. Auch einige Klassen (z.B. TList, TStrings oder TToolBar) unterstützen diese Auswertung.

Der Typ der Laufvariablen muss immer einem einzelnen Element der Liste entsprechen. Bei String wäre dies Char, bei einem array of Byte der Typ Byte.

Der Vorteil der for-in-Schleife liegt darin, dass man eine Zählvariable spart und an Ort und Stelle den Werte eines Listenelements geliefert bekommt. Vor allem muss man hierbei die Grenzen der Liste nicht kennen oder auswerten, also mit welchem Index sie beginnt und endet.

Die folgenden beiden Beispiele sind gleichbedeutend:

{ ab Delphi 2005 }
var
  Lottozahlen: array[1..6] of Byte = (2, 3, 5, 7, 11, 13);
  Element: Byte;

begin
  for Element in Lottozahlen do
    Writeln(Element);
end.

{ vor Delphi 2005 }
var
  Lottozahlen: array[1..6] of Byte = (2, 3, 5, 7, 11, 13);
  Zaehler: Byte;

begin
  for Zaehler := 1 to 6 do
    Writeln(Lottozahlen[Zaehler]);
end.

[Bearbeiten] Vorzeitiger Abbruch einer Schleife

In manchen Fällen ist es hilfreich, dass nicht jeder Schleifendurchgang komplett ausgeführt wird, oder dass die Schleife bereits früher als von der Schleifenbedingung vorgegeben verlassen werden soll. Hierfür stehen die Routinen Continue und Break zur Verfügung.

Beispiel: Sie suchen in einer Liste von Strings eine bestimmte Zeichenfolge:

var
  a: array[1..5] of string;
  i: Integer;
  e: Boolean;

begin
  a[1] := 'Ich';
  a[2] := 'werde';
  a[3] := 'dich';
  a[4] := 'schon';
  a[5] := 'finden!';

  e := False;
  i := 1;

  repeat
    if a[i] = 'dich' then e := True;
    Inc(i);
  until e or (a > 5);

  if i <= 5 then
    WriteLn('Das Wort "dich" wurde an Position ' + IntToStr(i - 1) + ' gefunden.')
  else
    WriteLn('Das Wort "dich" wurde nicht gefunden.');
end.

In diesem Beispiel steht das gesuchte Wort „dich“ an der Position 3 in der Liste. Um nicht alle Elemente durchzusuchen, haben wir hier eine repeat-until-Schleife verwendet, die dann beendet wird, sobald das Wort gefunden wird.

Einfacher wäre eine for-Schleife. Diese durchsucht jedoch grundsätzlich alle Elemente und gibt dann, wenn sie nicht vorher abgebrochen wird, immer den letzten Zählwert zurück. Um den rechtzeitigen Abbruch zu erreichen, verwenden wir Break:

  for i := 1 to 6 do
  begin
    if i = 6 then
      Break;
    if a[i] = 'dich' then
      Break;
  end;

Hier benötigen wir weder eine Prüfvariable, noch muss i vorher initialisiert werden. Zuerst wird geprüft, ob wir schon alle Elemente durchsucht haben und gegebenenfalls abgebrochen, falls nicht, erfolgt der Abbruch, wenn das Wort gefunden wurde. In diesem Falle erfolgen die Schleifendurchläufe mit den Werten 4, 5 und 6 gar nicht.

Man sollte jedoch nach Möglichkeit darauf verzichten, eine Schleife vorzeitig zu beenden. Der Programmcode kann damit viel unübersichtlicher werden als nötig. In unserem Beispiel ist die Repeat-Until-Schleife vorzuziehen.

[Bearbeiten] Überspringen von Werten

Ein Schleifendurchlauf kann mit dem Befehl Continue an der entsprechenden Stelle abgebrochen und wieder am Anfang begonnen werden.

Beispiel: Ausgabe aller geraden Zahlen zwischen 1 und 10:

var
  i: Integer;

begin
  for i := 1 to 10 do
    if i mod 2 = 0 then
      Writeln(IntToStr(i));
end.

oder:

var
  i: Integer;

begin
  for i := 1 to 10 do
  begin
    if i mod 2 <> 0 then
      Continue;
    Writeln(IntToStr(i));
  end;
end.

Im oberen Beispiel werden die Werte vor der Ausgabe „gefiltert“. Das zweite Beispiel startet hingegen einen neuen Durchlauf, wenn eine Zahl nicht ohne Rest durch 2 teilbar ist. Der Vorteil der zweiten Variante liegt darin, dass mit einer geringeren Verschachtelungsebene gearbeitet werden kann. Die Verarbeitung von i erfolgt noch immer im Programmcode der for-Schleife, während sie beim ersten Beispiel im Programmcode der if-Anweisung erfolgt.

[Bearbeiten] Prozeduren und Funktionen

[Bearbeiten] Prozeduren ohne Parameter

Oft benötigt man ein und den selben Code mehrere Male in einem Programm, - was liegt also näher als ihn nur ein mal zu schreiben, unter einem Namen zu speichern und diesen dann im Programm aufzurufen? Wohl nichts, und deshalb leisten Prozeduren genau dies. Will man etwa die Anweisungen aus dem Eingangsbeispiel

var
  Vorname: string;
begin
  Writeln('Wie heisst du?');
  Readln(Vorname);
  Writeln('Hallo '+Vorname+'! Schoen, dass du mal vorbeischaust.');
  Readln;
end.

gleich 2 mal aufrufen und dafür eine Prozedur verwenden, so sähe das Ergebnis so aus:

var
  Vorname: string;

procedure Beispielprozedur;
begin
  Writeln('Wie heisst du?');
  Readln(Vorname);
  Writeln('Hallo '+Vorname+'! Schoen, dass du mal vorbeischaust.');
  Readln;
end;  // Ende procedure Beispielprozedur

begin // Beginn des Hauptprogramms
  Beispielprozedur;
  Beispielprozedur;
end.  // Ende Hauptprogramm

Das Schlüsselwort procedure leitet dabei den Prozedurkopf ein, der im Beispiel nur aus dem Prozedurnamen besteht. Der Anfang des Codes der Prozedur wird durch begin gekennzeichnet, und im Anschluss daran folgt end; um das Prozedurende zu kennzeichnen. Der String Vorname ist hierbei global, also am Programmanfang außerhalb der Prozedur deklariert, wodurch er im gesamten Programm samt aller Prozeduren Gültigkeit besitzt, also an jeder Stelle gelesen und beschrieben werden kann. Dies hat jedoch Nachteile und birgt Gefahren, da verschiedene Prozeduren eventuell ungewollt gegenseitig den Inhalt solcher globaler Variablen verändern. Die Folge wären Fehler im Programm, die schwer zu erkennen, aber glücklicherweise leicht zu vermeiden sind. Man kann nämlich auch schreiben:

procedure Beispielprozedur;
var
  Vorname: string;
begin
  Writeln('Wie heisst du?');
  Readln(Vorname);
  Writeln('Hallo '+Vorname+'! Schoen, dass du mal vorbeischaust.');
  Readln;
end;  // Ende procedure Beispielprozedur

begin // Beginn des Hauptprogramms
  Beispielprozedur;
  Beispielprozedur;
end.  // Ende Hauptprogramm

Jetzt ist die Variable innerhalb der Prozedur deklariert, und sie besitzt auch nur dort Gültigkeit, kann also außerhalb weder gelesen noch beschrieben werden. Man nennt sie daher eine lokale Variable. Mit Erreichen der Stelle end; // Ende procedure Beispielprozedur verliert sie ihren Wert, sie ist also auch temporär.

[Bearbeiten] Prozeduren mit Wertübergabe (call by value)

Oft ist es jedoch nötig, der Prozedur beim Aufruf Werte zu übergeben, um Berechnungen auf unterschiedliche Daten anzuwenden oder individuelle Nachrichten auszugeben. Ein Beispiel:

var
  MusterName: string;
  GeschoentesAlter: Integer;

procedure NameUndAlterAusgeben(Vorname: string; AlterMonate: Integer);
var
  AlterJahre: Integer;
begin
  AlterJahre := AlterMonate div 12;
  AlterMonate := AlterMonate mod 12; 
  Writeln(Vorname+ ' ist '+ IntToStr(AlterJahre)+' Jahre und '+ IntToStr(AlterMonate)+ ' Monate alt');
  Readln;
end;

begin
  NameUndAlterAusgeben('Konstantin', 1197);
  MusterName := 'Max Mustermann';
  GeschoentesAlter := 386;
  NameUndAlterAusgeben(MusterName, GeschoentesAlter)
end.

Der Prozedur NameUndAlterAusgeben werden in runden Klammern zwei durch Semikolon getrennte typisierte Variablen (Vorname: string; AlterMonate: Integer) bereitgestellt, die beim Prozeduraufruf mit Werten belegt werden müssen. Dies kann wie im Beispiel demonstriert mittels Konstanten oder auch Variablen des geforderten Typs geschehen. Diese Variablen werden genau wie die unter var deklarierten lokalen Variablen behandelt, nur dass sie eben mit Werten vorbelegt sind. Sie verlieren also am Ende der Prozedur ihre Gültigkeit und sind außerhalb der Prozedur nicht lesbar. Veränderungen an ihnen haben auch keinen Einfluss auf die Variablen mit deren Werten sie belegt wurden, im Beispiel verändert also AlterMonate := AlterMonate mod 12; den Wert von GeschoentesAlter nicht.

[Bearbeiten] Prozeduren mit Variablenübergabe (call by reference)

Was aber, wenn man der Prozedur nicht nur Werte mitteilen will, sondern sie dem Hauptprogramm auch ihre Ergebnisse übermitteln soll? In diesem Fall benötigt man im Hauptprogramm eine Variable, deren Werte beim Prozeduraufruf übergeben werden und in die am Ende das Ergebnis geschrieben wird. Außerdem muss man im Prozedurkopf einen Platzhalter definieren, der die Variable aufnehmen kann (eine Referenz darauf bildet). Dies geschieht indem man genau wie bei der Wertübergabe hinter dem Prozedurnamen in runden Klammern eine typisierte Variable angibt, ihr aber das Schlüsselwort var voranstellt. Ein Beispiel:

var
  eingabe: Double;

procedure kubik(var zahl: Double);
begin
  zahl := zahl * zahl * zahl;
end;

begin
  eingabe := 2.5;
  kubik(eingabe);

  ...

end.

Als Platzhalter dient hier die Variable zahl, ihr wird beim Aufruf der Wert von eingabe übergeben, am Ende wird der berechnete Wert zurückgeliefert, im Beispiel erhält eingabe also den Wert 15.625. Bei der Variablenübergabe darf keine Konstante angegeben werden, da diese ja das Ergebnis nicht aufnehmen könnte, es muss immer eine Variable übergeben werden.

Objekte werden in Delphi immer als Zeiger übergeben. Man kann also auf Eigenschaften und Methoden eines Objekts direkt zugreifen:

 procedure ClearLabel(label: TLabel);
 begin
    label.Caption := ''
 end;

[Bearbeiten] Prozeduren/Funktionen mit Const Parameter

Parameter können mit Const gekennzeichnet sein, um zu verhindern, dass ein Parameter innerhalb einer Prozedur oder Funktion geändert werden kann.

 function StrSame(const S1, S2: AnsiString): Boolean;
 begin
   Result := StrCompare(S1, S2) = 0;
 end;

Bei String-Parametern ergibt sich ein Geschwindigkeitsvorteil, wenn diese mit Const gekennzeichnet werden.

[Bearbeiten] Erste Zusammenfassung

Prozeduren können ohne Ein- und Ausgabe, mit einer oder mehreren Eingaben und ohne Ausgabe, oder mit Ein- und Ausgabe beliebig vieler Variablen deklariert werden. Wertübergaben und Variablenübergaben können selbstverständlich auch beliebig kombiniert werden. Bei Variablenübergaben ist zu beachten, dass die Prozedur immer den Wert der Variable einliest. Will man sie allein zur Ausgabe von Daten verwenden, darf deren Wert nicht verwendet werden, bevor er nicht innerhalb der Prozedur überschrieben wurde, beispielsweise mit einer Konstanten oder dem Ergebnis einer Rechnung.

Prozeduren können natürlich auch aus anderen Prozeduren oder Funktionen heraus aufgerufen werden.

Werden Variablen im Hauptprogramm deklariert, so nennt man sie global, und ihre Gültigkeit erstreckt sich demnach über das gesamte Programm (genauer: die gesamte Unit); somit besitzen auch Prozeduren Zugriff darauf.
Innerhalb von Prozeduren deklarierte Variablen besitzten nur dort Gültigkeit, man nennt sie daher lokale Variablen.

Aber Vorsicht: Konnte man sich bei Zahlen (vom Typ Integer, Int64, Single, Double, ...) in globalen Variablen noch darauf verlassen, dass sie zu Anfang den Wert null haben, so ist dies in lokalen Variablen nicht mehr der Fall, sie tragen Zufallswerte. Außerdem kann man keine typisierten Konstanten innerhalb von Prozeduren deklarieren.

[Bearbeiten] Funktionen

Funktionen liefern gegenüber Prozeduren immer genau ein Ergebnis. Dieses wird sozusagen an Ort und Stelle geliefert, genau dort wo der Funktionsaufruf im Programm war, steht nach dem Ende ihr Ergebnis. Das hat den Vorteil, dass man mit den Funktionsausdrücken rechnen kann als ob man es bereits mit ihrem Ergebnis zu tun hätte, welches erst zur Laufzeit des Programms berechnet wird.
Sie werden durch das Schlüsselwort function eingeleitet, darauf folgt der Funktionsname, in runden Klammern dahinter ggf. typisierte Variablen zur Wertübergabe, gefolgt von einem Doppelpunkt und dem Ergebnis-Typ. Innerhalb der Funktion dient ihr Name als Ergebnisvariable. Ein Beispiel:

var
  ergebnis: Double;

function Kehrwert(zahl: Double): Double;
begin
  Kehrwert := 1/zahl;   // oder: Result := 1/zahl;
end;

begin
  ergebnis := Kehrwert(100)*10; // wird zu   ergebnis := 0.01*10;

  ...  

  Kehrwert(100)*10;
end.

Der Funktion wird also der (Konstanten-) Wert 100 übergeben, Sie liefert ihr Ergebnis, es wird mit 10 multipliziert, und in ergebnis gespeichert. Der nächste Aufruf bleibt ohne Wirkung, und verdeutlicht, dass man mit Funktionsausdrücken zwar beliebig weiterrechnen kann, aber am Ende das Ergebnis immer speichern oder ausgeben muss, da es sonst verloren geht.

Funktionen erfordern nicht notwendigerweise Wertübergaben. Z.B. wäre es möglich, dass eine Funktion mit Zufallszahlen arbeitet oder ihre Werte aus globalen Variablen oder anderen Funktionen bezieht. Eine weitere Anwendung wäre eine Funktion ähnlich einer normalen Prozedur, die jedoch einen Wert als Fehlermeldung zurückgibt. Tatsächlich gibt es z.B. in der Windows-Programmierung die Funktion GetForegroundWindow, die einen Zeiger auf das aktive Fenster zurückgibt und dafür keine Werte vom Benutzer benötigt.

[Bearbeiten] Unterprozeduren / Unterfunktionen

Prozeduren und ebenso Funktionen können bei ihrer Deklaration auch in einander verschachtelt werden (im Folgenden wird nur noch von Prozeduren gesprochen, alle Aussagen treffen aber auch auf Funktionen zu). Aus dem Hauptprogramm oder aus anderen Prozeduren kann dabei nur die Elternprozedur aufgerufen werden, die Unterprozeduren sind nicht zu sehen. Eltern- und Unterprozeduren können sich jedoch gegenseitig aufrufen.
Die Deklaration dazu an einem Beispiel veranschaulicht sieht folgendermaßen aus:

procedure Elternelement;
var
  Test: string;

  procedure Subprozedur;
  begin
    Writeln(Test);
    Readln(Test);
  end;

...
Beliebig viel weitere Prozeduren
...


begin  // Beginn von Elternelement
  Test := 'Ein langweiliger Standard';
  Subprozedur;
  Writeln(Test);
  Readln;
end;

Nach dem Prozedurkopf folgen optional die Variablen der Elternprozedur, dann der Prozedurkopf der Unterprozedur, ihr Rumpf, wenn noch nicht geschehen die Variablen der Elternprozedur und schließlich der Rumpf der Elternprozedur. Sofern die Variablen der Elternprozedur vor den Unterprozeduren deklariert werden, können diese darauf ähnlich einer globalen Variable zugreifen, wodurch deren Einsatz sich dadurch noch weiter reduzieren lässt. Im Zusammenhang mit Rekursionen wird ein solcher Einsatz manchmal angebracht sein.
Unterprozeduren können auch selbst wieder Unterprozeduren haben, die dann nur von ihrem Elternelement aufgerufen werden können, es sind beliebige Verschachtelungen möglich.

[Bearbeiten] forward Deklaration

Alle folgenden Aussagen treffen auch auf Funktionen zu: Eigentlich muss der Code einer Prozedur vor ihrem ersten Aufruf im Programm stehen, manchmal ist dies jedoch eher unpraktisch, etwa wenn man viele Prozeduren alphabetisch anordnen will, oder es ist gar unmöglich, nämlich wenn Prozeduren sich gegenseitig aufrufen. In diesen Fällen hilft die forward Deklaration, die dem Compiler am Programmanfang mitteilt, dass später eine Prozedur unter angegebenen Namen definiert wird. Man schreibt dazu den gesamten Prozedurkopf ganz an den Anfang des Programms, gefolgt von der Anweisung forward; . Der Prozedur-Rumpf folgt dann im Implementation-Teil der Unit. Hierbei kann der vollständige Prozedurkopf angegeben werden oder man lässt die Parameter weg. Am Beispiel der Kehrwertfunktion sähe dies so aus:

function Kehrwert(zahl: Double): Double; forward;

var
  ergebnis: Double;

function Kehrwert;
begin
  Kehrwert := 1/zahl;
end;

...

[Bearbeiten] Überladene Prozeduren / Funktionen

Alle Bisher betrachteten Prozeduren / Funktionen verweigern ihren Aufruf wenn man ihnen nicht genau die Zahl an Werten und Variablen wie in ihrer Deklaration gefordert übergibt. Auch deren Reihenfolge muss beachtet werden.
Will man beispielsweise eine Prozedur mit ein und demselben Verhalten auf unterschiedliche Datentypen anwenden, so wird dies durch die relativ strikte Typisierung von Pascal verhindert. Versucht man also, einer Prozedur, die Integer-Zahlen in Strings wandelt, eine Gleitkommazahl als Eingabe zu übergeben, so erhält man eine Fehlermeldung. Da dies aber eigentlich ganz praktisch wäre, gibt es eine Möglichkeit, dies doch zu tun. Man muss jedoch die Prozedur in allen benötigten Varianten verfassen und diesen den gleichen Namen geben. Damit der Compiler von dieser Mehrfachbelegung des Namens weiß, wird jedem der Prozedurköpfe das Schlüsselwort overload; angefügt. Wichtig ist es zu beachten, dass die Parameter tatsächlich in der Reihenfolge ihrer Datentypen unterschiedlich sind. Es reicht nicht, unterschiedliche Parameternamen zu verwenden.
Ein Beispiel:

procedure NumberToString(zahl: Int64; var Ausgabe: string); overload;
begin
  Ausgabe := IntToStr(zahl);
end;

procedure NumberToString(zahl: Double; var Ausgabe: string); overload;
begin
  Ausgabe := FloatToStr(zahl);
end;

procedure NumberToString(zahl: Double; var Ausgabe: TEdit); overload;
begin
  Ausgabe.Text := FloatToStr(zahl);
end;

Die erste Version kann Integer-Werte in Strings wandeln, die zweite wandelt Fließkommawerte, die dritte ebenso, speichert sie dann jedoch in einer Delphi-Edit-Komponenten.
Wenn Typen zuweisungskompatibel sind, braucht man keine separate Version zu schreiben, so nimmt z.B. Int64 auch Integer (Longint)-Werte auf, genau wie Double auch Single-Werte aufnehmen kann.

Der Begriff Überladen (overload) beschreibt das mehrmalige Einführen einer Funktion oder Prozedur mit gleichem Namen, aber unterschiedlichen Parametern. Der Compiler erkennt hierbei an den Datentypen der Parameter, welche Version er nutzen soll. Das Überladen ist sowohl in Klassen, für die dort definierten Methoden, als auch in globalen Prozeduren und Funktionen möglich.

Noch weitergehende Fähigkeiten kann man mit dem Typ Variant realisieren.

[Bearbeiten] Vorzeitiges Beenden

In einigen Situationen kann es sinnvoll sein, den Programmcode einer Prozedur oder Funktion nicht vollständig bis zum Ende durchlaufen zu lassen. Hierfür gibt es die Möglichkeit, mittels der Anweisung Exit vorzeitig hieraus auszusteigen. Exit kann an jeder Stelle im Programmablauf vorkommen, bei Funktionen ist jedoch zusätzlich zu beachten, dass vor dem Verlassen ein gültiges Funktionsergebnis zugewiesen wird.

Stellen Sie sich vor, Sie haben eine Liste von Namen und möchten wissen, an welcher Stelle dieser Liste sich ein Name befindet. Die entsprechende Funktion könnte wie folgt aussehen:

type
  TNamensListe = array[0..99] of string;

function HolePosition(Name: string; Liste: TNamensListe): Integer;
var
  i: Integer;
begin
  Result := -1;         // Funktionsergebnis bei Fehler oder "nicht gefunden"
  if Name = '' then
    Exit;               // Funktion verlassen, wenn kein Name angegeben wurde

  for i := 0 to 99 do   // komplette Liste durchsuchen
    if Liste[i] = Name then
    begin
      Result := i;      // gefundene Position als Funktionsergebnis zurückgeben
      Break;            // verlässt die Zählschleife (oder Exit, verlässt die Funktion)
    end;
end;

In diesem Beispiel wird als erstes das Funktionsergebnis -1 festgelegt. In diesem Falle soll es die Bedeutung "Fehler" oder "Name nicht gefunden" besitzen. Da der Index der Liste erst bei 0 beginnt, ist eine Stelle unter 0 als gültiges Ergebnis nicht möglich. Dadurch können wir diesen Wert als so genannte "Magic number" gebrauchen, sprich, als Ergebnis mit besonderer Bedeutung.

Als nächstes wird getestet, ob überhaupt ein Name angegeben wurde. Wenn die Zeichenkette leer ist, erfolgt der sofortige Ausstieg aus der Funktion. Die anschließende Prüfschleife wird nicht durchlaufen. Als Ergebnis wird der zuvor zugewiesene Wert -1 zurückgegeben. Nur wenn Name nicht leer ist, beginnt die eigentliche Suche. Hierbei werden alle Elemente der Liste geprüft, ob sie dem angegebenen Namen entsprechen. Wenn dies der Fall ist, wird die Position dem Funktionsergebnis zugewiesen und die Suche beendet.

Für den besonderen Fall, dass zwar ein Name angegeben wurde, dieser aber in der Liste nicht enthalten ist, wird ebenfalls -1 zurückgegeben. Da die Bedingung Liste[i] = Name niemals zutrifft, bekommt das Funktionsergebnis in der Schleife keinen neuen Wert zugewiesen. Nach 99 wird die Schleife verlassen und Result ist immer noch -1.

Das folgende Programm verdeutlicht den Ablauf.

var
  Liste: TNamensListe;

begin
  Liste[0] := 'Alfons';
  Liste[1] := 'Dieter';
  Liste[2] := 'Gustav';
  Liste[3] := 'Detlef';

  WriteLn(HolePosition('Gustav', Liste));  // Ergibt:  2
  WriteLn(HolePosition('Peter', Liste));   // Ergibt: -1
end.

[Bearbeiten] Fortgeschritten

[Bearbeiten] Typdefinition

Bei einer Typdefinition wird einem Variablentyp ein neuer Bezeichner zugeordnet. Die Typdefinitionen stehen vor den Variablendefinitionen und werden mit dem Schlüsselwort Type eingeleitet. Die Syntax zeigen die folgenden Beispiele.

 type
   int = Integer;
   THandle = Word;
 var
   zaehler: int;
   fensterhandle: THandle;

In den obigen Beispielen wird den in Delphi definierten Typen Integer sowie Word ein zusätzlicher Bezeichner, hier int sowie THandle gegeben. In Variablendefinitionen können danach die neuen Bezeichner verwendet werden.

Im Folgenden werden weitere mögliche Typdefinitionen beschrieben.

[Bearbeiten] Teilbereiche von Ganzzahlen

 type
   TZiffer = 0..9;  // Die Zahlen 0 bis 9
   TSchulnote = 1..6;
 var
   a, b: TZiffer;
 begin
   a := 5;     // zulässig
 //  a := 10;   Diese Zuweisung erzeugt beim Kompilieren eine Fehlermeldung!!!
   b := 6;
   a := a + b; // Dies führt bei Laufzeit zu einer Fehlermeldung, da das
               // Ergebnis außerhalb des Wertebereiches von TZiffer liegt!!!
 end;

[Bearbeiten] Aufzählungen

 type
   TWochentag = (Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag);
   TSchulnote = (sehr_gut, gut, befriedigend, ausreichend, mangelhaft, ungenuegend);
 var
   tag: TWochentag;
 begin
   tag := Mittwoch;
   if tag = Sonntag then Writeln('Sonntag');
 end;

Aufzählungen sind identisch mit Teilbereichen von Ganzzahlen, die mit 0 beginnen. Sie machen aber den Code besser lesbar, wie im letzten Beispiel verdeutlicht.

[Bearbeiten] Records, Arrays

 type
   TKomplex = record
     RealTeil: Double;    // Single, Double, Extended und Real sind in
                          // Delphi definierte Fließkommazahlen
     ImaginaerTeil: Double;
   end;
   TNotenArray = array[1..6] of Integer;

 var
   a, b: TKomplex;
   Noten: TNotenArray;

 function Plus(a1, a2: TKomplex): TKomplex;
 begin
   Result.RealTeil := a1.RealTeil + a2.RealTeil;
   Result.ImaginaerTeil := a1.ImaginaerTeil + a2.ImaginaerTeil;
 end;

 begin
   a.RealTeil := 3;
   a.ImaginaerTeil := 1;
   b := a;
   a := Plus(a, b);
 end.

Records oder Arrays als Typdefinition haben den Vorteil, dass sie direkt einander zugewiesen werden können (a := b) und dass sie als Parameter sowie Rückgabewert einer Funktion zulässig sind. Vergleiche (if a = b then...) sind allerdings nicht möglich.

[Bearbeiten] Zeiger

 type
   PWord = ^Word;
   PKomplex = ^TKomplex;  // nach obiger Typdefinition von TKomplex
 var
   w: PWord;
 begin
   ...
   w^ := 128;
   ...
 end.

Zeiger als Typdefinion sind ebenfalls als Parameter sowie Rückgabewert von Funktionen zulässig. Da ein Zeiger immer eine Adresse speichert, unabhängig vom Typ, auf den der Zeiger zeigt, kann die Typdefinition auch nach der Definition des Zeigers erfolgen, wie im nachfolgenden Beispiel.

 type
   PKettenglied = ^TKettenglied;
   TKettenglied = record
     Glied: Integer;
     Naechstes: PKettenglied;
   end;

[Bearbeiten] Klassen

Die Deklarierung von Klassen ist ebenfalls eine Typdefinition.

Es wird als guter Stil empfunden, wenn Typdefinitionen, die einen Zeiger (englisch: Pointer) definieren, mit P beginnen und alle anderen Typdefinitionen mit T.

[Bearbeiten] Typumwandlung

Unter Typumwandlung (auch Casts) versteht man, zwei Variablen von unterschiedlichen Typen, von denen entweder der eine vom anderen abstammt oder der eine mit dem anderen kompatibel ist, zu konvertieren. Der Typ „PChar“ ist beispielsweise mit dem Typ „string“ kompatibel. Trotzdem gibt es eine Fehlermeldung, wenn man z. B. folgendes versucht:

var
  a, b: string;
  c: PChar;
begin
  a := 'Hallo ';
  b := 'Welt!';
  c := a + b;
end;

Bei „a + b“ wird ein String zurückgegeben. Das ist nicht erlaubt! Man darf zwar einem PChar-Wert einen durch einfache Gänsefüßchen gekennzeichnete Strings zuweisen, jedoch keine Verkettungen oder String-Variablen. Dieses Problem wird mit der Typumwandlung gelöst:

<Variable> := <Typ1>(<Variable2>);

Also im Beispiel:

c := PChar(a + b);

So gibt es keine Fehlermeldungen und das Programm funktioniert!

Beispiel 2: Die Funktion FindComponent sucht eine Komponente mit dem als Parameter angegebenen Namen. Zum Beispiel: FindComponent('Edit1');

Leider gibt diese Funktion TComponent zurück. Dieser gibt uns nicht die Möglichkeit, den Text der gefundenen Komponente zu ändern. Das Problem können wir mit der Typumwandlung lösen:

var
  gefunden: TComponent;
  editierfeld: TEdit;
begin
  gefunden := FindComponent('Edit1');
  editierfeld := TEdit(gefunden);
  editierfeld.Text := 'Editierfeld gefunden!';
end;

[Bearbeiten] Methodenzeiger

Methodenzeiger werden intern als Doppel-Zeiger gespeichert.

type
  TMethod = record
    Code, Data: Pointer;
  end;

Bei der Zuweisung an einen Methodenzeiger ist also immer ein Objekt(-zeiger) und eine Methode beteiligt. Über Methodenzeiger werden die in Delphi so nützlichen Ereignisse abgebildet.

Beim Aufruf eines Methodenzeigers springt das Programm über Zeiger Code in die Methode. Dabei wird Data als der versteckte Self Parameter übergeben.

[Bearbeiten] Rekursion

[Bearbeiten] Definition

Als Rekursion bezeichnet man das Verfahren, dass eine Funktion ihren Rückgabewert durch Aufruf von sich selbst berechnet. Für viele Probleme existiert neben einer rekursiven Lösung auch eine iterative Lösung (Lösung durch Anwendung einer Schleife). Zudem müssen genügend Startwerte existieren (im Beispiel unten 0 für n=0).

[Bearbeiten] Beispiele für Rekursionen

Ein bekanntes Beispiel für ein Problem, das meistens (und sinnvollerweise) durch Rekursion gelöst wird, sind die Türme von Hanoi, ein mathematisches Spiel. Prinzipiell lässt sich dieses Problem auch iterativ lösen. Ein anderes sinnvolles Beispiel ist Floodfill, ein Algorithmus zum Einfärben von benachbarten Pixel gleicher Farbe.

[Bearbeiten] Beispiel einer Rekursionsprozedur

function Quersumme(n: Integer): Integer;
begin
  if n = 0 then
    Result := 0
  else
    Result := (n mod 10) + Quersumme(n div 10);
end;

[Bearbeiten] Rekursive und iterative Programmierung im Vergleich

Rekursive Algorithmen sind oft kürzer als iterative, leichter zu verstehen und gelten als eleganter. Iteration ist dafür ressourcensparender und schneller, weil der wiederholte Funktionsaufruf entfällt. Im Extremfall kann es bei der Rekursion zum Stapelüberlauf kommen, wenn der Stapelspeicher nicht mehr ausreicht. Zudem sind in iterativen Lösungen Fehler leichter zu finden. Daher ist die iterative Vorgehensweise der rekursiven immer vorzuziehen, wenn es eine Iterative Lösung gibt (und sich diese auch in vernünftiger Zeit finden lässt). Beispielsweise sollte Rekursion nicht zur Berechnung von Fakultät, Summen, der Fibonacci-Zahlen und ähnlichem Verwendung finden.

[Bearbeiten] Links

Wikipedia Artikel zu rekursiver Programmierung: Rekursive Programmierung

[Bearbeiten] Objektorientierung

[Bearbeiten] Klassen

[Bearbeiten] Einleitung

Die Grundlage für die objektorientierte Programmierung, kurz OOP, bilden Klassen. Diese kapseln, ähnlich wie Records, verschiedene Daten zu einer Struktur. Gleichzeitig liefern sie Methoden mit, welche die vorhandenen Daten bearbeiten.

Der Vorteil von Klassen besteht also darin, dass man mit ihnen zusammengehörige Variablen, Funktionen und Prozeduren zusammenfassen kann. Weiterhin können - bei entsprechender Implementation - die Daten einer Klasse nicht „von außen“ geändert werden.

[Bearbeiten] Aufbau einer Klasse

[Bearbeiten] Allgemeiner Aufbau

Die einfachste Klasse entspricht in ihrem Aufbau einem Record:

program Klassentest;

type
  TMyRec = record
    EinByte: Byte;
    EinString: string;
  end;

  TMyClass = class
    FEinByte: Byte;
    FEinString: string;
  end;

var
  MyRec: TMyRec;
  MyClass: TMyClass;

begin
  MyRec.EinByte := 15;
  MyClass := TMyClass.Create;
  MyClass.FEinString := 'Hallo Welt!';
  MyClass.Free;   // bzw. MyClass.Destroy;
end.

Hierbei kann man bereits einen Unterschied zu Records erkennen: Während man jederzeit auf die Daten eines Records zugreifen kann, muss bei einer Klasse zunächst Speicher angefordert und zum Schluss wieder freigeben werden. Die speziellen Methoden Create und Destroy bzw. Free sind in jeder Klasse enthalten und müssen nicht gesondert programmiert werden. Zur Freigabe des Speichers sollte dabei Free bevorzugt verwendet werden. Hierzu mehr im Kapitel Konstruktoren und Destruktoren.

Weiterhin hat es sich durchgesetzt, die Variablen einer Klasse, Felder genannt, immer mit dem Buchstaben F zu beginnen. So werden Verwechselungen mit globalen und lokalen Variablen vermieden.

[Bearbeiten] Sichtbarkeit der Daten

Im oben gezeigten Beispiel kann auf die Felder wie bei einem Record zugegriffen werden. Dies sollte man unter allen Umständen vermeiden!

Hierfür gibt es eine ganze Reihe von Möglichkeiten. Zunächst einmal können Felder, sowie Methoden und Eigenschaften einer Klasse nach außen hin „versteckt“ werden. Das erreicht man mit folgenden Schlüsselwörtern:

• strict private - auf diese Daten kann außerhalb der Klasse nicht zugegriffen werden
• private - wie strict private, allerdings kann auch in der beinhaltenden Unit darauf zugegriffen werden
• strict protected - hierauf kann man nur innerhalb der Klasse und ihrer Nachfahren zugreifen
• protected - wie strict protected, allerdings kann auch in der beinhaltenden Unit darauf zugegriffen werden
• public - diese Daten sind uneingeschränkt zugänglich
• published - zusätzlich zu public können diese Daten auch im Objekt-Inspektor von Delphi™ bearbeitet werden (nur bei Eigenschaften von Komponenten sinnvoll).

Das entsprechende Schlüsselwort wird der Gruppe von Daten vorangestellt, für die diese Sichtbarkeit gelten soll. Um die Felder unserer Klasse zu verstecken, schreiben wir also:

type
  TMyClass = class
  private
    FEinByte: Byte;
    FEinString: string;
  end;

Wenn man jetzt versucht, wie oben gezeigt, einem Feld einen Wert zuzuweisen oder ihn auszulesen, wird bereits bei der Kompilierung eine Fehlermeldung ausgegeben.

[Bearbeiten] Methoden

Wie erhält man nun aber Zugriff auf die Daten? Dies erreicht man über öffentlich zugängliche Methoden, mit denen die Daten ausgelesen und geändert werden können.

Eine Methode ist eine fest mit der Klasse verbundene Funktion oder Prozedur. Daher wird sie auch wie Felder direkt innerhalb der Klasse definiert:

TMyClass = class
public
  function GetString: string;
  procedure SetString(NewStr: string);
end;

Die Ausführung der Methoden erfolgt direkt über die Variable dieses Klassentyps:

var
  MyClass: TMyClass;

...

MyClass.SetString('Hallo Welt!');
WriteLn(MyClass.GetString);

In der Typdefinition werden nur der Name und die Parameter von Methoden definiert. Die Implementation, also die Umsetzung dessen, was eine Methode tun soll, erfolgt außerhalb der Klasse, genau wie bei globalen Funktionen und Prozeduren. Allerdings muss der Klassenname vorangestellt werden:

function TMyClass.GetString: string;
begin
  Result := FEinString;
end;

procedure TMyClass.SetString(NewStr: string);
begin
  FEinString := NewStr;
end;

Da die Methoden GetString und SetString Mitglieder der Klasse sind, können diese auf das private Feld FEinString zugreifen.

Ebenso wie globale Funktionen und Prozeduren lassen sich auch Methoden überladen. Dies bedeutet, dass mehrere Prozeduren mit dem gleichen Namen aber unterschiedlichen Parametern innerhalb einer Klasse deklariert werden. Hierzu ein vollständiges Programm als Beispiel:

program Ueberladen;

{$APPTYPE CONSOLE}

uses
  SysUtils;

type
  TTestKlasse = class
  public
    function ZaehleStellen(zahl: Cardinal): Integer; overload;
    function ZaehleStellen(wort: string): Integer; overload;
  end;

function TTestKlasse.ZaehleStellen(zahl: Cardinal): Integer;
begin
  Result := Length(IntToStr(zahl));
end;

function TTestKlasse.ZaehleStellen(wort: string): Integer;
begin
  Result := Length(wort);
end;

var
  Zaehler: TTestKlasse;

begin
  Zaehler := TTestKlasse.Create;

  Writeln(Zaehler.ZaehleStellen(16384));
  Writeln(Zaehler.ZaehleStellen('Donnerstag'));
  Readln;
  Zaehler.Free;
end.

Im ersten Fall – Writeln(ZaehleStellen(16384)); – wird die Methode TTestKlasse.ZaehleStellen(zahl: Cardinal): Integer aufgerufen, da der Übergabeparameter vom Typ Cardinal ist. Es wird 5 ausgegeben.

Im zweiten Fall – Writeln(ZaehleStellen('Donnerstag')); – wird die Methode TTestKlasse.ZaehleStellen(wort: string): Integer aufgerufen, da der Übergabeparameter ein String ist. Dementsprechend wird der Wert 10 ausgegeben.

In beiden Fällen wird die Stellenanzahl mittels Length bestimmt. Da Length aber eine Zeichenkette erwartet, wird der Zahlwert im ersten Fall zunächst in eine Zeichenkette umgewandelt und dann die Länge dieser Zeichenkette bestimmt.

Näheres zum Überladen unter Prozeduren und Funktionen.

[Bearbeiten] Eigenschaften

Für unser Beispiel erscheint der Zugriff etwas umständlich. Daher gibt es noch eine andere einfache Möglichkeit, Daten einer Klasse auszulesen und zu ändern: Eigenschaften (engl. properties).

Eigenschaften lassen sich wie Variablen behandeln, das heißt, man kann sie (wenn gewünscht) auslesen oder (wenn gewünscht) ändern. Die interne Umsetzung bleibt dabei verborgen. So kann eine Eigenschaft zum Beispiel direkt auf ein Feld oder über den Umweg einer Methode darauf zugreifen:

type
  TMyClass = class
  private
    FEinInt: Integer;
    function HoleDoppelteZahl: Integer;
    procedure SpeichereHalbeZahl(DoppZahl: Integer);    // Name des Parameters ist egal
  public
    property Zahl: Integer read FEinInt write FEinInt;
    property DoppelZahl: Integer read HoleDoppelteZahl write SpeichereHalbeZahl;
  end;

Sowohl das Feld als auch die Methoden sind versteckt. Die einzige Verbindung zur Außenwelt besteht über die Eigenschaften. Hier greift die Eigenschaft „Zahl“ beim Lesen und Schreiben direkt auf das Feld zu, während „DoppelZahl“ in beiden Fällen auf Methoden zurückgreift. Da DoppelZahl immer das Doppelte von Zahl sein soll (so sagt es zumindest der Name), werden die Methoden wie folgt implementiert:

function HoleDoppelteZahl: Integer;
begin
  Result := FEinInt * 2;
end;

procedure SpeichereHalbeZahl(DoppZahl: Integer);
begin
  FEinInt := DoppZahl div 2;
end;

Diese Klasse führt Berechnungen durch, ohne dass es der Benutzer mitbekommt. Weist man Zahl einen Wert zu, erhält man aus DoppelZahl automatisch das Doppelte. Andersherum kann man DoppelZahl einen Wert zuweisen und erhält mit Zahl die Hälfte. Von außen betrachtet erscheinen beide Eigenschaften jedoch wie Felder:

with MyClass do
begin
  Zahl := 4;
  WriteLn(DoppelZahl);  // Schreibt eine 8
  DoppelZahl := 20;
  WriteLn(Zahl);        // ergibt 10 und nicht etwa 4
end;

Soll DoppelZahl einen Schreibschutz erhalten, lässt man in der Definition den Teil „write ...“ weg. Damit kann auch die entsprechende Methode SpeichereHalbeZahl entfernt werden.

Die verschiedenen Arten von Eigenschaften werden ausführlicher in einem eigenen Kapitel behandelt.

[Bearbeiten] Konstruktoren und Destruktoren

[Bearbeiten] Allgemeines

Wie bereits im Kapitel über Klassen beschrieben, muss der Speicher für die Datenstruktur einer Klasse angefordert werden, bevor man mit ihr arbeiten kann. Da eine Klasse mehr als nur eine Datenansammlung ist - nämlich ein sich selbst verwaltendes Objekt - müssen gegebenenfalls weitere Initialisierungen durchgeführt werden. Genauso kann nach der Arbeit mit einer Klasse noch Speicher belegt sein, der von Delphis Speicherverwaltung nicht erfasst wird.

Für zusätzliche anfängliche Initialisierungen stehen die Konstruktoren („Errichter“) zur Verfügung, wogegen die Destruktoren („Zerstörer“) die abschließende Aufräumarbeit übernehmen. Diese sind spezielle Methoden einer Klasse, die nur zu diesem Zweck existieren.

[Bearbeiten] Konstruktoren

Für die Arbeit mit einfachen Klassen, die keine weitere Initialisierung benötigen, braucht kein spezieller Konstruktor verwendet zu werden. In Delphi stammt jede Klasse automatisch von der Basisklasse TObject ab und erbt von dieser den Konstruktor Create. Folgender Aufruf ist daher gültig, obwohl keine Methode Create definiert wurde:

type
  TErsteKlasse = class
  end;

var
  Versuch: TErsteKlasse;

begin
  Versuch := TErsteKlasse.Create;
end.

Wie zu sehen ist, erfolgt der Aufruf des Konstruktors über den Klassentyp. Eine Anweisung wie Variable.Create führt zu einer Fehlermeldung.

Das „einfache“ Create erzeugt ein Objekt des Typs TErsteKlasse und gibt einen Zeiger darauf zurück.

Verwendet man Klassen, welche die Anfangswerte ihrer Felder einstellen oder z.B. weiteren Speicher anfordern müssen, so verdeckt man die geerbte Methode mit seiner eigenen:

type
  TErsteKlasse = class
    constructor Create;
  end;

constructor TErsteKlasse.Create;
begin
  inherited;
  { Eigene Anweisungen }
end;

Das Schlüsselwort inherited ruft dabei die verdeckte Methode TObject.Create auf und sorgt dafür, dass alle notwendigen Initialisierungen durchgeführt werden. Daher muss dieses Schlüsselwort immer zu Beginn eines Konstruktors stehen.

Solange ein gleichnamiger Vorfahre aufgerufen wird, reicht das Schlüsselwort inherited, ohne weitere Angaben. Unterscheidet sich der Bezeichner vom Vorfahr im Namen oder Parametern, sollte nach inherited der Vorfahre genannt werden. Besteht der Konstruktor also nur aus dem Bezeichner Create, reicht inherited, bekommt er weitere Parameter, z. B. Create(Index: Word), kann der Vorfahre nicht mehr erkannt werden. In solchen Fällen sollte der Vorfahre genannt werden: inherited Create.

Beispiel: Sie wollen eine dynamische Adressliste schreiben, bei der der Name Ihrer Freundin immer als erster Eintrag erscheint.

type
  TAdresse = record
    Vorname, Nachname: string;
    Anschrift: string;
    TelNr: string;
  end;

  TAdressListe = class
    FListe: array of TAdresse;
    constructor Create;
  end;

In diesem Falle erstellen Sie den Konstruktor wie folgt:

constructor TAdressListe.Create;
begin
  inherited;
  SetLength(FListe, 1);  // Speicher für 1. Eintrag anfordern
  FListe[0].Vorname   := 'Barbie';
  FListe[0].Nachname  := 'Löckchen';
  FListe[0].Anschrift := 'Puppenstube 1, Kinderzimmer';
  FListe[0].TelNr     := '0800-BARBIE';
end;

Wenn Sie jetzt eine Variable mit diesem Konstruktor erstellen, enthält diese automatisch immer den Namen der Freundin:

var
  Adressen: TAdressListe;

begin
  Adressen := TAdressListe.Create;
  with Adressen.FListe[0] do
    {Ausgabe: "Barbie Löckchen wohnt in Puppenstube 1, Kinderzimmer und ist erreichbar unter 0800-BARBIE."}
    Writeln(Vorname+' '+Nachname+' wohnt in '+Anschrift+' und ist erreichbar unter '+TelNr+'.')
end.

[Bearbeiten] Destruktoren

Destruktoren dienen, wie schon oben beschrieben dazu, den von einer Klasse verwendeten Speicher wieder freizugeben. Auch hierfür stellt die Basisklasse TObjekt bereits den Destruktor Destroy bereit. Dieser gibt grundsätzlich zwar den Speicher einer Klasse wieder frei, aber nur den des Grundgerüstes. Wenn eine Klasse zusätzlichen Speicher anfordert, z.B. weil sie mit Zeigern arbeitet, wird nur der Speicher für den Zeiger freigegeben, nicht aber der Speicherplatz, den die Daten belegen.

Es sollte jedoch immer Free anstatt Destroy benutzt werden, da Free noch prüft, ob überhaupt die Klasse initialisiert wurde und Free so zu keiner Exception führen kann; im Gegensatz zu Destroy.

Eine Klasse sollte daher immer dafür sorgen, dass keine Datenreste im Speicher zurückbleiben. Dies erfolgt durch Überschreiben des Destruktors TObject.Destroy mit einem eigenen:

type
  TZweiteKlasse = class
    destructor Destroy; override;
  end;

destructor TZweiteKlasse.Destroy;
begin
  { Anweisungen }
  inherited;
end;

var
  Versuch: TZweiteKlasse;

begin
  Versuch := TZweiteKlasse.Create;
  Versuch.Destroy
end.

Eine eigene Implementation von Destroy muss immer mit dem Schlüsselword override versehen werden, da Destroy eine virtuelle Methode ist (mehr dazu unter Virtuelle Methoden). Auch hier kommt wieder das Schlüsselwort inherited zum Einsatz, welches den verdeckten Destruktor TObject.Destroy aufruft. Da dieser Speicher frei gibt, muss inherited innerhalb eines Destruktors immer zuletzt aufgerufen werden.

Wenn wir unser Beispiel der Adressliste erweitern und auf das Wesentliche reduzieren, ergibt sich folgendes Programm:

type
  TAdresse = record
    Vorname, Nachname: string;
    Anschrift: string;
    TelNr: string;
  end;

  TAdressListe = class
    FListe: array of TAdresse;
    destructor Destroy; override;
  end;

destructor TAdressListe.Destroy;
begin
  SetLength(FListe, 0);  // Speicher der dynamischen Liste freigeben
  inherited;             // Objekt auflösen
end;

var
  Adressen: TAdressListe;

begin
  Adressen := TAdressListe.Create;
  { Anweisungen }
  Adressen.Destroy;
end.

[Bearbeiten] Die Methode Free

Free dient ebenso wie Destroy dazu, den Speicher einer Klasse freizugeben. Dabei funktioniert Free jedoch etwas anders.

Destroy gibt ausschließlich den Speicher des Objektes frei, von dem aus es aufgerufen wurde. Bei allen Objekten, die von TComponent abstammen, gibt Free zusätzlich den Speicher aller Unterkomponenten frei. TComponent wird in der Programmierung grafischer Oberflächen verwendet.

Weiterhin können Sie Free auch bei Objekten anwenden, deren Wert nil ist, die also noch nicht mittels Create erstellt wurden. Destroy löst in diesem Falle eine Exception aus. Hierbei ist jedoch zu beachten, dass nur globalen Objektvariablen und Klassenfeldern automatisch nil zugewiesen wird. Lokale Variablen von Routinen bzw. Methoden enthalten anfangs meist Datenmüll, also nicht nil. Free versucht daher einen ungültigen Speicherbereich freizugeben, was zu einer Exception führt. Objektvariablen, die nicht mit Sicherheit initialisiert werden, sollten Sie daher am Anfang einer Routine oder Methode den Wert nil manuell zuweisen.

Aufgrund dieser Vorteile sollten Sie immer Free bevorzugen, um ein Objekt aufzulösen.

Wenn Sie in Ihren eigenen Klassen die Methode Free erweitern wollen, können Sie diese ebenso wie Destroy überschreiben.

[Bearbeiten] Überladen

Das Überladen von Konstruktoren und Destruktoren ist genauso möglich wie bei anderen Methoden auch. Für das Beispiel unserer Adressliste könnten zum Beispiel zwei Konstruktoren bestehen: einer, der eine leere Liste erzeugt, und einer, der eine Liste aus einer Datei lädt. Genauso könnte ein Destruktor die Liste einfach verwerfen, während ein anderer die Liste vorher in einer Datei speichert.

Sie können die Konstruktoren und Destruktoren jeweils gegenseitig aufrufen. Sie sollten hierbei jedoch darauf achten, dass nur genau einer das Schlüsselwort inherited aufruft.

type
  TAdressListe = class
    constructor Create; overload;
    constructor Create(Dateiname: string); overload;
    procedure DateiLaden(Dateiname: string);
  end;

procedure TAdressListe.DateiLaden(Dateiname: string);
begin
  {...}
end;

constructor TAdressListe.Create;
begin
  inherited;
  {...}
end;

constructor TAdressListe.Create(Dateiname: string);
begin
  Create;  // ruft TAdressListe.Create auf
  Dateiladen(Dateiname);
end;

Weiteres zum Thema Überladen in den Kapiteln „Prozeduren und Funktionen“ sowie „Klassen“.

[Bearbeiten] Eigenschaften

[Bearbeiten] Einleitung

Objekte haben Eigenschaften. Dies ist eine Regel, die in der freien Natur wie auch in der objektorientierten Programmierung unter Delphi zutrifft.

Eigenschaften stellen einen Zwischenweg zwischen Feldern und Methoden einer Klasse dar. So kann man zum Beispiel beim Auslesen einer Eigenschaft einfach den Wert eines Feldes zurück erhalten, löst aber beim Ändern dieser Eigenschaft eine Reihe von Folgeaktionen aus. Dies liegt daran, dass man bei Eigenschaften genau festlegen kann, was im jeweiligen Falle passieren soll. Ebenso kann jeweils das Lesen oder das Schreiben einer Eigenschaft unterbunden werden.

Wie man bereits sieht, kann ein Programm über Eigenschaften sicherer und gleichzeitig flexibler gestaltet werden.

[Bearbeiten] Eigenschaften definieren

In der Klassendefinition legt man Eigenschaften mit folgender Syntax an:

property Name: <Typ> [read <Feld oder Methode>] [write <Feld oder Methode>];

Die Schlüsselwörter read und write sind so genannte Zugriffsbezeichner. Sie sind beide optional, wobei jedoch mindestens einer von beiden angegeben werden muss. Die folgenden Beispiele sind alle gültig:

property Eigenschaft1: Integer read FWert;
property Eigenschaft2: Integer write ZahlSetzen;
property Eigenschaft3: string read FText write TextSetzen;

Zur kurzen Erklärung:

• mit Zugriff auf Eigenschaft1 wird der Wert des Feldes FWert zurück gegeben, eine Zuweisung an Eigenschaft1 ist jedoch nicht möglich (Nur-Lesen-Eigenschaft)
• Eigenschaft2 dürfen nur Werte zugewiesen werden, diese werden dann an die Methode ZahlSetzen weitergereicht. Das Auslesen des Wertes ist über Eigenschaft2 nicht möglich (Nur-Schreiben-Eigenschaft)
• Eigenschaft3 ermöglicht hingegen sowohl das Schreiben als auch das Lesen von Daten (Lesen-Schreiben-Eigenschaft)

Im Normalfall wird man überwiegend Lese-Schreib-Eigenschaften verwenden und ggf. einige Nur-Lesen-Eigenschaften. Nur-Schreib-Eigenschaften sind hingegen sehr selten anzutreffen, können aber im Einzelfall einen ebenso nützlichen Dienst erweisen.

Verwendet man für den Zugriff ein Feld, muss dieses lediglich den gleichen Typ haben wie die Eigenschaft. Sollen jedoch Methoden beim Zugriff zum Einsatz kommen, müssen diese bestimmten Regeln folgen: Für den Lesezugriff benötigt man eine Funktion ohne Parameter, deren Ergebnis vom Typ der Eigenschaft ist. Beim Schreibzugriff muss eine Prozedur verwendet werden, deren einziger Parameter den gleichen Typ wie die Eigenschaft besitzt.

Gut, das alles hört sich etwas kompliziert an. Gestalten wir doch mal ein kleines Gerüst für die Verwaltung eines Gebrauchtwagenhändlers:

type
  TFarbe = (fSchwarz, fWeiß, fSilber, fBlau, fGruen, fRot, fGelb);
  TAutoTyp = (atKlein, atMittelStufe, atMittelFliess, atKombi, atLuxus, atGelaende);

  TAuto = class
  private
    FFarbe: TFarbe;
    FTyp: TAutoTyp;
    procedure FarbeSetzen(Farbe: TFarbe);
    function PreisBerechnen: Single;
  public
    property Farbe: TFarbe read FFarbe write FarbeSetzen;
    property Typ: TAutoTyp read FTyp;
    property Preis: Single read PreisBerechnen;
    constructor Create(Farbe: TFarbe; Typ: TAutoTyp);
  end;

Wie man bereits ohne das vollständige Programm erkennen kann, haben wir mit dieser Klasse ähnliche Möglichkeiten wie in der realen Welt. Zum Beispiel ist es dem Händler möglich, das Auto umzulackieren. Hierbei wird eine Methode aufgerufen, die möglicherweise Folgeaktionen auslöst (z.B. das Auto für eine Weile als „nicht im Bestand“ markiert). Andererseits kann der Händler zwar abrufen, um welchen Autotyp es sich handelt, kann diesen aber selbstverständlich nicht verändern. Der Preis ist nicht starr festgelegt, sondern wird über eine Funktion berechnet (die sich wahrscheinlich unter anderem an der Farbe und am Typ des Autos orientiert).

Weiterhin ist diese Klasse so angelegt, dass man „von außen“ nur Zugriff auf die Eigenschaften und den Konstruktor von TAuto hat. Die Felder und Methoden dienen nur der internen Verwaltung der Eigenschaften und sind daher im private-Abschnitt verborgen.

[Bearbeiten] Array-Eigenschaften

Eigenschaften können auch als Arrays definiert werden. Dies ist immer dann sinnvoll, wenn man Daten in Form einer Tabelle bzw. Auflistung speichern möchte. Der Zugriff erfolgt wie bei Variablen über Indizes in eckigen Klammern. Hinter den Zugriffsbezeichnern darf bei Array-Eigenschaften allerdings kein Feld angegeben werden, hier sind nur Methoden zulässig:

property Zeile[Nr: Integer]: string read HoleZeile write SchreibeZeile;
property Punkt[X, Y: Integer]: Integer read HolePunkt;

Die zugehörigen Methoden werden dann wie folgt definiert:

function HoleZeile(Nr: Integer): string;
procedure SchreibeZeile(Nr: Integer; Text: string);
function HolePunkt(X, Y: Integer): Integer;

Als erste Parameter werden also immer die Felder des Arrays angesprochen, dann folgen die Parameter analog den einfachen Eigenschaften. Die Bezeichner der Variablen müssen mit den Indizes der Eigenschaften nicht notwendigerweise übereinstimmen. Um die Anwendung jedoch übersichtlich zu gestalten, sollte man jedoch gleiche Bezeichner verwenden. Grundsätzlich wäre also auch folgende Notation gültig:

function HoleZeile(ZeilenNr: Integer): string;
property Zeile[X: Integer]: string read HoleZeile;

[Bearbeiten] Überschreiben

[Bearbeiten] Sichtbarkeit ändern

Bei der Vererbung von Klassen kann es vorkommen, dass man Eigenschaften mit der Sichtbarkeit protected erbt, diese aber in der eigenen Klasse als public kennzeichnen möchte. Hierfür ist es möglich, die Eigenschaften mit der gewünschten Sichtbarkeit neu zu definieren.

Beispiel: Wir haben von der Klasse TBasis die als private gekennzeichnete Eigenschaft „Name“ geerbt. Um diese nun allgemein zugänglich zu machen, schreiben wir einfach:

public
  property Name;

Damit wurde an der Funktionsweise der Eigenschaft nichts geändert, sie ist jetzt lediglich „besser sichtbar“. Damit ist der Programmcode bereits vollständig. Es müssen keine weiteren Zugriffsfelder oder -methoden hierfür geschrieben werden.

Auf diese Weise ist es ebenfalls möglich, öffentlich zugängliche Eigenschaften als privat zu kennzeichnen.

[Bearbeiten] Neu definieren

Wenn Sie nun von einer Klasse eine Eigenschaft vererbt bekommen, die Sie anders verarbeiten wollen, können Sie diese wie eine gewöhnliche Eigenschaft mit dem gleichen Namen neu definieren. Hierzu sind ebenfalls die Angaben der Zugriffsbezeichner erforderlich. So lässt sich zum Beispiel eine Lese-Schreib-Eigenschaft als Nur-Lesen-Eigenschaft neu definieren:

type
  TBasis = class
    FFarbe: string;
    property Farbe: string read FFarbe write FFarbe;
  end;
  
  TErbe = class(TBasis)
    property Farbe: string read FFarbe;
  end;

„FFarbe“ muss in der Klasse „TErbe“ nicht neu eingeführt werden, es wird das Feld aus der Basis-Klasse verwendet. Falls ein Zugriffsbezeichner in der Basisklasse als private gekennzeichnet wurde, gibt Delphi bei der Kompilierung eine entsprechende Warnung aus. Für reine Delphi-Programme kann diese Warnung ignoriert werden. Sie ist für die Portierung des Programms in andere Programmiersprachen gedacht, da dort eine solche Schreibweise unter Umständen nicht erlaubt ist.

Falls eine Eigenschaft eine Methode für den Zugriff verwendet und Sie das Verhalten ändern wollen, müssen Sie lediglich die geerbte Methode überschreiben. Mehr hierzu im nächsten Kapitel „Vererbung“.

[Bearbeiten] Zugriff auf Eigenschaften

Der Zugriff auf Eigenschaften erfolgt wie bei Feldern und Methoden:

Objekt.Eigenschaft := Wert;
Wert := Objekt.Eigenschaft;

Hierbei ist jedoch zusätzlich zur Sichtbarkeit auch die Zugriffsmöglichkeit der Eigenschaft zu beachten, das heißt, ob Sie eine Nur-Lesen-, Nur-Schreiben- oder eine Lese-Schreib-Eigenschaft verwenden wollen. Die Eigenschaften verhalten sich wie eine Mischung aus Variablen und Methoden, z.B. kann man Werte auslesen und übergeben. Nicht möglich ist dagegen die Übergabe einer Eigenschaft als Variablen-Parameter einer Funktion. So erzeugt dieser Programmschnipsel eine Fehlermeldung:

type
  TKlasse = class
  private
    FZahl: Integer;
  public
    property Zahl: Integer read FZahl write FZahl;
  end;

var
  Test: TKlasse;

begin
  Test := TKlasse.Create;
  Test.Zahl := 0;
  Inc(Test.Zahl);  // <-- Fehlermeldung
  Test.Destroy;
end.

Obwohl hier die Daten letztlich in der Klassenvariablen FZahl gespeichert werden, darf die dazugehörige Eigenschaft Zahl nicht an die Routine Inc übergeben werden. Hier bleibt letztlich nur der direkte Weg:

Test.Zahl := Test.Zahl + 1;

[Bearbeiten] Standard-Eigenschaften

Wie oben beschrieben muss beim Zugriff auf eine Eigenschaft immer der Name der Eigenschaft selbst angegeben werden. Für Array-Eigenschaften gibt es eine praktische Besonderheit: die Standard-Eigenschaft. Wenn eine Array-Eigenschaft als Standard definiert wird, kann der Name dieser Eigenschaft beim Zugriff weggelassen werden. Dies erreicht man durch Angabe der Direktive default hinter der Eigenschaften-Definition:

 property Eigenschaft[X: Integer]: string read LeseMethode write SchreibMethode; default;

Jetzt sind diese beiden Angaben gleichbedeutend:

 Wert := Objekt.Eigenschaft[Index];
 Wert := Objekt[Index];

Selbstverständlich kann nur jeweils eine Eigenschaft je Klasse als Standard definiert werden.

[Bearbeiten] Vererbung

[Bearbeiten] Einleitung

Das Vererben von sämtlichen Methoden, Feldern, etc. von einer alten Klasse ist eine ganz wichtige Eigenschaft von Klassen.
So ist es z.B. möglich, von einer Klasse TWirbeltier die Klasse TMensch abzuleiten. So kann man eine bestehende Klasse spezialisieren, oder auch verändern.
Jede Klasse ist ein Nachkomme von TObject.

[Bearbeiten] Deklaration

Es wird einfach hinter das Schlüsselwort class die Vorfahrklasse in Klammern gesetzt, und schon kann man die Nachkommenklasse benutzen.

[Bearbeiten] TObject

Da jede Klasse ein Nachkomme von TObject ist, ist es bei Delphi nicht nötig, TObject extra hinzuschreiben. Deswegen sind die beiden Deklarationen absolut gleichwertig und gleichbedeutend:

type
  TMeineKlasse = class (TObject)   
  end;

oder

type
  TMeineKlasse = class
  end;

[Bearbeiten] Beispiel

type
  TWirbeltier = class
  private
    AnzKnochen: Integer;
  public
    Lebt: Boolean;

    procedure Iss(Menge: Integer);
    function Gesundheit: Integer;
  end;
  

  TMensch = class (TWirbeltier)
  end;

TMensch besitzt alle Methoden und Felder von TWirbeltier. Folgender Aufruf ist also völlig legitim (abgesehen davon, dass Mensch.Gesundheit nicht gesetzt wurde):

var Mensch: TMensch;
begin
  Mensch := TMensch.Create;
  Mensch.Iss(10);
  Writeln(Mensch.Gesundheit);
  Mensch.Free;
end;

[Bearbeiten] Ersetzen von Methoden und Feldern

Wenn man eine Methode/Feld in der Nachkommenklasse deklariert, die den selben Namen hat wie in der Vorfahrklasse, dann wird die Vorfahr-Methode/Feld durch die neu deklarierte ersetzt.

type
  TWirbeltier = class
  private
    AnzKnochen: Integer;
  public
    Lebt: Boolean;

    procedure Iss(Menge: Integer);
    function Gesundheit: Integer;
  end;
  

  TMensch = class (TWirbeltier)
    procedure Iss(Menge: Integer);
  end;

procedure TWirbeltier.Iss(Menge: Integer);
begin
  Writeln(Menge);
end;

procedure TMensch.Iss(Menge: Integer);
begin
  Writeln(Menge*2);
end;

var Mensch: TMensch;

begin
  Mensch := TMensch.Create;
  Mensch.Iss(10);
  Mensch.Free;
end.

Die procedure Iss von TMensch ersetzt Iss von der Vorfahrklasse. Und damit wird 20 ausgegeben werden.

[Bearbeiten] Überschreiben von Methoden und Feldern

Wenn man eine Methode/Feld ersetzen will, aber trotzdem noch unter Umständen auf die Vorfahr-Methode/Feld zugreifen will, dann überschreibt man sie mit dem Schlüsselwort override und muss in der Vorfahrklasse diese Methode/Feld mit dem Schlüsselwort virtual kennzeichnen.
Die Vorfahr-Methode/Feld ist dann sozusagen virtuell im Hintergrund schlummernd.
Dann ist die virtuelle Vorfahr-Methode/Feld über das Schlüsselwort inherited zu erreichen.

type
  TWirbeltier = class
  private
    AnzKnochen: Integer; 
  public
    Lebt: Boolean;

    procedure Iss(Menge: Integer); virtual;
    function Gesundheit: Integer;
  end;
  

  TMensch = class (TWirbeltier)
    procedure Iss(Menge: Integer); override;
  end;

procedure TWirbeltier.Iss(Menge: Integer);
begin
  Writeln(Menge);
end;

procedure TMensch.Iss(Menge: Integer);
begin
  Writeln(Menge); 
  inherited Iss(Menge*2);  // hier wird die Vorfahr-Methode aufgerufen
end;

var Mensch: TMensch;

begin
  Mensch := TMensch.Create;
  Mensch.Iss(10);
  Mensch.Free;
end.

Hier wird erst 10 ausgegeben werden, dann 20.
Dies ist ein sehr großer Vorteil bei dem Überschreiben, dass man eine Methode sehr gut erweitern kann, ohne den Code nochmal abschreiben zu müssen.
Also in dem Beispiel: Wieso nochmal Writeln aufrufen? Wir benutzen einfach die virtuelle Methode.

[Bearbeiten] dynamic

Anstatt des Schlüsselwortes virtual kann man auch dynamic benutzen. Jedoch arbeitet es nicht so schnell wie virtual. Die Benutzung ist aber genau die selbe.

[Bearbeiten] Zugriff auf Klassen

Hauptsächlich arbeitet man mit Instanzen von Klassen, also Variablen, die über einen Konstruktor erstellt wurden. Die regulären Felder, Methoden und Eigenschaften lassen sich erst aus dieser Instanz heraus verwenden.

Es kann jedoch auch vorkommen, dass man nicht mit einer Instanz, sondern mit der Klasse selbst arbeiten möchte, zum Beispiel um grundlegende Daten über eine Klasse zu erhalten. Hierfür gibt es so genannte Klassenvariablen, Klassenmethoden und Klasseneigenschaften. Diese werden ähnlich für der Konstruktor über die Typbezeichnung einer Klasse aufgerufen, statt über eine Variable. Vor einem Klassenmember steht immer das Schlüsselwort class:

type
  TKlasse = class
  private
    class var FVariable: Byte;
  public
    class procedure SchreibeVariable;
    class property Variable: Byte read FVariable write FVariable;
  end;

class procedure TKlasse.SchreibeVariable;
begin
  Writeln(Variable);
end;

begin
  TKlasse.Variable := 15;
  TKlasse.SchreibeVariable;
end.

Dieses Beispiel ist bereits so lauffähig, es wird keine Variable benötigt, über die eine Instanz angelegt werden muss.

Klassenmethoden können nur auf Klassenvariablen und -eigenschaften zugreifen, auf normale (instantiierte) nicht. Andersherum können jedoch Instanzmethoden Klassenelemente lesen, ändern bzw. aufrufen. Von einem solchen Konstrukt sollte man jedoch Abstand nehmen, da jede Instanz die Klassenvariable beliebig verändern kann. Dies kann zu unvorhergesehenem Verhalten führen. Folgendes ist also möglich:

type
  TVorfahr = class
  public
    class var Text: string;
    procedure NeuenWertSetzen;
  end;

  TNachfahr = class(TVorfahr)
  public
    procedure NeuenWertSetzen;    // überschreibt die geerbte Methode
  end;

procedure TVorfahr.NeuenWertSetzen;
begin
  Text := 'Vorfahr';
end;

procedure TNachfahr.NeuenWertSetzen;
begin
  Text := 'Nachfahr';
end;

var
  Vorfahr: TVorfahr;
  Nachfahr: TNachfahr;

begin
  Vorfahr := TVorfahr.Create;     // neue Instanz vom Vorfahr, Text = ''
  Nachfahr := TNachfahr.Create;   // neue Instanz vom Nachfahr, Text = ''

  TVorfahr.Text := 'Geht los!';   // TVorfahr.Text = 'Geht los!'
  Vorfahr.NeuenWertSetzen;        // TVorfahr.Text = 'Vorfahr'
  Nachfahr.NeuenWertSetzen;       // TVorfahr.Text = 'Nachfahr'!!!

  Nachfahr.Free;
  Vorfahr.Free;
end.

In diesem Beispiel wird eine Vorfahrklasse angelegt, die eine Klassenvariable „Text“ enthält. Die Methode dieser Klasse füllt die Variable mit „Vorfahr“. Anschließend wird die Klasse an TNachfahr vererbt. Diese enthält ebenfalls die Klassenvariable „Text“, und die überschriebene Methode füllt die Variable mit „Nachfahr“. Die Methode ist eine reguläre Objektmethode, d.h. sie kann nur über eine Instanz der jeweiligen Klasse aufgerufen werden.

Als erstes legen wir also entsprechende Objektinstanzen für beide Klassen an. Dann tragen wir in der Klassenvariablen TVorfahr.Text einen Wert ein, der auch bei einer Ausgabe auf dem Bildschirm so erscheinen würde. Als nächstes lassen wir das Vorfahr-Objekt diesen Text überschreiben. Dabei passiert noch immer nichts unerwartetes, TVorfahr.Text hat nun den entsprechenden Inhalt. Nun aber trägt das Nachfahr-Objekt einen neuen Wert ein und damit besitzt auch TVorfahr.Text diesen neuen Wert.

Auch wenn es nicht so aussieht, es gibt auch eine praktische Anwendung hierfür: Instanzzähler. Unter Umständen möchte oder muss man wissen, wie oft von einer Klasse Objekte erstellt wurden. Dafür kann man einfach eine Klassenvariable als Zähler verwenden und diesen im Konstruktor erhöhen bzw. im Destruktor verringern.

[Bearbeiten] Interfaces

Dieses Kapitel muss noch angelegt werden. Hilf mit unter: http://de.wikibooks.org/wiki/Programmierkurs:_Delphi

[Bearbeiten] Exceptions

Exceptions (deutsch: Ausnahmen) sind eventuelle Fehler, die auftreten können. Anfänger sollten wissen, dass man diese Exceptions mit der Konstruktion try-except abfangen kann. Hier stehen noch ein paar weitere, detailliertere Informationen zu Exceptions.

[Bearbeiten] Abfangen von Exceptions

Erst einmal gibt es eine ganze Reihe vordefinierter Exceptions. Die bekanntesten Exception-Typen (jede Exception hat einen Klassentypen) sind wahrscheinlich EMathError, EConvertError und EZeroDivide. Vorallem der letzte tritt häufig auf, wenn man Ergebnisse zum Beispiel bei einem Taschenrechner nicht prüft. EZeroDivide könnte hier auftreten:

 var
  a, b: Integer;
begin
  a := 2;
  b := 0;
  Writeln(a / b);
end;

In der Delphi-IDE kann man zwar Exceptions abschalten, davon wird es jedoch nicht besser. Ein weiteres Beispiel ist der EConvertError, der zum Beispiel auftritt, wenn man bei einer StrToInt eine ungültige Eingabe gemacht hat. Beide diese Exceptions sind bei einem Taschenrechner ziemlich wahrscheinlich. Lösung 1: Alles in einen try-except-Block packen und bei Except eine Writeln mit "Fehler!" ausgeben. Natürlich ginge auch "Division durch 0" oder irgendetwas! Jedoch wollen wir den User auch über seinen Fehler im Detail informieren. Beim Letzteren Beispiel könnte aber auch eine Eingabe falsch sein. Lösung: Exceptions!

try
  Writeln(a / b);
except
  on EZeroDivide do
    Writeln('Fehler: Division durch 0!';
  on EConvertError do
    Writeln('Fehler: Ungueltige Eingabe!';
end;

Damit wäre das Problem gelöst, der User wird über seinen Fehler informiert!

[Bearbeiten] Deklaration

Man kann für eine eigene Klassen auch eigene Exceptions erstellen. Genau genommen sind Exceptions sogar selbst Klassen. Beispiel:

EMyError = class(Exception);

Die Hierarchie würde nun so aussehen:

Exception
   │
   └─── EMyError

Nun wird an einer Stelle (mit if abgefragt) eine Exception ausgelöst:

raise EMyError.Create;

Exceptions sollten immer ausgelöst werden, wo das Programm zusammenbrechen könnte, gerade dann, wenn man eine Klasse weitergeben möchte.

[Bearbeiten] Schnelleinstieg

[Bearbeiten] Einstieg

[Bearbeiten] Was ist Delphi

Borland Delphi ist eine RAD-Programmierumgebung von Borland. Sie basiert auf der Programmiersprache Object Pascal. Borland benannte Object Pascal jedoch 2003 in Delphi-Language um, mit der Begründung, dass sich bereits soviel in der Sprache verändert habe, dass man es nicht mehr mit Pascal vergleichen könne. RAD-Umgebungen für Object Pascal bzw. Delphi existieren nur wenige. Der bekannteste ist der Delphi-Compiler von Borland. Für Linux gibt es Kylix (Anmerkung: Kylix wurde eingestellt), das ebenfalls von Borland stammt und mit Delphi (ggf. mit wenigen Code-Änderungen) kompatibel ist. Darüber hinaus gibt es das freie Projekt Lazarus, das versucht eine ähnliche Entwicklungsumgebung bereitzustellen. Dieses nutzt FreePascal für die Kompilierung und ist für verschiedene Betriebssysteme erhältlich.

[Bearbeiten] Warum Delphi?

Es gibt viele Gründe, Delphi zu benutzen. Es gibt aber wahrscheinlich auch genauso viele dagegen. Es ist also mehr Geschmacksache, ob man Delphi lernen will oder nicht. Wenn man allerdings Gründe für Delphi sucht, so fällt sicher zuerst auf, dass Delphi einfach zu erlernen ist, vielleicht nicht einfacher als Basic aber doch viel einfacher als C/C++. Gegenüber Basic hat Delphi allerdings den Vorteil, dass Delphi viel mächtiger ist. Für professionelle Programmierer ist es sicher auch wichtig zu wissen, dass die Entwicklung von eigenen Komponenten unter Delphi einfach zu handhaben ist. Durch die große Delphi-Community mangelt es auch nicht an Funktionen und Komponenten.

Erstellt man größere Projekte mit Borlands Delphi Compiler, so ist die Geschwindigkeit beim Kompilieren sicher ein entscheidender Vorteil. Auch die einfache Modularisierung, durch Units, Functions und Procedures ist sicherlich ein Vorteil der Sprache gegenüber einfachen Sprachen wie Basic.

Mit Delphi lässt sich zudem fast alles entwickeln, abgesehen von Systemtreibern. Dennoch ist es auch teilweise möglich, sehr hardwarenahe Programme zu entwickeln.

[Bearbeiten] Die Oberfläche

[Bearbeiten] Ältere Delphi-Versionen

Beim ersten Start von Delphi erscheint ein in mehrere Bereiche unterteiltes Fenster. Oben sieht man die Menüleiste, links befindet sich der Objektinspektor und in der Mitte ist eine so genannte Form. Im Hintergrund befindet sich ein Texteditor. Aus der Menüleiste kann man verschiedene Aktionen, wie Speichern, Laden, Optionen, und anderes ausführen. Unten rechts in der Menüleiste (bzw. bei neueren Delphi-Versionen am rechten Bildschirmrand) kann man die verschiedenen Komponenten auswählen, die dann auf der Form platziert werden. Im Objektinspektor kann man die Eigenschaften und Funktionen der Komponenten ändern. Der Texteditor dient dazu, den Quellcode des Programms einzugeben.

[Bearbeiten] Neuere Delphi-Versionen

Neuere Versionen haben alles in einem Fenster (standardmäßig). Vielen erschwert dies das Arbeiten. Deshalb hat man oben in der Toolbar die Möglichkeit, in einem Drop-Down-Menü (ComboBox) das klassische Layout einzustellen, das ähnlich dem der älteren Versionen ist (abgesehen davon, dass der Objektinspektor noch nach Kategorien unterteilt ist und dass die Komponentenpalette (GUI-Anwendungen) vertikal - nicht horizontal - sortiert ist.

[Bearbeiten] Das erste Programm (Hello world)

Wenn man nun mit dem Mauszeiger auf die Komponente Label (Menükarte „Standard“) und dann irgendwo auf die Form klickt, dann erscheint die Schrift „Label1“. Das so erzeugte Label kann man nun überall auf der Form verschieben. Um die Schrift zu ändern, wählt man das Label an und sucht im Objektinspektor die Eigenschaft „Caption“ und ändert den Wert von „Label1“ in „Hello world!“. Wenn man nun auf den grünen Pfeil in der Menüleiste klickt (oder F9 drückt), kompiliert Delphi die Anwendung, d.h. Delphi erstellt eine ausführbare Datei und startet diese. Nun sieht man ein Fenster mit der Schrift „Hello world!“. Das ist unsere erste Anwendung in Delphi! War doch gar nicht so schwer, oder?

[Bearbeiten] Erweitertes Programm

Nachdem wir unser „Hello world“-Programm mit Datei / Alles speichern... gespeichert haben, erstellen wir mit Datei / Neu / Anwendung eine neue GUI-Anwendung. Auf die neue Form setzt man nun einen Button und ein Label (beides Registerkarte Standard). Wenn man nun doppelt auf den Button klickt, öffnet sich das Code-Fenster. Hier geben Sie folgendes ein:

Label1.Caption := 'Hello world';

Wenn man nun das Programm mit F9 startet und dann auf den Button klickt sieht man, dass sich das Label verändert und nun „Hello world“ anzeigt. Damit haben wir eine Möglichkeit, Labels (und eigentlich alles) während der Laufzeit zu verändern.

Beenden Sie nun die Anwendung und löschen Sie den eben getippten Text wieder. Nun bewegen Sie den Cursor vor das begin und geben folgendes ein:

var
  x, y, Ergebnis: Integer;

Wenn Sie wieder unter dem begin sind, dann geben Sie

x := 40;
y := 40;
Ergebnis := x + y;
Label1.Caption := IntToStr(Ergebnis);

ein. Nun kompilieren Sie mit F9 (oder Start / Start) und sehen sich das Ergebnis an. Sie sehen, wenn man auf den Button klickt, verändert sich das Label und zeigt nun das Ergebnis der Addition an. Dies kann man natürlich auch mit anderen Zahlen oder Operationen durchführen. Es sind Zahlen von -2147483648 bis 2147483647 und die Operatoren +, -, * , div (Ganzzahlendivision) und mod (Divisionsrest) möglich.

Nun fassen wir mal zusammen, was Sie bis jetzt gelernt haben könnten bzw. jetzt lernen:

• In Delphi fungiert das „:=“ als so genannter Zuweisungsoperator, d.h. die linke Seite enthält nach der Operation den Inhalt der rechten Seite. z.B.:

x := 40;
x := y;
Label1.Caption := 'Text';

• Es gibt unter Delphi Variablen, die vorher in einem speziellen var-Abschnitt definiert werden, z.B.: x: Integer;, so kann x Zahlen von -2147483648 bis 2147483647 aufnehmen oder x, y: Integer; definiert x und y als Integer (spart Schreibarbeit!)

[Bearbeiten] Die Syntax

(Fast) jeder Programmcode-Befehl wird mit einem Semikolon/Strichpunkt (;) abgeschlossen. Ausnahmen davon sind ein nachfolgendes end (nicht nötig), else (nicht erlaubt) oder until (nicht nötig).

ShowMessage('Hallo Welt');

Strings werden von einfachen Anführungszeichen eingeschlossen

var
  s: string;
...
  s := 'ich bin ein String';

Ebenso wie einzelne Zeichen (Char)

var
  c: Char;
...
  c := 'A';

[Bearbeiten] Die Strukturen von Delphi

Delphi verfügt über die aus Pascal bekannten Kontrollstrukturen zur Ablaufsteuerung: Reihenfolge, Auswahl und Wiederholung. Als Auswahlkonzepte stehen zur Verfügung: ein-, zwei- und mehrseitige Auswahl (Fallunterscheidung). Als Wiederholstrukturen verfügt Delphi über abweisende, nicht abweisende Schleifen und Zählschleifen. Die Syntax der Strukturen stellt sich wie folgt dar:

Reihenfolge

 <Anweisung>;
 <Anweisung>;
 <Anweisung>;
 <...>

Einseitige Auswahl

 if <Bedingung> then <Anweisung>;

Zweiseitige Auswahl

 if <Bedingung> then
   <Anweisung> 
 else
   <Anweisung>;

Fallunterscheidung

 case <Fall> of
   <wert1> : <Anweisung>;
   <wert2> : <Anweisung>;
   <.....> : <Anweisung>
 else
   <Anweisung>
 end; // von case

Abweisende Schleife

 while <Wiederhol-Bedingung> do
   <Anweisung>;

Nicht abweisende Schleife

 repeat
   <Anweisung>;
   <Anweisung>;
   ...
 until <Abbruch-Bedingung>;

Zählschleife

 for <Laufvariable> := <Startwert> to <Endwert> do
   <Anweisung>;

Strukturen können ineinander verschachtelt sein: Die Auswahl kann eine Reihenfolge enthalten, in einer Wiederholung kann eine Auswahl enthalten sein oder eine Auswahl kann auch eine Wiederholung enthalten sein. Enthält die Struktur <Anweisung> mehr als eine Anweisung, so sind Blöcke mittels begin und end zu bilden. Ausnahme davon ist die Repeat-Schleife: Hier wird zwischen repeat und until automatisch ein Block gebildet.

Programmbeispiel mit allen Strukturen

 program example001;
 {$APPTYPE CONSOLE}
 uses
   SysUtils;
 var
   i      : Integer;
   Zahl   : Real;
   Antwort: Char;
 begin
   WriteLn('Programmbeispiel Kontrollstrukturen');
   WriteLn;
   repeat                  // nicht abweisende Schleife
     Write('Bitte geben Sie eine Zahl ein: ');
     ReadLn(Zahl);
     if Zahl <> 0 then     // einseitige Auswahl
       Zahl := 1 div Zahl;
     for i := 1 to 10 do   // Zählschleife
       Zahl := Zahl * 2;
     while Zahl > 1 do     // abweisende Schleife
       Zahl := Zahl div 2;
     i := Round(Zahl) * 100;
     case i of             // Fallunterscheidung
       1: Zahl := Zahl * 2;
       2: Zahl := Zahl * 4;
       4: Zahl := Zahl * 8
     else
       Zahl := Zahl * 10
     end;
     if Zahl <> 0 then     // zweiseitige Auswahl
       WriteLn(Format('Das Ergebnis lautet %.2f', [Zahl]))
     else
       Writeln('Leider ergibt sich der Wert von 0.');
     Write('Noch eine Berechnung (J/N)? ');
     ReadLn(Antwort)
   until UpCase(Antwort) = 'N'
 end.

[Bearbeiten] Prozeduren und Funktionen

Grundsätzlich wird zwischen Prozeduren und Funktionen unterschieden. Dabei liefert eine Funktion immer einen Rückgabewert zurück, hingegen eine Prozedur nicht.

[Bearbeiten] Deklaration

Der eigentliche Code einer Prozedur oder Funktion (in OOP auch als Methode bezeichnet) beginnt immer nach dem begin und endet mit end;

procedure TestMethode;
begin
  ShowMessage('TestMethode!');
end;

Die folgende Funktion liefert beispielsweise einen String zurück.

function TestMethode: string;
begin
  Result := 'ich bin der Rückgabewert';
end;

Parameter können wie folgt verwendet werden:

procedure TestMitParameter1(Parameter1: string);

Mehrere Parameter werden mit „;“ getrennt.

procedure TestMitParameter2(Parameter1: string; Parameter2: Integer);

Mehrere Parameter vom gleichen Typ können auch mit „,“ getrennt werden:

procedure TestMitParameter3(Parameter1, Parameter2: string);

[Bearbeiten] Aufruf

Eine Methode - egal, ob Prozedur oder Funktion - wird prinzipiell nach folgendem Muster aufgerufen:

Methode(Parameter1, Parameter2, Parameter3, Parameter_n);

Es fällt auf, dass Parameter - im Gegensatz zur Deklatation - durch ein Komma, nicht durch ein Semikolon, getrennt werden. Bei Funktionen kann das Resultat (Result) verwendet werden, muss aber nicht. Falls nicht, geschieht das wie bei der Prozedur, falls doch, wird es wie folgt erweitert:

Variable := Funktion(Parameter1, Parameter2, Parameter3, Parameter_n);

Parameter, die bei der Deklaration in eckige Klammern geschrieben wurden, werden entweder ignoriert oder zugewiesen, jedoch nicht in eckige Klammern geschrieben. Delphi erkennt an der Anzahl der Parameter, ob diese Parameter verwendet wurden.

[Bearbeiten] Datentypen (Array, Records und Typen)

[Bearbeiten] Arrays

Ein Array ermöglicht es, Daten zu indizieren und Tabellen zu erstellen. Es gibt zwei verschiedene Arten von Arrays:

[Bearbeiten] Eindimensionale Arrays

[Bearbeiten] Statische Arrays

• Ein statisches Array besitzt eine in der Variablendeklarierung festgelegte Größe, die in eckigen Klammern angegeben wird:

var
  test_array: array[1..10] of Byte;

definiert ein Array, das mit 10 Byte-Werten gefüllt werden kann. Man unterscheidet in Delphi zwischen 0-basierten und 1-basierten Arrays, wobei der Unterschied eigentlich nur in der Zählweise liegt:

var
  array_0: array[0..9] of Byte;

definiert ein gleich großes Array mit 0 als ersten Index. Dies ist eigentlich Geschmacksache, aber wer nebenbei C/C++ programmiert, dem wird die 0-basierte Schreibweise sicher vertrauter sein.

[Bearbeiten] Dynamische Arrays

• Ein dynamisches Array ist in seiner Größe dynamisch (wie der Name schon sagt). Das heißt, dass man die Größe während der Laufzeit verändern kann, um beliebig große Datenmengen aufzunehmen. Die Deklaration erfolgt mit

var
  array_d: array of Byte;

Will man zur Laufzeit dann die Größe verändern, so erfolgt die über die procedure SetLength(array, neue_Laenge). Mit den Funktionen High(array) und Low(array) erhält man den höchsten und den niedrigsten Index des Arrays. Bei dynamischen Arrays ist zu beachten, dass diese immer 0-basiert sind.
Mit Length(tabelle1) bekommt man die Länge des Arrays heraus. Hier ist zu beachten, dass bei einem Array von 0 bis 2, 3 Elemente vorhanden sind und darum die Zahl 3 zurückgegeben wird.

Der Zugriff auf ein Array erfolgt mit arrayname[5] := 10;. Der Vorteil von Arrays ist, dass man sie einfach in Schleifen einbauen kann:

var
  arrayname: array[1..10] of Byte;
begin
  for i := 1 to 10 do
    arrayname[i] := 10;
end;

[Bearbeiten] Mehrdimensionale Arrays

Außerdem kann man mit Arrays mehrere Dimensionen definieren:

[Bearbeiten] Statische Arrays

var
  tabelle1: array[1..10] of array[1..10] of Byte;   // dies ist gleichbedeutend mit:
  tabelle2: array[1..10, 1..10] of Byte;

definiert beides eine Tabelle mit der Größe 10x10. Der Zugriff erfolgt über

tabelle[5, 8] := 10;

Damit wird die Zelle in der 8. Reihe und in der 5. Spalte mit 10 belegt.

[Bearbeiten] Dynamische Arrays

var
  Tabelle1: array of array of Byte;

Natürlich muss man auch hier mit SetLength die Länge des Arrays bestimmen. Und das geht so:

SetLength(Tabelle1, 9, 9);

Dies definiert eine 2-dimensionale Tabelle mit der Größe 9×9. Der Zugriff kann nun wie bei einem statischen Array erfolgen. Beide Indizes liegen im Bereich 0..8.

[Bearbeiten] Typen

Mit einer Typendeklaration kann man eigene Datentypen festlegen, dies erfolgt z.B. durch

type
  Zahl = Integer;

Nach dieser Deklaration kann man überall anstatt Integer Zahl einsetzen:

var
  x: Zahl;

Interessant werden Typen, wenn man zum Beispiel eine Arraydefinition, z.B. eine bestimmte Tabelle öfter einsetzen will:

type
  Tabelle = array[1..10, 1..10] of Byte;

oder wenn man Records oder Klassen benutzt.
Natürlich funktioniert das mit allen Arten von Arrays, also auch mehrdimensional, dynamisch, etc.

[Bearbeiten] Records

Mit einem Record kann man einer Variable mehrere Untervariablen geben, dies ist z.B. bei Datensammlungen der Fall. Man definiert einen Record fast immer über einen Typen:

type
  THighscoreEintrag = record
    Nr: Byte;
    Name: string;
    Punkte: Integer;
  end;

Wenn man nun eine 10-stellige Highscoreliste erstellen will, dann benutzt man die Anweisung:

var
  Hscr: array[1..10] of THighscoreEintrag;
begin
  Hscr[1].Nr := 1;
  Hscr[1].Name := 'Der Erste';
  Hscr[1].Punkte := 10000;
end;

[Bearbeiten] Pointer

[Bearbeiten] Einleitung

Der RAM als Modell

Betrachtet man den RAM, so fällt folgende Struktur auf:

Der RAM^[1] ist unter den verschiedenen Anwendungen und dem Betriebssystem aufgeteilt; Den RAM, den eine Anwendung verbraucht, kann man wiederum in Heap und Stack unterteilen. Im Stack werden alle Variablen gespeichert, die z.B. mit var i: Integer; deklariert worden sind. Das Problem am Stack ist, dass er in der Größe sehr beschränkt ist. Bei großen Datenstrukturen sollte man daher auf den Heap zurückgreifen. Dazu benötigt man Zeiger (Pointer).

[Bearbeiten] Grundlagen

Ein Zeiger in den Heap

Ein Pointer ist in der Regel 4 Bytes groß, d.h. es lohnt sich normalerweise nicht, einen Pointer auf einen Bytewert zu erzeugen, da dieser nur einen Byte belegt! Ein Pointer auf eine bestimmte Datenstruktur wird folgenderweise definiert:

var
  zgr: ^TDaten;

Einem Pointer muss immer ein Wert zugewiesen werden! Für den Fall, dass ein Pointer vorerst nicht gebraucht wird, kann ein Zeiger auch ins Leere zeigen, dies geschieht mit der Zuweisung:

zgr := nil; // nil = not in list

Bevor man den Zeiger allerdings auf Daten zeigen lassen kann muss man zuerst Speicher im Heap reservieren:

New(zgr);

Nun kann man auf die Daten zugreifen, als wäre es eine normale Variable, allerdings hängt man dem Zeigernamen beim Zugriff ein Zirkumflex (^) hinten an:

zgr^ := 50000;

Dies ist nötig, da in zgr selber die Anfangsadresse von zgr^ im Heap gespeichert ist. Wenn TDaten allerdings ein Record ist, so kann man theoretisch beim Zugriff auf die einzelnen Unterpunkte den Zirkumflex weglassen:

zgr.nummer := 1;

Wenn man einen Pointer im weiterem Programmverlauf nicht mehr braucht, dann sollte man unbedingt den belegten Speicher wieder freigeben:

Dispose(zgr);

Mit diesen Grundlagen sollte das Kapitel über Listen, Bäume und Schlangen eigentlich kein Problem mehr darstellen!

[Bearbeiten] Weiterführende Literatur

1. ↑ RAM: siehe http://de.wikibooks.org/wiki/Computerhardware:_RAM

[Bearbeiten] Dynamische Datenstrukturen

[Bearbeiten] Die klassische Methode: Listen

Bitte beachten: Die hier gezeigte Vorgehensweise ist stark veraltet, fehleranfällig und umständlich.
Seit Delphi 4 gibt es bessere und sicherere Methoden, dynamische Datenstrukturen zu handhaben.
Siehe hierzu Die moderne Methode: Klassen. Die klassische Vorgehensweise ist nur für erfahrene
Programmierer geeignet, die aus dieser Laufzeit-Geschwindigkeitsvorteile ziehen wollen.

Eine Liste ist wie alle dynamischen Datenstrukturen eine rekursive Datenstruktur, d.h.: sie referenziert sich selbst. Schauen wir uns mal folgendes Beispiel für eine Typendefinition für Listen an:

type
  PListItem = ^TListItem;
  TListItem = record
    data: Integer;
    next: PListItem;  // Verweis auf das nächste Item
  end;

Man sieht, dass der Zeiger in PListItem auf ein Objekt gelegt wird, das noch nicht definiert ist. Eine solche Definition ist nur bei rekursiven Strukturen möglich.

Möchte man nun eine neue, leere Liste erzeugen, so reicht folgender Code:

var
  Liste: PListItem;
begin
  New(Liste);
  Liste^.data := 0;
  Liste^.next := nil; // WICHTIG!!!
end;

Vergessen Sie bitte niemals, einen nicht benötigten Zeiger (wie in diesem Fall) auf nil zu setzen, da das gerade bei dynamischen Datenstrukturen zu nicht vorhersehbaren Fehlern führen kann.

Wollen sie nun ein Item der Liste hinzufügen, ist folgender Code zu benutzen:

New(Liste^.next);

und die entsprechende Belegung mit Nichts:

Liste^.next^.data := 0;
Liste^.next^.next := nil;

Es ist natürlich lästig und aufwändig, die Liste auf diese Weise zu vergrößern. Deshalb benutzt man eine Prozedur, um die Liste bis zu ihrem Ende zu durchlaufen und an ihrem Ende etwas anzuhängen:

procedure AddItem(List: PListItem; data: Integer);
var
  tmp: PListItem;
begin
  tmp := List;
  while tmp^.next <> nil do
    tmp := tmp^.next;
  New(tmp^.next);
  tmp^.next^.data := data;
  tmp^.next^.next := nil;
end;

Da dies aber sehr zeitaufwändig ist, sollte immer das letzte Element der Liste gespeichert werden, um nicht zuerst die gesamte Liste durchlaufen zu müssen, bevor das neue Element angehängt werden kann.

Um eine Liste wieder aus dem Speicher zu entfernen, genügt es nicht, die Variable Liste auf nil zu setzen. Dabei würde der verbrauchte Speicherplatz belegt bleiben und auf die Dauer würde das Programm den Speicher „zumüllen“. Um die Objekte wieder freizugeben, muss Dispose verwendet werden:

Dispose(Item);

Da hierbei jedoch das Element in next (falls vorhanden) nicht ordnungsgemäß freigegeben würde, muss man mit einer Schleife alle Elemente einzeln freigeben:

procedure DisposeList(var List: PListItem);
var
  current, temp: PListItem;
begin
  current := List;
  while current <> nil do
  begin
    temp := current^.next;
    Dispose(current);
    current := temp;
  end;
  List := nil;
end;

Hier wird in jedem Schleifendurchlauf das aktuelle Element freigegeben und das nächste Element zum aktuellen gemacht. Hier wäre zwar prinzipiell auch eine rekursive Funktion möglich (und eventuell auch die zunächst offensichtliche Lösung), diese würde aber bei sehr großen Listen einen Stack Overflow auslösen.

[Bearbeiten] Die moderne Methode: Klassen

Nachteile der Listenmethode sind vor allem die Fehleranfälligkeit und die umständliche Referenzierung. Sinnvoller - und natürlich auch komplexer - ist hier der Einsatz einer sich selbst verwaltenden Klasse. Hierbei hat man als Anwender lediglich Zugriff auf Methoden, nicht jedoch auf die Datenstruktur selbst. Dies bewirkt einen höchstmöglichen Schutz vor Fehlern.

[Bearbeiten] Grundgerüst

Als Basis für die dynamische Liste wird ein dynamisches Array verwendet. Der Speicherbedarf hierfür lässt sich dem Bedarf entsprechend anpassen. Weiterhin werden Methoden benötigt, um neue Daten hinzuzufügen, nicht mehr benötigte zu löschen, vorhandene auszulesen oder zu ändern. Dies alles wird in einer Klasse gekapselt.

type
  TMyList = class
  private
    FFeld: array of Integer;
  public
    constructor Create;
    procedure Free;
    function Count: Integer;
    procedure Add(NewValue: Integer);
    procedure Delete(Index: Integer);
    procedure Clear;
    function GetValue(Index: Integer): Integer;
    procedure SetValue(Index: Integer; NewValue: Integer);
  end;

[Bearbeiten] Implementation

Im Constructor muss dem Feld Speicher zugewiesen werden, ohne diesen jedoch bereits mit Daten zu füllen:

constructor TMyList.Create;
begin
  inherited;
  SetLength(FFeld, 0);
end;

Die Methode Free sollte auf gleiche Weise den Speicher wieder freigeben:

procedure TMyList.Free;
begin
  SetLength(FFeld, 0);
  inherited;
end;

Für die Verwendung der Liste ist es oftmals notwendig, deren Größe zu kennen, um nicht eventuell über deren Ende hinaus Daten auszulesen. Das wird mit der simplen Methode Count verwirklicht.

function TMyList.Count: Integer;
begin
  Result := Length(FFeld);
end;

Um nun Daten hinzuzufügen, wird eine weitere Methode benötigt: Add. Hierbei ist zu beachten, dass der erste Index der Liste immer 0 (Null) ist. Wenn nur ein Eintrag enthalten ist (Count = 1), dann ist dieser in FFeld[0] zu finden. Durch den Aufruf von SetLength wird das Feld um einen Eintrag erweitert, womit sich auch das Ergebnis von Count um 1 erhöht. Demnach muss beim Speichern des Wertes wieder 1 subtrahiert werden.

procedure TMyList.Add(NewValue: Integer);
begin
  SetLength(FFeld, Count+1);    // Größe des Feldes erhöhen
  FFeld[Count-1] := NewValue;   // Neuen Eintrag ans Ende der Liste setzen
end;

Das Löschen eines Eintrages gestaltet sich etwas schwieriger, da dieser sich am Anfang, in der Mitte oder am Ende der Liste befinden kann. Je nachdem müssen die Daten gegebenenfalls umkopiert werden.

procedure TMyList.Delete(Index: Integer);
var
  i: Integer;
begin
  if (Index < 0) or (Index >= Count) then
    Exit;

  if Index = Count - 1 then        // letzter Eintrag
    SetLength(FFeld, Count-1)      // Es reicht, den Speicher vom letzten Eintrag freizugeben
  else                             // erster Eintrag oder irgendwo in der Mitte
  begin
    for i := Index to Count - 2 do
      FFeld[i] := FFeld[i+1];
    SetLength(FFeld, Count-1);
  end;
end;

Man sollte auch die Liste leeren können, ohne jeden einzelnen Eintrag zu löschen. Hierfür muss nur wieder die Größe des Feldes auf 0 gesetzt werden.

procedure TMyList.Clear;
begin
  SetLength(FFeld, 0);
end;

Das Auslesen und Ändern vorhandener Daten gestaltet sich ebenfalls sehr einfach.

function TMyList.GetValue(Index: Integer): Integer;
begin
  if (Index < 0) or (Index >= Count) then
    Result := -1                      // Oder ein anderer Wert, der einen Fehler darstellt
  else
    Result := FFeld[Index];
end;

procedure TMyList.SetValue(Index: Integer; NewValue: Integer);
begin
  if (Index < 0) or (Index >= Count) then
    Exit
  else
    FFeld[Index] := NewValue;
end;

[Bearbeiten] Erweiterungsmöglichkeit

Um einen noch komfortableren Zugriff auf die Daten zu erhalten, können diese über eine Eigenschaft aufgerufen werden. Hierzu werden die Methoden GetValue und SetValue „versteckt“, das heißt, im Bereich private der Klasse untergebracht. Im Bereich public kommt folgendes hinzu:

public
  property Items[I: Integer]: Integer read GetValue write SetValue; default;

Auf diese Weise ist ein wirklich einfacher Zugriff auf die Daten möglich:

var
  MyList: TMyList;
  i: Integer;
begin
  MyList := TMyList.Create;
  MyList.Add(2);       // MyList[0] = 2
  MyList.Add(3);       // MyList[1] = 3
  MyList.Add(5);       // MyList[2] = 5

  i := MyList[2];      // i = 5
  MyList[0] := 13;     // MyList[0] = 13
end;

[Bearbeiten] Anmerkung

Die hier gezeigte Lösung stellt nur den einfachsten Ansatz einer dynamischen Datenverwaltung dar. Sie kann jedoch Daten jeden Typs speichern, es muss lediglich der Typ von FFeld und aller betroffenen Methoden angepasst werden. Auch andere Klassen können so gespeichert werden.

Dieses Grundgerüst ist auf einfachste Weise erweiterbar. Zum Beispiel können Methoden zum Suchen und Sortieren von Daten eingebaut werden. Auch das Verschieben von Einträgen wäre denkbar.

[Bearbeiten] DLL-Programmierung

[Bearbeiten] Was ist eine DLL?

Eine DLL (Dynamic Link Library) kann Routinen und Forms beinhalten, die dann in ein beliebiges Programm eingebunden werden können, auch in andere Sprachen. Dazu wird die DLL in den Speicher geladen, von wo aus alle Anwendungen auf sie zurückgreifen können. Aus diesen Eigenschaften ergeben sich folgende Vorteile:

• Programmiersprachenunabhängiges Programmieren
• Beim Benutzen durch mehrere Anwendungen wird der Code nur einmal geladen
• Die DLL kann dynamisch in den Code eingebunden werden

[Bearbeiten] Das Grundgerüst einer DLL

Klickt man auf Datei->Neu->DLL erhält man folgendes Grundgerüst für eine DLL:

library Project1;
{ ...Kommentare (können gelöscht werden)...}
uses
  SysUtils,
  Classes;

begin
end.

Wie man sieht, wurde das für ein Programm übliche program durch library ersetzt, dadurch „weiß“ der Compiler, dass er eine DLL kompilieren soll und dieser die Endung .dll gibt.

In den Bereich zwischen dem Ende des uses und dem begin können nun beliebig viele Prozeduren und Funktionen eingegeben werden. Wenn man die DLL nun kompiliert, kann man allerdings noch nichts mit ihr anfangen! Man muss die Funktionen/Prozeduren, die man aus der DLL nutzen soll, exportieren! Dazu benutzt man vor dem Abschließenden begin end folgenden Code:

exports
  Funktion1 index 1,
  Funktion2 index 2;

Dadurch kann man diese Funktionen aus jedem Windows-Programm nutzen. Da andere Sprachen allerdings andere Aufrufkonventionen besitzen, muss der Funktionsdeklaration ein stdcall; hinzugefügt werden, das für den Standard-Aufruf von anderen Sprachen steht. Damit erhält man z.B. folgenden Code:

library DemoDLL;

uses
  SysUtils,
  Classes;

function Addieren(x, y: Byte): Word; stdcall;
begin
  Result := x + y;
end;

function Subtrahieren(x, y: Byte): ShortInt; stdcall;
begin
  Result := x - y;
end;

exports
  Addieren index 1,
  Subtrahieren index 2;

begin
end.

[Bearbeiten] Assembler und Delphi

[Bearbeiten] Allgemeines

In Delphi wird der Assemblerteil immer mit asm eröffnet und mit dem obligatorischen end geschlossen. Die Register edi, esi, esp, ebp und ebx müssen innerhalb des Assemblerteils unverändert bleiben! Will man sie trotzdem verwenden, muss man sie vorher auf dem Stack ablegen:

push edi
push esi
push esp
push ebp
push ebx

Und am Ende der Assembler-Anweisungen wieder zurückholen:

pop ebx
pop ebp
pop esp
pop esi
pop edi

[Bearbeiten] Syntax

Es können wahlweise Assemblerblocks mit Delphicode vermischt werden, oder ganze Prozeduren/Funktionen in Assembler verfasst werden.

Beispiel für Assembler-Funktion

function Add(a, b: Integer): Integer; assembler;
asm
  mov eax, a
  add eax, b
end;

Das Schlüsselwort assembler ist hierbei nicht verpflichtend.

Beispiel für Assembler in Delphi

function Add(a, b: Integer): Integer;
begin
  asm
    mov eax, a
    add b, eax
  end;
  result := b;
end;

Anstatt die Parameter selbst in die einzelnen Register zu schieben, kann man diese auch direkt verwenden. Die Parameter werden nämlich auf den Registern gespeichert, der erste Parameter auf EAX, der zweite auf EDX und der dritte auf ECX. Außerden kann man als Result das Register EAX verwenden. Demnach könnte die Funktion oben folgendermaßen aussehen:

function Add(a, b: Integer): Integer;
begin
  asm
    add eax, edx
  end;
end;

In der Regel wird in Assembler-Abschnitten nicht mehr als ein Befehl pro Zeile untergebracht. Mehrere Befehle können durch ein Semikolon oder einem Kommentar voneinander getrennt werden.

Assembler-Zeile:

[Label] [Befehl] [Operand(en)]

Beispiele:

xor eax, eax
mov variable, eax

xor eax, eax; mov variable, eax

xor eax, eax {eax leeren} mov variable, eax

Alle drei Varianten sind gleichwertig, die erste Variante mit einem Befehl pro Zeile ist jedoch die übliche und sollte vorgezogen werden. Kommentare dürfen in Assembler-Blocks nie zwischen Befehl und Operanden stehen, zwischen Label und Befehl jedoch schon.

Labels müssen als lokale Labels definiert sein:

@xxx:
{ ... }
jmp @xxx

Einige unterstützte Befehle gibt es in der Delphi-Hilfe unter dem Index „Assembler-Anweisungen“. Der integrierte Assembler unterstützt die Datentypen Byte(db), Word(dw) und DWord(dd), ein Pointer entspricht einem DWord. Wenn Sie eine Variable deklarieren, die denselben Namen hat wie ein reserviertes Wort, dann hat das reservierte Wort Vorrang. Auf die deklarierte Variable kann durch Voransetzen eines kaufmännischen Unds zugegriffen werden:

var
  ax: Integer;
asm
  mov ax, 4  {verändert das Register ax}
  mov &ax, 4 {verändert die Variable ax}
end;

[Bearbeiten] RAD-Umgebung

[Bearbeiten] Warum eine RAD-Umgebung?

Um diese Frage zu beantworten, muss man erst einmal den Begriff RAD definieren: RAD ist ein Akronym für Rapid Application Development (dt. etwa: „Schnelle Anwendungsentwicklung“). Sprich, es behauptet, man könne schnell Anwendungen entwickeln. Verwirklicht wird dies durch:

• IDE: Die integrierte Entwicklungsumgebung („Integrated Development Environment“) bietet Design, Coding, Compiler und Debugging in einer Oberfläche
• Automatisierung: per Knopfdruck (bei Delphi „F9“) wird das Projekt geprüft, kompiliert, gelinkt und dann ausgeführt. Das geschieht meist innerhalb von wenigen Sekunden, man kann also eine kleine Änderung vornehmen und sofort sehen, wie sich diese im Programm auswirkt.

Nun mag vielleicht die Frage aufkommen „Was gibt es denn dann noch außer RAD?“. Antwort: Es gibt zum Beispiel Kommandozeilen-Compiler, bei denen der Vorgang so abläuft:

• Code komplett in eine Textdatei schreiben
• Compiler mit der Datei ausführen
• Wenn ein Compiler-Fehler auftritt, zurück zum Anfang und korrigieren, dann kommt der nächste, denn der Compiler spuckt immer nur einen Fehler auf einmal aus
• Dann die Objektfiles linken - bei Linkerfehler das selbe Spiel wie beim Kompilieren
• Und dann endlich sollte ein ausführbares Programm rauskommen, bei dem man dann überprüfen kann, ob man alles richtig programmiert hat. Wenn das nicht der Fall ist, zurück zum Anfang.

Der Vorteil eines solchen Systems: Man gewöhnt sich bald an, sehr, sehr sauber zu programmieren - Die Einsteigerfreundlichkeit ist aber gleich Null.

Die Antwort lautet also:

• Mit einer RAD-Umgebung kann man schnell und flexibel programmieren.
• Eine RAD-Umgebung ist anfängerfreundlich.
• Eine RAD-Umgebung ist kompakt und in sich stimmig.

[Bearbeiten] Der Debugger

Der Debugger (von engl. bug: Wanze; wörtlich: Entwanzer) ist ein nützliches Tool, das einem die Arbeit erleichtert, einen Fehler zu finden. Es gibt für fast jede Programmiersprache einen Debugger, wir sind hier nicht auf die RAD-Umgebung angewiesen! Für den C-Compiler GCC gibt es beispielsweise einen dazugehörigen Debugger. Jedoch wird er per Kommandozeile bedient und ist nicht nur deshalb nicht so bequem wie der Delphi-Debugger.

[Bearbeiten] Die Aufgabe des Debuggers

Der Debugger hat - wie schon oben erwähnt - die Aufgabe, einem Programmierer beim Finden eines Fehlers zu helfen. Man kann damit beispielsweise prüfen, ob man eine Bedingung richtig formuliert hat oder welchen Wert eine Variable hat. Diese Sachen sind das Einzige, was der Debugger bietet. Auch wenn es nach wenig klingt: Allein das kann oftmals sehr nützlich sein!

[Bearbeiten] Setzen eines Haltepunkts

Gesetzter Haltepunkt

Ein Haltepunkt - manchmal auch Breakpoint genannt - ist eine Zeile im Code, die überprüft wird. Genauer: Das Programm wird an dieser Stelle abgebrochen. Man erhält Informationen über alle Variablen und ihren Wert, den sie zum Zeitpunkt des Abbruchs hatten.

Um einen Haltepunkt zu setzen, muss man mit der linken Maustaste auf den Rand neben der gewünschten Codezeile klicken. Auf dieselbe Weise lässt er sich wieder entfernen.

Danach wird das Programm kompiliert und ausgeführt (F9). Sie sehen, nachdem das Programm abgebrochen wurde, wie der Punkt abgehakt wird (wer genau hinsieht, der wird erkennen, dass dies schon beim Kompilieren passiert). Sie landen im Editorfenster. Sie erkennen so, ob eine Codezeile ausgeführt wird oder nicht. Und damit auch, ob Sie eine Bedingung richtig formuliert haben.

Wenn Sie nun den Cursor über eine Variable oder über die Eigenschaft eines Objekts (z. B. auch Edit1.Text), bekommen Sie als Hint den Wert der Variablen mitgeteilt. Somit können Sie auch feststellen, ob Ihre Befehle richtig formuliert wurden.

[Bearbeiten] Erstellung einer grafischen Oberfläche

[Bearbeiten] Grundsätze

Eine grafische Oberfläche wird durch Drag&Drop erstellt: In der Komponentenpalette wählt man die Komponente durch einen einfachen Klick aus und bewegt dann die Maus an die Stelle, wo die linke obere Ecke der Komponente sein soll. Dann zieht man mit der Maus nach rechts unten, bis die gewünschte Position erreicht ist. Wenn man nur auf das Formular klickt, wird die Komponente in einer Standardgröße, die veränderlich ist, erstellt.

Anschließend kann man im Objektinspektor die Eigenschaften der Komponente ändern, wie z.B. die Aufschrift (Caption), den Inhalt (Text, Lines oder Items), Schriftart, -größe, -farbe etc. (Font) und komponentenspezifische Eigenschaften ändern.

Um ein Ereignis zu programmieren, das bei einer bestimmten Aktion geschehen soll, wählt man im Objektinspektor die Registerseite "Ereignisse" und wählt das entsprechende Ereignis durch Doppelklick auf das leere Feld hinter dem Namen der Methode aus (OnClick für einen Klick, OnDblClick für einen Doppelklick, OnMouseDown für ein Runterdrücken einer Maustaste, OnMouseMove für ein Drüberfahren mit der Maus, OnKeyDown für das Drücken eines Keys, ...). Im Code-Editor kann man allerdings auch jede Eigenschaft ohne Objektinspektor regeln. Dabei wird das Ereignis OnCreate des Formulars gewählt (wird durch Doppelklick auf das Formular erstellt):

procedure TForm1.FormCreate(Sender: TObject);
begin
  Button1.Font.Name := 'Courier New';
end;

Sagt, dass Button1 die Schriftart "Courier New" verwenden soll. Ungewohnt: Zwischen Formular und Unit wird mit F12 gewechselt. Der erstellte Quellcode ist ebenfalls ungewohnt (Delphi 7 Personal):

unit Unit1;

interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs;

type
  TForm1 = class(TForm)
  private
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

end.

Kompiliert wird das Ganze wie in der Konsole mit F9 oder Start / Start.

Spezielle Komponenten haben spezielle Eigenschaften / Ereignisse. Ein Timer hat zum Beispiel die Eigenschaften Intervall - der Abstand in Millisekunden, indem das Ereignis OnTimer ausgelöst wird.

[Bearbeiten] Weitergabe

Einem Formular steht genau eine Unit zu. Beim Abspeichern des Projekts durch Datei / Alles speichern ... gelten folgende Regeln:

• Die Projektdatei fasst alle Formulare / Units zusammen. In ihr kann auch der Programmablauf verändert werden, beispielsweise wenn ein Info-Fenster am Anfang erstellt werden soll. Sie hat die Dateiendung ".dpr" (Delphi Project).
• Die einzelnen Units bekommen die Dateiendung ".pas" für Pascal. Sie beinhalten entweder den Code einer Komponente, den eines Formulars oder Funktionen. Keine Unit darf denselben Namen wie die Projektdatei haben.
• Die Formulare bekommen in Delphi (wie im C++ Builder) die Endung ".dfm" für Delphi Formular. Sie haben denselben Namen wie die dazugehörige Unit, bloß eine andere Endung. Delphi- und C++ Builder-Formulare sind zueinander kompatibel.

Bei allen Dateinamen sind Leerzeichen oder Zahlen am Anfang verboten, auch wenn das Windows theoretisch zulassen würde. Weiterhin werden folgende Dateien beim Kompilieren erzeugt:

• Die Anwendung bekommt denselben Namen wie das Projekt, bloß mit der Endung ".exe" für Executable. Sie ist das fertige Programm und ist (neben eventuellen Ressourcen oder Datenbanken, Grafiken, ...) die einzige Datei, die zur Ausführung relevant ist. Demnach muss man auch nur sie für eine Weitergabe als Nicht-OpenSource / Freeware mit Source weitergeben.
• Alle Units werden kompiliert. Die kompilierte Unit ist binär und bekommt die Endung ".dcu" für Delphi compiled Unit. Eine DCU-Datei ist nur mit der Delphi-Version, mit der sie erstellt wurde, kompatibel. Höhere Delphi-Versionen bieten es einem an, eine DCU-Datei eines älteren Formats zu konvertieren. Andersherum ist das logischerweise nicht möglich.
• Eine Ressourcendatei (*.res) wird ebenfalls erstellt. Diese ist jedoch nicht wichtig, man bekommt zwar eine Fehlermeldung, wenn die Ressourcendatei fehlt. Diese kann aber ignoriert werden.
• Eine Outlook-Konfigurationsdatei wird auch erstellt.

Für OpenSource-Projekte müssen folgende Dateien mitgeliefert werden:

• Die Projektdatei (.dpr)
• Die Units (.pas)
• Die Formulare (.dfm)

[Bearbeiten] Mehrere Formulare erstellen

Mehrere Formulare können erstellt werden, um z.B. einen Dialog oder ein Info-Fenster zu integrieren. Dies kann über Datei / Neues Formular geschehen.

Beim Aufruf eines Formulars gibt es zwei Möglichkeiten. Nachdem die Unit des Formulars (z. B. Unit1 für Form1) in die Uses-Klausel aufgenommen wurden, kann man das Formular aufrufen:

• Form2.Show;
• Form2.ShowModal;

Show ist ein einfaches Aufrufen. Wenn man einen Dialog hat, kann man Buttons unterbringen und denen einen anderen ModalResult-Wert zuweisen (mrOk für OK, mrCancel für Abbrechen, ...). Nun ist Show eine Prozedur und ShowModal eine Funktion. ShowModal gibt den gedrückten Button (bzw. dessen ModalResult) zurück. z. B. kann man feststellen, ob wirklich auf OK gedrückt wurde:

if Form2.ShowModal = mrOk then          // User hat OK geklickt
  ShowMessage('Sie haben OK geklickt'); // User benachrichtigen

Bei mehreren Abfragen wird ein anderes Konzept verwendet:

var
  a: Integer;
begin
  a := Form2.ShowModal;                                // Form2 aufrufen und den ModalResult der Variablen a zuweisen
  case a of                                            // case-of ...
    mrOk: ShowMessage('Sie haben OK geklickt');        // OK wurde geklickt
    mrCancel: ShowMessage('Aktion wurde abgebrochen.');// Cancel wurde geklickt
  end;                                                 // case-of beenden

Wichtig zu wissen ist, dass mrOk bloß eine Integer-Konstante ist. Sie kann demnach auch mit einer Zahl angesprochen werden:

Quelle: Delphi 2006-Hilfe

[Bearbeiten] Komponenten dynamisch erstellen

Objekte / Komponenten können dynamisch erstellt werden. Dazu sind ein Teil von Eigenschaften wichtig, um sie sichtbar zu machen. Hier beschreiben wir kurz mit Beispielcode, wie man ein Image (nächster Abschnitt) dynamisch erstellt:

var
  myimage: TImage;
begin
  try
    myimage          := TImage.Create(Self);
    myimage.Parent   := Form1;
    myimage.Left     := 100;
    myimage.Top      := 100;
    myimage.AutoSize := true;
    myimage.Picture.LoadFromFile(ExtractFilePath(Application.ExeName) + 'bild.bmp');
    myimage.Visible  := true;
    myimage.Name     := 'DynamicImage';
  finally
    myimage.Free;    // Hier wird die Komponente sofort wieder gelöscht.
  end;               // Sie sollten dies eventuell im OnClose -Ereignis des Forms machen.
end;

Um das myimage.Free in den OnClose-Teil des Forms zu verlagern, muss myimage global vereinbart werden!

[Bearbeiten] Fortgeschrittene Themen

[Bearbeiten] Grafiken

Für Grafiken gibt es die Komponente TImage. Man findet sie in dem Register „Zusätzlich“. Doppelklickt man auf es bzw. wählt man die Eigenschaft „Picture“ und klickt auf die drei Punkte daneben, öffnet sich der Bild-Editor. In ihm wird per „Laden ...“ die Grafik in einem Dialog geladen, die erscheinen soll.

An Eigenschaften bietet das Image noch Stretch. Bei Stretch = true bedeutet dies, dass das Bild auf die Größe der TImage-Komponente gezerrt werden soll, ansonsten behält es seine Originalgröße, unabhängig von der Größe des Images.

Wenn Proportional = true gestellt ist (neuere Delphi-Versionen), heißt das, dass das Image so gezerrt wird, dass das Verhältnis von Höhe und Breite trotzdem noch denen des Originals entspricht.

Bei AutoSize = true erhält das Image automatisch die Größe des Originalbildes. Somit werden Stretch und Proportional ignoriert und die Breite und Höhe verändert.

Die Eigenschaften Left und Top geben (auch bei anderen Komponenten) die linke obere Position an. Für Spiele kann man diese verändern. Bei Spielen sollte man allerdings die Eigenschaft DoubleBuffered des Formulars auf true stellen (geht nur im Code-Editor im OnCreate-Ereignis):

procedure TForm1.FormCreate(Sender: TObject);
begin
  Form1.DoubleBuffered := true;
end;

Es wird jedoch im allgemeinen davon abgeraten eine TImagekomponente als Zeichenfläche (für Spiele oder ähnliches) zu missbrauchen. Für dynamische Grafiken (also bei Grafiken die sich öfters ändern, wie bei Spielen) sollte man die TPaintbox-Komponente verwenden. Diese eignet sich auch nur bedingt für Spiele, alles was über ein einfache Dinge wie Tetris hinausreicht, sollte man eher OpenGL verwenden. Dafür gibt es auch einige 2D-Engines die von der Delphi-Community entwickelt wurden. Im deutschsprachigem Raum werden vor allem Fear2D und Andorra 2D. Für 3D-Spieleprogammierung ist die DGL-Community besonders zu empfehlen, da diese sehr gute Tutorials zu 3D-Programmierung verfasst hat.

[Bearbeiten] Menüs

[Bearbeiten] Hauptmenüs

Professionelle Anwendungen haben meist ein Hauptmenü. Dazu wird die Komponente TMainMenu benötigt. Man findet sie in der Komponentenpalette unter Standard. Setzt man sie auf das Formular, so sieht man rein gar nichts. Außer eine nicht-visuelle Komponente (eine Komponente, die zwar im Erstellungsmodus gekennzeichnet wird, zur Laufzeit jedoch nicht sichtbar ist). Nun klickt man doppelt auf das TMainMenu. Der Menü-Editor öffnet sich. Dort gibt man einem Platzhalter einen Caption. Über Enter bestätigt man die Eingabe. Ein neuer Platzhalter wird erstellt. In erster Ebene sieht man nur Menüpunkte wie „Datei“, „Bearbeiten“, ... Diese können Untermenüs enthalten wie z.B. Datei / Neu, Datei / Öffnen. Selektiert man einen Menüpunkt, sieht man darunter einen Platzhalter. Ihm kann genauso ein Caption zugewiesen werden, z.B. "Neues Dokument". Per Enter wird bestätigt und ein neues Item wird erstellt, z.B. „Öffnen“. Das geht endlos weiter. Wenn der Caption „-“ ist, wird er als Trennlinie interpretiert. Einem Buchstaben kann ein „&“ vorangestellt werden, um das Item per Alternativtaste (Alt) aufzurufen. Weiterhin hat jedes Item die Eigenschaft Shortcut. Dort kann ein Tastenkürzel wie z.B. „Strg+S“, „Strg+Alt+V“, „F1“ oder „Strg+Leer“ eingestellt werden. Per Klick wird genauso wie über Betätigung des Shortcuts das OnClick-Ereignis ausgelöst, das wie oben beschrieben definiert werden kann.

Weiterhin kann jedes Item Untermenüs erhalten. Diese können per Kontextmenü / Untermenü erstellen erstellt werden und wieder Untermenüs erhalten.

[Bearbeiten] Kontextmenüs

Für ein Kontextmenü wird die Komponente TPopupMenu verwendet. Sie befindet sich unter Standard neben TMainMenu. Die Vorgehensweise ist dieselbe wie beim MainMenu. Der Komponente, die per Rechtsklick das Kontextmenü aufruft (es können auch mehrere sein), wird bei der Eigenschaft „PopupMenu“ (wenn vorhanden, in neueren Delphi-Versionen rot gekennzeichnet) die PopupMenu-Komponente zugewiesen (in der Liste ausgewählt).

[Bearbeiten] Ribbon Bar

In den neueren Delphi-Versionen (ab Delphi 2009) gibt es weiters die Ribbon Bar-Komponente, um den Programmen ein ähnliches Aussehen wie den neueren Microsoft Office-Anwendungen zu verpassen. Will man diese Komponenten jedoch benutzen muss man bei Microsoft eine kostenlose Lizenz beantragen und bestimmte Design-Richtlinien beachten. Gedacht ist diese Komponente als einfache und schnelle Alternative zu den Menüs.

[Bearbeiten] Toolbars

Toolbars bzw. Werkzeugleisten sind ebenfalls in professionellen Anwendungen oft anzutreffen. Man verwendet dazu die Windows-Komponente TToolbar im Register „Win32“. Weiterhin wird eine ImageList benötigt (ebenfalls im Register Win32). Auf diese wird nun doppelt geklickt. Im ImageList-Editor werden per Hinzufügen die benötigten Glyphs (Bitmaps in den Formaten 16x16, 24x24, 32x32, ...) zugewiesen. Diese können per Drag&Drop verschoben werden.

Nun wird der Toolbar-Komponente unter der Eigenschaft „Images“ (rot hervorgehoben) die ImageList zugewiesen. Per Rechtsklick auf die Toolbar kann im Kontextmenü „Neuer Schalter“ oder „Neuer Trenner“ gewählt werden. Bei Schaltern (TToolButton) gibt es die Eigenschaft ImageIndex, die den Index des Glyphs innerhalb der ImageList bestimmt. Erwartet wird eine Ganzzahl. -1 bedeutet: Kein Glyph. Die Nummerierung beginnt bei 0.

Soll der Schalter ein Checker sein, also angeben, ob ein Zustand 1 (true) oder 0 (false) hat, z.B. ob eine andere Toolbar sichtbar ist, wird ihr bei der Eigenschaft „Style“ der Wert „tbsCheck“ zugewiesen. Bei der Eigenschaft Down findet man den Wert False, wenn er nicht gedrückt ist, und True, wenn nicht. Wichtig dazu ist noch der Name des Buttons, den man unter der Eigenschaft „Name“ findet bzw. verändern kann.

Soll der Schalter ein Menü sein, also eine Liste enthalten, die bei Klick „aufpoppt“, stellt man den Wert der Eigenschaft „Style“ auf tbsDropDown. Der Eigenschaft „DropDownMenu“ wird ein PopupMenu zugewiesen, das sich bei einem Klick mit der linken Maustaste auf den Pfeil neben dem Button öffnet.

[Bearbeiten] Statuszeilen

Eine Statuszeile enthält wertvolle Informationen für den Benutzer. Sie befindet sich (meist) im unteren Teil des Formulars. Im einfachsten Fall zeigt sich eine Beschreibung zu einer Schaltfläche an. Diese Beschreibung wird angezeigt, sobald der Benutzer mit der Maus über die Komponente fährt. Ebenfalls wird ein gelber Hinweis angezeigt.

Um den gelben Hinweis (QuickInfo oder Hint genannt) zu definieren, muss die Eigenschaft „ShowHint“ der jeweiligen Komponente auf True gestellt werden. Die Eigenschaft „Hint“ enthält den Text, der angezeigt wird.

Um eine Statuszeile zu erstellen, zieht man eine TStatusbar (Register Win32) auf das Formular. Die Eigenschaft „AutoHint“ wird ebenso wie die Eigenschaft „SimplePanel“ auf True gestellt. Damit erscheinen nun in der Statuszeile die Hints, die bei der Eigenschaft „Hint“ der Komponente unter der Verwendung von AutoHint = true definiert wurde.

[Bearbeiten] Vorlagen

Für grafische Benutzeroberflächen (GUIs) gibt es drei wesentliche Vorlagen:

• VCL-Formularanwendung: Leeres Formular, wird (bei älteren Delphi-Versionen) standardmäßig erstellt
• MDI-Anwendung: Multiple Document Interface. Eine Basis, die es möglich macht, mehrere Dokumente zur gleichen Zeit zu verwalten. Beispiel: Photoshop, Phase5
• SDI-Anwendung: Single Document Interface. Eine Basis, die grundsätzlich nur ein Dokument offen unterstützt. Dennoch ist es auch mit SDI möglich, mehrere Dokumente zu verwalten, wenn man die Komponenten dynamisch zur Laufzeit erzeugt.

Alle Vorlagen lassen sich über Datei / Neu / Weitere ... verwenden.

[Bearbeiten] MDI-Anwendungen

Eine MDI-Anwendung besteht aus einem Hauptformular (Parent) und mehreren MDI-Kindfenstern (MDI-Children). Im Parent sind Werkzeugleisten (TToolbar oder Zusätze wie Toolbar2000 von Jordan Russell oder TAdvToolbar von TMS Software) und ein Menü (TMainMenu oder gerade genannte Zusätze) untergebracht.

Alle Child-Fenster werden dynamisch erzeugt. In ihnen befindet sich nur der Editor. Die Fenster erhalten im Menü ihre Schaltflächen für Verkleinern, Maximieren und Schließen. Im Maximierten Zustand bekommt das Hauptfenster ein Caption der Form Titel - [Dateiname] in der Annahme, dass die Children wie standardmäßig den Dateinamen der geöffneten Datei oder „Unbenannt n“ als Caption erhalten.

Zu beachten ist, das man beim Schließen des Childfensters das Formular mittels Action := caFree; aus dem Speicher frei gibt.

Tipp: Zum Verwalten der Childfenster bietet sich das dynamisches Array an, welches das Parentfenster automatisch erzeugt. Man kann dann mittels MDIChildren[i] (wobei i den Index des MDI-Childfensters angibt) auf die einzelnen Fenster zugreifen.

[Bearbeiten] SDI-Anwendungen

SDI-Anwendungen unterscheiden sich nicht von einer VCL-Formularanwendung, lediglich die automatisch von der IDE erzeugten Komponenten sind unterschiedlich.

[Bearbeiten] Dialoge

Dialoge sind ebenfalls wichtig. Z.B. der SaveDialog, der OpenDialog, der PrintDialog, der PrinterSetupDialog, der FontDialog oder der ColorDialog. Sie befinden sich im Register Dialoge. Alle diese Dialoge lassen sich mit der Prozedur Execute aufrufen:

OpenDialog1.Execute;

Bei Execute handelt es sich um eine Funktion handelt, die einen Wahrheitswert, also True oder False, zurückgibt. Diesen sollte man auswerten, da True bedeutet, dass der Benutzer auf OK geklickt hat, während er bei False die Dialog mit Abbrechen verlassen hat.

Wie nun die Daten in den einzelnen Dialogen ausgewertet werden, würde hier zu weit führen. Bitte ziehen Sie hierfür Ihre Delphi-Hilfe zurate.

Weiters gibt es noch Dialoge mit denen man Benutzerabfragen gestalten kann. Diese sind in der selben Unit wie die Öffungs- und Speicherndialoge enthalten.

Mit dem Befehl MessageDlg erzeugt man Dialoge, die zum Beispiel abfragen können ob man das Programm wirklich beenden will. Der Befehl MessageDlg braucht in Klammern folgende Parameter mit: der Text der in der Box angezeigt werden soll; die Art des Dialoges (mtNone, mtInformation, mtConfirmation, mtCustom, mt Error); die Buttons die zur Verfügung stehen sollen (da kann man entweder eine vorgefertigte Mischung nehmen, oder mittels Array selbst die Buttons bestimmen); den Hilfeindex. MessageDlg gibt auch einen Wert zurück mit dem man prüfen kann welchen Button der Benutzer gedrückt hat. Diese können mrYes, mrNo und so weiter sein, für genaueres bitte die Delphi-Hilfe konsultieren.

ein Beispielaufruf könnte jetzt dann so aussehen:

procedure TForm1.Button1Click(Sender: TObject);
begin
  if MessageDlg('Wollen sie beenden?', mtConfirmation, [mbYes, mbNo], 0)=mrYes then
     Close;
end;

Außerdem gibt es dann noch die sogenannte InputBox. Mit Hilfe dieser kann man Eingaben vom Benutzer einfordern, auch Zahlen und Gleitkommawerte. Für nähere Informationen steht ihnen die Delphi-Hilfe zur Verfügung.

[Bearbeiten] Formatierter Text

Wikipedia hat einen Artikel zum Thema:

Rich Text Format

Als erste GUI-Anwendung eignet sich ein Texteditor für das Rich Text Format (RTF). Mit ihm ist es möglich, Formatierungen bis hin zu Bildern darzustellen. Auch wenn die Komponente RichEdit (Register Win32) nur formatierten Text ohne Bilder unterstützt, ist es doch eine interessante Komponente, die man kennen sollte.

Man zieht sie auf das Formular.

[Bearbeiten] Öffnen und Speichern

Als erstes zum Laden und Speichern von Dateien - wir brauchen LoadFromFile und SaveToFile. In Klammern wird ihnen als Parameter der Dateiname übergeben. Hat man die Funktion der Dialoge verstanden, lässt sich das erweitern:

procedure TFormEditor.ladeDatei(Sender: TObject);
begin
  try
    if OpenDialog1.Execute then
      editor.Lines.LoadFromFile(OpenDialog1.FileName);                           {{{1}}}
  except
    ShowMessage('Fehler beim Öffnen einer Datei');
  end;
end;

Ähnlich ist es beim Speichern:

procedure TFormEditor.speicherDatei(Sender: TObject);
begin
  try
    if SaveDialog1.Execute then
      editor.Lines.SaveToFile(SaveDialog1.FileName);                           {{{1}}}
  except
    ShowMessage('Fehler beim Speichern einer Datei');
  end;
end;

[Bearbeiten] Formatierung

[Bearbeiten] Schriftfarbe

Der ColorDialog wird aufgerufen und die Schriftfarbe des gewählten Bereichs im RichEdit wird verändert. Das Ganze funktioniert folgendermaßen:

procedure TForm1.Button3Click(Sender: TObject);
begin
  if ColorDialog1.Execute then                        // ColorDialog aufrufen
    RichEdit1.SelAttributes.Color :=                  // Farbe des gewählten Bereichs
    ColorDialog1.Color;                               // gewählte Farbe im ColorDialog
end;

[Bearbeiten] Kompletter Font

Für den kompletten Font sieht es so aus:

procedure TForm1.Button4Click(Sender: TObject);
begin
  if FontDialog1.Execute then                         // FontDialog aufrufen
  begin
    RichEdit1.SelAttributes.Color :=                  // Farbe des gewählten Bereichs
      FontDialog1.Font.Color;                         // gewählte Schriftfarbe
    RichEdit1.SelAttributes.Name :=                   // Schriftart des gewählten Bereichs
      FontDialog1.Font.Name;                          // gewählte Schriftart
    RichEdit1.SelAttributes.Size :=                   // Schriftgröße des gewählten Bereichs
      FontDialog1.Font.Size;                          // gewählte Schriftgröße
    RichEdit1.SelAttributes.Style :=                  // Style des gewählten Bereichs (fett, kursiv, unterstrichen)
      FontDialog1.Font.Style;                         // gewählter Schriftstyle
  end;
end;

Style kann folgende Werte haben: [fsBold] für Fett. [fsItalic] für kursiv. [fsUnderline] für unterstrichen. [fsStrikeOut] für durchgestrichen. Möchte man einem Style einen Style hinzufügen oder entnehmen, geht das folgendermaßen:

RichEdit1.Font.Style := [fsBold];                          // Fett stellen

RichEdit1.Font.Style := RichEdit1.Font.Style + [fsItalic]; // Kursiv hinzufügen, Ergebnis: fett, kursiv

RichEdit1.Font.Style := RichEdit1.Font.Style - [fsBold];   // Bold wegnehmen, Ergebnis: kursiv

Möchte man mehrere Styles listen, gelingt das mit [fsBold, fsItalic] für fett + kursiv. Soll es wieder Standard sein, ist es [].

[Bearbeiten] Weitere Themen

[Bearbeiten] Drucken

Möchte man irgendetwas Drucken, benutzt man das Printer-Objekt. Dazu muss man die Unit Printers in die Uses-Klausel aufnehmen. Beim Drucken kann man mit der Canvas-Eigenschaft des Druckers arbeiten (dazu muss man beachten, dass zwar FontSize der Größe des Bildschirm entspricht, alle anderen Koordinaten sich jedoch auf Druckerpunkte beziehen, die sind wesentlich kleiner als die Pixel des Bildschirms):

Printer.BeginDoc;                                      // Druckauftrag starten
Printer.Canvas.Assign(Image1.Canvas);                  // Canvas des Image1 übernehmen
Printer.EndDoc;                                        // Druckauftrag fertig, Ausdruck beginnen

Damit wird das Bild von Image1 gedruckt.

Möchte man seinen Druck auf verschiedene Druckerauflösungen anpassen, gibt es einen einfachen Weg:

pfactor := Printer.PageWidth / 2400;

Somit multipliziert man dann alle Koordinaten mit pfactor. Funktionsweise: 2400 ist die Breite einer DIN A4 - Seite bei 300 dpi (dots per inch). Es wird hier ermittelt, wie viel mal die Seitenbreite größer als die von 300 dpi / DIN A4. Bei einer Breite von 4800 (600 dpi / DIN A4) wird pfactor 2 sein. So hat das Ergebnis zwar eine andere Auflösung, die Elemente befinden sich aber an derselben Stelle. Möchte man nun das Image drucken, so geschieht das so:

var
  Bereich: TRect;
begin
  Printer.BeginDoc;                                      // Druckauftrag starten
  pfactor := Printer.PageWidth / 2400;
  Bereich.Top := round(10 * pfactor);
  Bereich.Bottom := round((10 + Image1.Height) * pfactor);
  Bereich.Left := round(10 * pfactor);
  Bereich.Right := round((10 + Image1.Width) * pfactor);
  Printer.Canvas.StretchDraw(Bereich, Image1.Canvas);
  Printer.EndDoc;                                        // Druckauftrag fertig, Ausdruck beginnen

Alternativ zu round (runden) kann auch trunc (Dezimalstellen abschneiden) benutzt werden.

Ein zweiter Weg wäre es, den Formularinhalt zu drucken:

Form1.Print;

[Bearbeiten] Tabellen

Und auch wichtig sind StringGrids. TStringGrid findet man im Register Zusätzlich. Dann zieht man die StringGrid-Komponente auf das Formular. Mit der Eigenschaft FixedRows wird die Anzahl der grauen Reihen festgelegt. Dasselbe tut FixedCols für die grauen Spalten (Col = Column = Spalte). RowCount legt die Anzahl der Zeilen fest, ColCount die Anzahl der Spalten. Die wirklich wichtige Eigenschaft ist Cells. Möchte man der Zelle A1 (0; 0) den Inhalt "A1" zuweisen, so geschieht das folgendermaßen:

StringGrid1.Cells[0, 0] := 'A1';    // StringGrid1.Cells[Spalte, Zeile]

Die Nummerierung beginnt auch hier bei 0 (anders als bei den meisten Dingen unter Delphi), da es sich um eine Windows-Komponente handelt (und bei Windows ziemlich überall die Indizierung bei 0 beginnt), denn das ist Standard bei C.

[Bearbeiten] Aufteilung des Formulars

[Bearbeiten] Panels

Panels sind sogenannte Container, vergleichbar mit dem DIV-Tag in HTML. Sie finden das Panel in der Registerkarte "Standard". Zieht es auf euer Formular. Soll es die ganze linke Seite einnehmen, oben, unten, rechts oder alles, so müssen Sie Align verändern. Im Objektinspektor wählen Sie eines der Einträge, also:

• alClient: alles einnehmen
• alLeft: Breite wie angegeben, Höhe passt sich dem Formular an, das Panel ist immer ganz links
• alRight: Breite wie angegeben, Höhe passt sich dem Formular an, das Panel ist immer ganz rechts
• alBottom: Höhe wie angegeben, Breite passt sich dem Formular an, das Panel ist immer ganz unten
• alTop: Höhe wie angegeben, Breite passt sich dem Formular an, das Panel ist immer ganz oben
• alNone: Standardeinstellung, Left, Top, Width und Height veränderbar.

Übrigens werden Sie feststellen, dass Sie so auch die Position einer Toolbar oder Statusbar verändern können, die haben nämlich standardmäßig alTop (Toolbar) / alBottom (Statusbar).

Weiterhin kann man noch die Eigenschaft Anchors nutzen, wobei man festlegt, ob die Position der Komponente abhängig vom Abstand nach links, rechts, oben oder unten zum jeweiligen Rand ihres Parents ist.

[Bearbeiten] Splitter

Die TSplitter-Komponente finden Sie im Register "Zusätzlich". Zieht sie auf das Formular. Align ist veränderbar. Wenn sie zum Beispiel Align alTop hat und unter einem Panel, das ebenfalls alTop hat, durch Ziehen die Größe verändern. Das ist sinnvoll, weil jeder User eine andere Vorstellung von einer "guten" Größeneinteilung hat.

[Bearbeiten] Registerkarten

Registerkarten werden mit der Komponente TPageControl, die sich im Register "Win32" befindet, erstellt. Um eine neue Seite zu erstellen, klicken Sie im Kontextmenü eines neuen leeren PageControls auf "Neue Seite". Das geht unendlich oft (theoretisch, da der Speicher begrenzt ist). Dabei fällt auf, dass jede Seite ein einzelnes Objekt ist, nämlich ein TTabSheet. Das heißt, wenn man dem TabSheet1 den Parent PageControl2 zuweist, der vorher PageControl1 war, kann man das PageControl ändern. So kann man Seiten auch dynamisch erstellen (siehe Komponenten dynamisch erstellen).

Weiterhin kann man die Eigenschaft des TabSheets "Caption" für eine andere Aufschrift verändern. TabIndex legt den Rang innerhalb des PageControls fest. Visible stellen Sie auf false, wenn das Item nicht sichtbar sein soll, Visible des PageControls für eine veränderte Sichtbarkeit des PageControls, siehe auch die Methoden Hide und Show.

Mit der Eigenschaft des PageControls "HotTrack" legen Sie fest, ob das Item, über dem sich die Maus befindet, mit einer dunkelblauen Schrift (clNavy) erscheinen soll. Die Eigenschaft MultiLine legt fest, ob die Tabs über mehrere Zeilen verteilt werden sollen oder ob sich am Rand zwei Buttons zum Navigieren nach links und rechts befinden sollen. Style gibt das Layout für die Komponente an.

Mit Align (beim Panel behandelt) kann man, wie bei fast allen Komponenten, die Ausrichtung festlegen.

[Bearbeiten] Trackbar und Scrollbar

Beide Komponenten sind eine Art "Slider", um bestimmte Werte einzustellen. Sie funktionieren ziemlich gleich: Es gibt Eigenschaften für Maximal- und Minimalwerte, nämlich Max und Min. Weiterhin gibt es das Ereignis OnChange. Diese tritt dann auf, wenn etwas bewegt wurde. Mit Orientation wird die Richtung, also horizontal oder vertikal festgelegt.

Bei der Trackbar kann man bei Frequency einstellen, in welchem Abstand Markierungs-Striche gezogen werden sollen. Und es ist möglich, einen Teil zu markieren, dafür werden wie im RichEdit die Eigenschaften SelStart und SelEnd verwendet, die allerdings als Public, nicht als Published deklariert sind und so nicht im Objektinspektor auffindbar sind.

TTrackbar ist unter "Win32", TScrollbar unter "Standard" aufzufinden.

[Bearbeiten] GroupBox, RadioGroup und Checkbox

Diese drei Komponenten sind unter "Standard" aufzufinden.

• Die GroupBox ist eine Art Panel mit anderem Aussehen
• Die RadioGroup ist eine GroupBox mit mehreren Optionsfeldern, von denen genau eins gewählt werden kann
• Die Checkbox ist ein Feld für das angeben eines Zustands, also True oder False, welcher mit der Eigenschaft Checked festgelegt wird, auch bekannt als Kontrollfeld oder Check

Die Groupbox verfügt lediglich über die Eigenschaft Caption, die den Titel angibt, ansonsten funktioniert sie wie ein Panel und dient nur der Optik.

Die RadioGroup hat die gleichen Eigenschaften wie die Groupbox. Zusätzlich verfügt sie über "Items" für die Liste der Optionen als TStringList und ItemIndex (Indizierung beginnt bei 0), die die gewählte Option angibt.

Die Checkbox hat zwei wichtige Eigenschaften: Checked für den Zustand und Caption für die Beschriftung.

[Bearbeiten] Fortschritt anzeigen

Ein Fortschritt wird mit der TProgressBar angezeigt, welche sich im Register Win32 befindet. Mit Max und Min werden obere und untere Grenze festgelegt. Mit Position wird der Fortschritt angezeigt.

Alternativ zur Progressbar kann auch die TGauge genutzt werden. Sie befindet sich im Register "Beispiele" (Samples). Mit MinValue und MaxValue werden die Grenzen angegeben. ForeColor und BackColor treffen Aussagen über die Farbwahl. Mit Font kann die Schriftart verändert werden. Die Eigenschaft Progress gibt den Fortschritt an.

[Bearbeiten] Anwendungsoptionen

Um der Anwendung einen Titel zu verpassen, der auch dann in der Taskleiste erscheint, sowie ein Icon (was man unter anderem mit kostenlosen Tools wie dem Borland Bildeditor, LiquidIcon oder IcoFX erstellen kann), müssen Sie Projekt / Optionen / Anwendung wählen. In den drei Editierfeldern geben Sie einfach die dazugehörigen Werte ein und klicken dann auf OK.

[Bearbeiten] WinXP-Themes

Für Delphi ab Version 7: Hier finden Sie im Register "Win32" die Komponente TXPManifest. Diese ist eine nicht-visuelle Komponente und bindet nur die Unit XPMan ein. Für ein Löschen der Komponente muss also auch die Unit aus der Uses-Klausel entfernt werden.

Für ältere Versionen vor Delphi 7: Sie müssen die Manifest- und Resourcen-Dateien etwas komplizierter selbst erstellen. Zunächst legen Sie eine Datei "WindowsXP.manifest" mit folgendem Inhalt an:

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">
  <assemblyIdentity
    type="win32"
    name="DelphiApplication"
    version="1.0.0.0"
    processorArchitecture="*"/>
  <dependency>
    <dependentAssembly>
      <assemblyIdentity
        type="win32"
        name="Microsoft.Windows.Common-Controls"
        version="6.0.0.0"
        publicKeyToken="6595b64144ccf1df"
        language="*"
        processorArchitecture="*"/>
    </dependentAssembly>
  </dependency>
</assembly>

Die Attribute name und version können entsprechend angepasst werden. Den Rest bitte unverändert lassen.

Anschließend benötigen Sie eine Resourcen-Datei. Legen Sie dazu eine weitere Textdatei namens "WindowsXP.rc" an und tragen Sie dort folgende Zeile ein:

1 24 WindowsXP.manifest

Nun an der Eingabeaufforderung eingeben:

brcc32 WindowsXP.rc

Gegebenenfalls müssen Sie noch den Pfad zum Borland-Programmverzeichnis davor schreiben bzw. den entsprechenden Pfad vor die .rc-Datei.

Dies erstellt eine Resourcendatei namens WindowsXP.res im gleichen Verzeichnis. Damit Ihr Programm nun die Windows XP-Stile annimmt, öffnen Sie den Quelltext Ihres Hauptformulars und tragen im 'implementation-Abschnitt, nach {$R *.dfm} folgendes ein:

{$R 'WindowsXP.res'}

Hiermit wird automatisch von Delphi eine Resourcendatei erzeugt und in Ihr Programm eingebunden. Nach dem nächsten Kompilieren verwendet Ihr Programm die XP-Themes.

[Bearbeiten] Arbeit mit Tasten

Tasten können auch simuliert und abgefangen werden, als negatives Beispiel für ein Backdoor oder einen Keylogger. Allerdings kann man das auch nützlich gebrauchen. Auch, wenn man fast alles davon eleganter lösen könnte.

[Bearbeiten] Simulation

Ein Screenshot wird mit der Taste DRUCK erstellt. Man kann diesen auch per Windows-API erzeugen, allerdings können wir mit zwei Codezeilen solch einen Tastendruck simulieren:

Keybd_Event(VK_PRINT, 0, 0, 0);
Keybd_Event(VK_PRINT, 0, KEYEVENTF_KEYUP, 0);

Das sollte übrigens nicht nur unter Delphi funktionieren, sondern in allen Programmiersprachen, die einen Zugriff auf die Windows-API erlauben. Übrigens sollten Sie die zweite Zeile nie vergessen, denn diese sorgt dafür, dass die Taste auch wieder losgelassen wird. Sonst bleibt Sie ewig unten! Übrigens: Ein alphanumerischer Buchstabe, wzb. A kann einfach mit Ord('A') als ID simuliert werden.

[Bearbeiten] Abfrage

Eine Abfrage kann man zum Beispiel für ein Spiel gebrauchen. Man fragt mit einem Timer alle 100 Sekunden ab (Beispiel), ob eine Taste gedrückt ist (auch das geht eleganter, Stichwort Hook: allerdings ist dann die Gefahr groß, dass ein Anti-Viren-Programm eingreift). Dazu benutzen Sie die Funktion(en) GetAsyncKeystate oder GetKeyState:

if GetAsyncKeystate(VK_LEFT) < 0 then
  // Nach links bewegen

Übrigens finden Sie alle Tastencodes in der Delphi-Hilfe unter dem Stichwort Virtuelle Tastencodes.

[Bearbeiten] Fremdkomponenten installieren

Sie können auch Fremdkomponenten installieren. Diese enthalten meistens zwei Arten von Packages:

• Runtime-Packages

• DesignTime-Packages

Beide haben die Dateiendung ".dpk". Man kann sie meistens folgendermaßen unterscheiden:

• Runtime-Packages: Name = [Name]R[Version].dpk

• DesignTime-Packages. Name = [Name]D[Version].dpk

Zunächst muss man den Pfad, wo diese Packages gespeichert sind, Delphi kenntlich machen. Das geschieht (unter Delphi 7) über Tools / Umgebungsoptionen / Bibliothek. Nun fügt man im Editierfeld "Bibliothekspfad" ein Semikolon (;) und den Ordner, in dem die Packages gespeichert sind, an.

Jetzt wird der Dialog geschlossen.

Nun öffnet man zuerst das Runtime-, dann das DesignTime-Package. Ein neues Fenster öffnet sich. Nun klickt man dort bei beiden jeweils auf "Kompilieren", beim DesignTime-Package zusätzlich auf "Installieren". Achtung: Es soll hintereinander geschehen, also erst das Runtime-Package fertig, dann das DesignTime-Package beginnen.

Besteht die Komponente nur aus einer Unit, erstellt man über Datei / Neu / Package ein neues Package. Nun fügt man über das grüne Plus-Symbol die entsprechende Unit hinzu und speichert das Package im selben Ordner ab. Dieses Verzeichnis wird Delphi kenntlich gemacht und wie ein DesignTime-Package anschließend geöffnet, kompiliert und installiert.

Alternativ dazu kann man auch nur den Pfad zur Unit angeben (Tools / Umgebungsoptionen / Bibliothek ...) und anschließend die Komponente über Komponente / Komponente installieren ... im Menü in das Package "dclusr.dpk" aufnehmen. Dort wird die neue Unit gewählt, kompiliert und installiert.

Benötigt man sie nur, um sie dynamisch zu erstellen (was ja sowieso nur geht, wenn man den Turbo Delphi Explorer nutzt), reicht es auch, den Pfad zur Unit anzugeben.

[Bearbeiten] Komponentenentwicklung

[Bearbeiten] Vorfahrtyp

Zunächst einmal sollten Sie sich im Klaren sein, was für einen Vorfahrtypen man wählt. Für graphische Komponenten ist für eine ganz neue Komponente TGraphicControl eine gute Wahl. Sollte es ein erweitertes Edit sein, muss man natürlich TEdit als Vorfahrtyp wählen, es sei denn, man möchte alles neu schreiben.

[Bearbeiten] Neue Komponente

Eine neue Komponente wird über Komponente / Neue Komponente ... erstellt. In diesem Dialog geben wir ein, was Delphi von uns wissen will. Wir wissen nun, welchen Vorfahrtypen wir nehmen, hier TGraphicControl, und nennen unsere neue Klasse zum Beispiel TMyShape. Diese soll am Ende dem TShape ähneln.

[Bearbeiten] Zeichnen

Zum Zeichnen benutzen wir Canvas. Das kann überall gemacht werden. Gut ist es jedoch, es in der Methode Paint zu machen, die TGraphicControl mitbringt. Diese überschreiben wir. Es sieht nun so aus:

TMyShape = class(TGraphicControl)
  private
    { Private-Deklarationen }
  
  protected
    procedure Paint; override; // Hier eintragen
  
  public
    { Public-Deklarationen }
  
  published
    { Published-Deklarationen }
end;

{ ... }

procedure TMyShape.Paint; override;
begin
  { ... }
end;

Da wir uns in TMyShape befinden, müssen wir Canvas nicht mit TMyShape.Canvas ansprechen, sondern dürfen auch Canvas schreiben. Normalerweise schreibt ja auch niemand Form1.Edit1.Text sondern Edit1.Text. Wir stellen uns vor, wir wären in einer with-do-Konstruktion. Wie wir mit Canvas zeichnen, wurde im letzten Kapitel erklärt.

[Bearbeiten] Koordinaten

Bei den Koordinaten darf man auf gar keinen Fall Left und Top für die linke obere Ecke verwenden, sondern 0. Die Koordinaten beziehen sich nicht auf die auf dem Formular, sondern auf die innerhalb der Komponente. Damit kann man überflüssige Unklarheiten vermeiden. Die Breite und Höhe bekommen wir mit Width und Height geliefert.

[Bearbeiten] Ereignisse

Ereignisse müssen wir einfach nur importieren. Wir schreiben also in den Published-Teil:

published
  property OnClick;
  property OnMouseMove;
  ...

Denn alle wichtigen Ereignisse werden von TGraphicControl geliefert.

[Bearbeiten] Properties

Properties sollen meistens im Objektinspektor erscheinen. Dafür wird diese Schreibweise verwendet:

published
  property MyProperty: Datentyp read AMyProperty write FmyProperty;

AMyProperty wird im Private-Teil mit demselben Datentypen deklariert. FMyProperty ist eine Prozedur aus dem Private-Teil und könnte folgendermaßen aussehen:

procedure TMyShape.FMyProperty(A: Datentyp);
begin
  AMyProperty := A;
  Paint;
end;

Damit wird wieder das Paint-Ereignis aufgerufen. Innerhalb der Komponente hat man immer AMyProperty zu verwenden, nie MyProperty!

[Bearbeiten] Komponente installieren

Hier geht es relativ einfach, da die Komponente nur aus einer Unit besteht: Man ruft Komponente / Komponente installieren ... auf, gibt die Unit an, klickt im Dialog auf "Compilieren" und anschließend auf "Installieren" und wartet auf eine Erfolgsmeldung. Dafür darf aber die automatisch erzeugte Register-Prozedur nicht gelöscht werden!

[Bearbeiten] Multimediafunktionen

[Bearbeiten] Multimedia

Man kann unter Delphi sehr einfach multimediale Funktionen implementieren, indem man auf die Windows-API zugreift (Voraussetzung ist natürlich, dass man Windows nutzt). Das ist noch nicht nötig, wenn man ein Video abspielen möchte, wohl aber beim Schneiden. Oder etwa bei der Aufnahme von der Soundkarte und dem Abspeichern als Wave.

Zuerst muss man die Unit MMSystem in die Uses-Klausel aufnehmen. Diese bietet uns nun den Zugriff auf die entsprechenden API-Funktionen.

[Bearbeiten] Aufnehmen eines Sounds

Um einen Sound aufzunehmen, benötigen wir zum Beispiel schon die MMSystem-Unit (MultiMediaSystem). Wir benutzen immer die Funktion "mciSendString". Zuerst wollen wir einen neuen Bezeichner erstellen, vom Typ "waveaudio". Jedoch nicht als Delphi-Variable! Der entsprechende Code sieht folgendermaßen aus:

mciSendString('OPEN NEW TYPE WAVEAUDIO ALIAS mysound', nil, 0, Handle);

Groß- / Kleinschreibung ist auch bei diesem String (genau genommen PChar) egal. Darauf folgt die Aufnahme:

mciSendString('RECORD mysound', nil, 0, Handle);

Möchte man vorher noch etwas an der Qualität feilen, müssen wir folgendes voranstellen:

mciSendString('SET mysound TIME FORMAT MS', nil, 0, Handle);
mciSendString('SET mysound BITSPERSAMPLE 16', nil, 0, Handle);
mciSendString('SET mysound CHANNELS 1', nil, 0, Handle);
mciSendString('SET mysound SAMPLESPERSEC 44000', nil, 0, Handle);
mciSendString('SET mysound BYTESPERSEC 88250', nil, 0, Handle);

Damit haben wir eine gute Qualität, nicht wie standardmäßig! Nun wird die Aufnahme (natürlich nicht direkt danach) gestoppt. Dazu wird folgendes verwendet:

mciSendString('STOP mysound', nil, 0, Handle);

Damit wird nicht nur die Aufnahme, sondern auch die Wiedergabe gestoppt. Die Wiedergabe erfolgt so:

mciSendString('PLAY mysound FROM 0', nil, 0, Handle);

Oder nur 2 Sekunden lang:

mciSendString('PLAY mysound FROM 0 TO 2000', nil, 0, Handle);

Die 2000 bezieht sich auf das Zeitformat, welches wir auf Millisekunden gestellt haben.

[Bearbeiten] Öffnen eines Sounds / Videos

Für den Sound genügt dazu ein einfacher Befehl:

mciSendString('OPEN sound.wav ALIAS mysound', nil, 0, Handle);

Danach kann er wie gezeigt abgespielt werden. Für das Video ist das Öffnen dasselbe, das Abspielen jedoch anders:

mciSendString(PChar(format('WINDOW mymovie HANDLE %d', [Panel1.Handle])), nil, 0, Handle);
mciSendString('PLAY mymovie FROM 0', nil, 0, Handle);

Bei Dateinamen mit Leerzeichen ist dieser in Gänsefüßchen einzuschließen!

[Bearbeiten] Schneiden eines Sounds / Videos

Auch das ist möglich! Mit einem einfachen Befehl:

mciSendString('DELETE mysound FROM 100 TO 1000', nil, 0, Handle);

Wichtig ist das Zeitformat!

[Bearbeiten] Speichern

Zuletzt noch das Speichern:

mciSendString('SAVE mysound sound.wav', nil, 0, Handle);

Bei einem Dateinamen mit Leerzeichen ist dieser in Gänsefüßchen einzuschließen!

[Bearbeiten] TMediaPlayer

In Delphi gibt es seit mindestens Delphi 3 die Komponente "TMediaPlayer". Diese kapselt so ziemlich alle diese Methoden und Zugriff in einer Komponente.

Standardmäßig hat diese Komponente eine visuelle Benutzerschnittstelle. Jedoch gerade wenn man seinen eigenen Media Player programmieren will, ist diese nicht wirklich erwünscht. Für dieses Problem stellt die Komponente die Eigenschaft "ButtonsVisible" zu Verfügung. Diese blendet die Steuerfläche aus, und man kann die Komponente weiter ansteuern.

Standardmäßig unterstützt diese Komponente die häufigsten Dateiformate wie *.mp3, *.wav und *.wma.

[Bearbeiten] Anhänge

[Bearbeiten] Der (richtige) Programmierstil

Wie schon am Anfang des Buches beschrieben, unterscheidet Pascal nicht zwischen Groß- und Kleinschreibung. Ebenso ist es dem Compiler egal, wie viele Leerzeichen oder Tabulatoren man zwischen die einzelnen Schlüsselwörter, Rechenzeichen oder Ähnliches setzt, genauso wie man ein Programm auch komplett in einer Zeile unterbringen könnte.

Der Programmtext sollte jedoch sauber strukturiert sein und man sollte sich dabei an einige Regeln halten. Dies dient dazu, den Code später einfacher warten zu können. Falls man im Team arbeitet ist so auch sichergestellt, dass sich andere im Code schneller zurecht finden.

Hierfür haben sich einige Regeln eingebürgert, die nach Möglichkeit von jedem angewandt werden sollten.

[Bearbeiten] Allgemeine Regeln

[Bearbeiten] Einrückung

Um bestimmte Zusammenhänge, wie zum Beispiel Anweisungsblöcke, im Quelltext kenntlich zu machen, rückt man die Zeilen ein. Dabei sollten keine Tabulatoren sondern Leerzeichen verwendet werden, damit der Text auf jedem Rechner gleich aussieht. Standard sind 2 Leerzeichen je Ebene.

[Bearbeiten] Seitenrand

Gelegentlich wird man auch mal einen Programmtext ausdrucken wollen. Hierfür ist der rechte Seitenrand auf 80 einzustellen. Erkennbar ist dies über eine durchgezogene Linie im Editor. Wenn möglich, sollte diese Linie nicht überschrieben werden.

[Bearbeiten] Kommentare

Für Kommentare sollte man hauptsächlich die geschweiften Klammern { } verwenden. Den anderen Kommentarblock (* *) sollte man nur verwenden, um Programmabschnitte vorübergehend aus dem Programm auszuschließen (auszukommentieren). Kommentare mittels // bitte ausschließlich für einzeilige Kommentare verwenden.

[Bearbeiten] Compilerdirektiven

Direktiven werden immer in geschweifte Klammern gesetzt, wobei die Compileranweisung in Großbuchstaben geschrieben wird. Beim Einrücken gelten die gleichen Regeln wie oben.

[Bearbeiten] Anweisungsblöcke

Bei Anweisungsblöcken zwischen begin und end stehen diese beiden Schlüsselwörter jeweils auf einer eigenen Zeile. Anweisungen wie if ... then begin oder while ... do begin sollten vermieden werden. begin und end stehen immer auf der gleichen Ebene wie die zugehörige If- oder Schleifenabfrage:

if ... then
begin
  ...
end;

[Bearbeiten] Klammern

Nach einer geöffneten Klammer und vor der geschlossenen Klammer stehen keine Leerzeichen. Bei Klammern zur Parameterübergabe an Funktionen, Prozeduren und Methoden kein Leerzeichen zwischen dem Namen und der geöffneten Klammer verwenden. Dies gilt auch für die eckigen Klammer zur Angabe eines Index. Klammern nur angeben, wenn diese auch notwendig sind!

Writeln ( txt );    // falsch
Writeln (txt);      // falsch
Writeln( txt );     // falsch
Writeln(txt);       // die einzig richtige Variante

x := a * ( b + c ); // falsch
x := a * (b + c);   // richtig

x := (a * b);       // falsch, unnötige Klammer
x := a * b;         // richtig

i[1] := x;          // richtig

[Bearbeiten] Interpunktion

Semikolons sowie der Punkt hinter dem letzten end stehen ohne Leerzeichen direkt hinter dem letzten Zeichen der Anweisung. Sie schließen die Zeile ab, danach folgt ein Zeilenumbruch, sprich: jede Anweisung steht auf einer eigenen Zeile. Ausnahme: Direktiven hinter der Deklaration von Funktionen.

Writeln('Zeilenende hinter Semikolon!');
Writeln('Nächste Anweisung.');

aber:

function Stellenanzahl(Zahl: Integer): Integer; forward;
procedure HilfeAusgeben; overload;
procedure HilfeAusgeben(Text: string); overload;

Vor Kommata zur Trennung von Parametern oder in anderen Auflistungen steht kein Leerzeichen, aber dahinter. Dasselbe gilt für Doppelpunkte bei der Deklaration von Variablen oder Parametern.

var
  x: Integer;
  a: array[0..2, 0..2] of Byte;
{ ... }
x := Pos(chr, zeichenkette);
a[0, 1] := 32;

Rechenoperatoren werden immer von Leerzeichen umschlossen.

[Bearbeiten] Operatoren

Mit Ausnahme der unären Operatoren @ und ^ stehen vor und nach Operatoren immer Leerzeichen. Hierzu zählt auch der Zuweisungsoperator :=.

z := x+y;        // falsch
z := x + y;      // richtig

a := @Funktion;  // richtig
p := Zeiger^;    // richtig

[Bearbeiten] Reservierte Wörter

Diese Wörter gehören fest zum Sprachumfang von Pascal/Delphi. Sie werden unter neueren Delphi-Versionen standardmäßig dunkelblau und fett hervorgehoben, unter Lazarus und älteren Delphi-Versionen schwarz und fett. Diese Wörter werden immer kleingeschrieben.

Beispiele:

program
const

aber auch:

string

[Bearbeiten] Routinen und Methoden

[Bearbeiten] Namensvergabe

Namen von Prozeduren und Funktionen (=Routinen) sowie Methoden sollten immer großgeschrieben sein. Falls sich der Name aus mehreren Wörtern zusammensetzt, beginnt jedes neue Wort ebenso mit einem Großbuchstaben. Der Name sollte so sinnvoll gewählt sein, dass man daraus bereits die Aufgabe der Routine ableiten kann. Um dies zu erreichen, empfiehlt es sich, ein entsprechendes Verb im Namen unterzubringen. Bei Routinen, die Werte von Variablen ändern, wird das Wort Set (oder deutsch Setze) davorgeschrieben. Bei Routinen, die Werte auslesen, steht das Wort Get bzw. Hole davor.

procedure Hilfe;          // falsch, Aufgabe nicht ganz eindeutig
procedure HilfeAnzeigen;  // richtig
procedure ausgabedateispeichernundschliessen;  // falsch, nur Kleinbuchstaben
procedure AusgabedateiSpeichernUndSchliessen;  // richtig
procedure SetzeTextfarbe;
function HolePersonalnr: Integer;

[Bearbeiten] Parameter

Die Bezeichnung von Parametern sollte ebenfalls so gewählt werden, dass man auf den ersten Blick den Zweck erkennen kann. Der Name wird auch groß geschrieben. Nach Möglichkeit sollte ihm ein großes A vorangestellt werden, um einen Parameter von Variablen und Klasseneigenschaften unterscheiden zu können.

Bei der Reihenfolge sollten die allgemeineren Parameter weiter links stehen, die spezielleren rechts, z.B. Ort, Straße, Hausnummer. Zusammengehörige Parameter sollten dabei nebeneinander stehen. Genauso sollten, wenn möglich, Parameter gleichen Typs zusammengefasst werden:

procedure ZeichnePunkt(R, F: Integer; L: TColor);                // falsch, Zweck der Parameter nicht erkennbar
procedure ZeichnePunkt(Y: Integer; AFarbe: TColor; X: Integer);  // falsch, unsinnige Reihenfolge
procedure ZeichnePunkt(X, Y: Integer; AFarbe: TColor);           // richtig

Parameter vom Typ Record, Array oder ShortString sollten als konstante Parameter deklariert werden, falls deren Wert in der Routine nicht geändert wird. Dies erhöht die Geschwindigkeit des Programms, da der Inhalt der Parameter nicht lokal kopiert wird. Bei anderen Parametertypen ist dies ebenfalls möglich, bringt aber keinen Geschwindigkeitsvorteil.

[Bearbeiten] Variablen

Variablen sollte ein Name gegeben werden, der ihren Zweck erkenntlich macht. Sie sollten ebenfalls grundsätzlich großgeschrieben werden. Bei Zählern und Indizes besteht der Name meist nur aus einem Buchstaben: z.B. I, J, K. Boolische Variablen sollten einen Namen haben, bei dem die Bedeutung der Werte True und False sofort klar ist.

var
  Wort: Boolean;           // falsch, Bedeutung von True und False nicht zu erkennen
  WortGeaendert: Boolean;  // richtig

Variablen werden jede auf einer eigenen Zeile deklariert (wie im Beispiel oben). Es sollte nicht mehrere Variablen gleichen Typs zusammengefasst werden.

Sie sollten es dringend vermeiden, globale Variablen zu benutzen. Falls Sie Variablen global benutzen müssen, dann schränken Sie dies so weit wie möglich ein. Deklarieren Sie z.B. eine solche Variable im Implementation-Teil einer Unit und nicht im Interface-Teil.

[Bearbeiten] Typen

Typen sollten so geschrieben werden, wie sie deklariert wurden. string ist z.B. ein reserviertes Wort und wird demnach auch als Typ klein geschrieben. Viele Typen aus der Windows-Schnittstelle sind vollständig in Großbuchstaben deklariert und sollten dann auch dementsprechend verwendet werden, z.B. HWND oder WPARAM. Andere von Delphi mitgelieferte Typen beginnen mit einem Großbuchstaben, z.B. Integer oder Char.

Typen, die Sie selbst anlegen, stellen Sie bitte ein großes T voran, bei Zeigertypen ein großes P. Ansonsten gilt die gleiche Schreibweise wie bei Variablen. Auch hier achten Sie bitte darauf, dass der Typ einen zweckmäßigen Namen erhält.

[Bearbeiten] Gleitkommazahlen

Benutzen Sie bitte hauptsächlich den Typ Double, hierfür sind alle Prozessoren ausgelegt. Real existiert nur noch um mit älteren Programmen kompatibel zu sein, in Delphi ist Real derzeit gleichbedeutend mit Double. Single sollten Sie nur verwenden, wenn Ihnen der Speicherbedarf der entsprechenden Variable wichtig ist. Extended ist ein Sonderformat von Intel und könnte beim Datenaustausch zwischen verschiedenen Rechnern zu Problemen führen. Sie sollten Extended daher nur verwenden, wenn Sie auf die erweiterte Genauigkeit angewiesen sind und Werte dieses Typs möglichst nicht in Dateien speichern, die für einen Datenaustausch verwendet werden.

[Bearbeiten] Aufzählungen

Geben Sie bitte Aufzählungen einen Namen, der dem Zweck des Typs entspricht. Die Bezeichner der Positionen benennen Sie so, dass die ersten zwei oder drei Buchstaben (kleingeschrieben) den Typ der Aufzählung wiedergeben:

TMitarbeiterArt = (maAngestellter, maLeitenderAngestellter, maVorstand);

Eine Variable vom Typ Aufzählung wird genau wie der Typ benannt, lediglich das führende T lässt man weg. Benötigt man mehrere Variablen eines Typs, kann man diese entweder durchnummerieren oder erweitert den Namen um einen passenden Begriff.

[Bearbeiten] Varianten

Verwenden Sie Varianten so sparsam wie möglich. Varianten sind nicht die bevorzugte Art, Daten unbekannten Typs zu konvertieren. Benutzen Sie stattdessen Zeiger und Typumwandlungen. Bei COM- und Datenbankapplikationen werden Sie vermutlich nicht umhin kommen, Varianten zu verwenden. Sie sollten in diesem Falle den Typ OleVariant nur bei COM-Anwendungen (z.B. ActiveX-Komponenten) verwenden und ansonsten den Typ Variant.

[Bearbeiten] Arrays und Records

Wie auch schon zuvor, sollte auch der Name von Arrays und Records sinnvoll zu deren Verwendungszweck vergeben werden. Auch vor diese Typbezeichner wird ein T gesetzt (bzw. P bei Zeigern). Ähnlich wie bei Aufzählungen, sollten Sie auch bei Variablen eines Array- bzw. Record-Typs den gleichen Namen nur ohne führendes T verwenden, falls möglich.

[Bearbeiten] Anweisungen

[Bearbeiten] If-Anweisungen

Bei Verzweigungen mit if sollten die wahrscheinlichsten Anweisungen nach dem then stehen, die seltender eintretenden Bedingungen nach dem else.

Wenn irgend möglich, sollten Sie vermeiden, mehrere If-Abfragen nacheinander zu schreiben. Verwenden Sie statt dessen die Verzweigung mittels case. Ebenso vermeiden Sie es bitte, If-Abfragen in mehr als fünf Ebenen zu verschachteln. Klammern bitte nur verwenden, wenn diese auch benötigt werden!

In Delphi gibt es die Möglichkeit, Bedingungsabfragen bereits nach der ersten falschen Bedingung abbrechen zu lassen. Dies spart in der Ausführung der Anwendung etwas an Zeit. Um diesen Zeitvorteil weiter auszubauen, sollte man die Abfragen sortieren. Dabei kann man von links nach rechts die Abfragen tätigen, die am wahrscheinlichsten auf "false" lauten werden. Eine weitere Möglichkeit ist, die am schnellsten zu berechnenden Bedingungen am weitesten nach links zu stellen.

Für gewöhnlich stehen die Bedingungen nebeneinander. Sollten dies zu viele werden, können sie auch untereinander geschrieben werden. Dabei sind sie linksbündig zu formatieren:

if Bedingung1 and Bedingung2 and Bedingung3 then
  ...

if Bedingung1 and
   Bedingung2 and
   Bedingung3 then
  ...

Wenn sich die auszuführende Anweisung nach dem then oder else über mehrere Zeilen erstreckt (zum Beispiel, weil sie am Zeilenende umgebrochen werden muss, oder weil Kommentare vorangesetzt werden), bitte alles zwischen begin und end einfassen:

{ Falsch }
if x = 1 then
  // Hier passiert was
  Writeln(x);

{ Richtig }
if x = 1 then
begin
  // Hier passiert was
  Writeln(x);
end;

{ Falsch }
if x = 1 then
  Writeln('Dies ist ein sehr langer Text, der' +
          'am Zeilenende umgebrochen wurde,' +
          'damit er auf Ausdrucken immer noch' +
          'lesbar erscheint.');

{ Richtig }
if x = 1 then
begin
  Writeln('Dies ist ein sehr langer Text, der' +
          'am Zeilenende umgebrochen wurde,' +
          'damit er auf Ausdrucken immer noch' +
          'lesbar erscheint.');
end;

Das Schlüsselwort else sollte immer den gleichen Einzug erhalten wie if.

[Bearbeiten] Case-Anweisungen

Die einzelnen Unterscheidungsmöglichkeiten einer Case-Verzweigung sollten numerisch, alphabetisch oder (bei anderen Aufzählungstypen) in der Reihenfolge ihrer Deklaration abgefragt werden.

Die Anweisungen, die den Abfragen folgen, sollten möglichst kurz und einfach gehalten werden, da der Programmtext sonst schnell unübersichtlich wird. Empfehlenswert sind vier bis fünf Zeilen, diese sollten immer zwischen begin und end stehen (auch bei einzelnen Zeilen). Größere Anweisungsfolgen am besten in eigene Routinen auslagern.

Den Else-Abschnitt sollten Sie nur verwenden, wenn Sie ein gültiges Default-Verhalten festlegen können.

Alle Abschnitte einer Case-Verzweigung sollen eingerückt werden. Das else steht auf der gleichen Höhe wie das case. Bei größeren Case-Blöcken, die einen Else-Abschnitt enthalten, sollte man das else zum besseren Überblick mit einem Kommentar versehen, um es eindeutig dem Case-Abschnitt zuzuordnen.

case Wert of
  Bedingung:
    begin
      ...
    end;
else  { case }
  ...
end;

[Bearbeiten] While-, For- und Repeat-Schleifen

Wenn Sie eine Schleife verlassen wollen, vermeiden Sie bitte die Anweisung Exit. Schleifen sollten immer über die Prüfbedingung beendet werden. Alle Variablen, die Sie innerhalb einer Schleife verwenden, sollten Sie direkt davor initialisieren und (wenn nötig) direkt anschließend wieder bereinigen. So stellt man sicher, dass man nichts vergisst.

[Bearbeiten] With-Anweisungen

With-Anweisungen sollten Sie nur sehr selten einsetzen, wenn Sie zum Beispiel mit einem sehr umfangreichen Record arbeiten. Ansonsten verwenden Sie bitte die Form Variable.Element in Ihrem Programm. Obwohl es möglich ist, verwenden Sie bitte nie mehrere Records in einer With-Anweisung, wie z.B. with Record1, Record2 do

[Bearbeiten] Fehlerbehandlung

Die Fehlerbehandlung sollte sowohl zur Korrektur möglicher Fehler als auch immer dann eingesetzt werden, wenn Speicherbereiche zugewiesen werden, um diese nach dem Auftreten einer Exception sauber wieder freizugeben.

Zur Fehlerbehandlung verwendet man gewöhnlich try ... finally. Bei Speicherzuweisungen sollte man recht großzügig mit der Anzahl der Blöcke sein und nach jeder Zuweisung einen neuen Block beginnen.

Klasse1 := TKlasse1.Create;
Klasse2 := TKlasse2.Create;
try
  { ... }
finally
  Klasse1.Free;
  Klasse2.Free;
end;

besser:

Klasse1 := TKlasse1.Create;
try
  Klasse2 := TKlasse2.Create;
  try
    { ... }
  finally
    Klasse2.Free;
  end;
finally
  Klasse1.Free;
end;

try ... except sollte man nicht unbedingt benutzen, es sei denn, dass man bei verschiedenen Exceptions verschiedene weitere Aktionen auslösen möchte.

[Bearbeiten] Klassen

Der Name einer Klasse beginnt immer mit einem T, da es sich hierbei um einen Typ handelt. Der Rest des Namens sollte dem Zweck der Klasse entsprechen. Bei mehreren Wörtern im Namen beginnt jedes Wort mit einem Großbuchstaben. Die dazugehörige Variable trägt den gleichen Namen wie die Klasse, nur ohne führendes T. Falls Sie weitere Variablen einer Klasse benötigen, können Sie diese nummerieren oder Sie verwenden weitere zusätzliche Begriffe im Namen der Variablen.

[Bearbeiten] Felder

Felder werden wie Variablen benannt, sollten jedoch mit einem F beginnen. Damit sind sie eindeutig von anderen Variablen zu unterscheiden. Weiterhin sollten Felder immer als private deklariert werden. Falls Sie die Daten von außerhalb der Klasse ändern möchten, erstellen Sie eine Methode oder Eigenschaft für diesen Zweck.

Ebenso wie Variablen sollten Felder jedes auf seiner eigenen Zeile deklariert werden. Bitte keine Felder gleichen Typs zusammenfassen.

[Bearbeiten] Methoden

Methoden benennen Sie wie Prozeduren und Funktionen.

Deklarieren Sie eine Methode als static, wenn diese in Nachkommenklassen nicht überschrieben werden sollen. Im Gegensatz dazu deklarieren Sie eine Methode als virtual, wenn sie ausdrücklich überschrieben werden soll. Verwenden Sie hierfür nicht dynamic! Deklarieren Sie eine Methode nur in Basisklassen als abstract, die niemals direkt verwendet werden.

Methoden zum Zugriff auf Eigenschaften werden immer als private oder protected deklariert. Die Methoden zum Lesen der Eigenschaften beginnen mit Get (bzw. deutsch Hole), die Methoden zum Schreiben der Eigenschaft mit Set (bzw. Setze). Der Parameter der Methode zum Schreiben des Wertes heißt Value.

[Bearbeiten] Eigenschaften

Eigenschaften, die auf private Felder zugreifen, werden wie das Feld benannt, nur ohne führendes F. Verwenden Sie für den Namen bitte nur Substantive, keine Verben. Eigenschaften mit Index sollten dabei in der Mehrzahl stehen, sonst Einzahl:

property Farbe: TColor read FFarbe write FFarbe;
property Adressen[1..10]: TAdresse read HoleAdresse write SetzeAdresse;

Eigenschaften, die im Objektinspektor von Delphi angezeigt werden sollen, deklarieren Sie als published, sonst als public.

Quelle: frei nach „Delphi 4 Developer's Guide Coding Standards Document“

[Bearbeiten] Befehlsregister

Dieses Kapitel muss noch angelegt werden. Hilf mit unter: http://de.wikibooks.org/wiki/Programmierkurs:_Delphi

[Bearbeiten] Glossar

Dieses Kapitel muss noch angelegt werden. Hilf mit unter: http://de.wikibooks.org/wiki/Programmierkurs:_Delphi

[Bearbeiten] Autoren

Diese Autoren haben an diesem Wikibook mitgearbeitet (IP-Adressen nicht aufgelistet):

• Alpha
• Axelf
• Bastie
• Daniel B
• Dannys9
• Delphi-himmel.de
• Delphimann
• Derbeth
• DieFel
• Dosenfant
• Drumlin
• Elundril
• Gbg
• Gnushi
• Gordon Freeman
• Hollerbach
• I.MacLeod
• Jayk
• Jonathan Hornung
• Luke
• MGla
• Muffin
• Progman
• Shivan
• Sliver
• Stefan Majewsky
• ThePacker

Letzte Aktualisierung: 5.11.2007, 17:37:23

[Bearbeiten] Lizenz

Version 1.2, November 2002

Copyright (C) 2000,2001,2002  Free Software Foundation, Inc.
51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.

0. PREAMBLE

The purpose of this License is to make a manual, textbook, or other functional and useful document "free" in the sense of freedom: to assure everyone the effective freedom to copy and redistribute it, with or without modifying it, either commercially or noncommercially. Secondarily, this License preserves for the author and publisher a way to get credit for their work, while not being considered responsible for modifications made by others.

This License is a kind of "copyleft", which means that derivative works of the document must themselves be free in the same sense. It complements the GNU General Public License, which is a copyleft license designed for free software.

We have designed this License in order to use it for manuals for free software, because free software needs free documentation: a free program should come with manuals providing the same freedoms that the software does. But this License is not limited to software manuals; it can be used for any textual work, regardless of subject matter or whether it is published as a printed book. We recommend this License principally for works whose purpose is instruction or reference.

1. APPLICABILITY AND DEFINITIONS

This License applies to any manual or other work, in any medium, that contains a notice placed by the copyright holder saying it can be distributed under the terms of this License. Such a notice grants a world-wide, royalty-free license, unlimited in duration, to use that work under the conditions stated herein. The "Document", below, refers to any such manual or work. Any member of the public is a licensee, and is addressed as "you". You accept the license if you copy, modify or distribute the work in a way requiring permission under copyright law.

A "Modified Version" of the Document means any work containing the Document or a portion of it, either copied verbatim, or with modifications and/or translated into another language.

A "Secondary Section" is a named appendix or a front-matter section of the Document that deals exclusively with the relationship of the publishers or authors of the Document to the Document's overall subject (or to related matters) and contains nothing that could fall directly within that overall subject. (Thus, if the Document is in part a textbook of mathematics, a Secondary Section may not explain any mathematics.) The relationship could be a matter of historical connection with the subject or with related matters, or of legal, commercial, philosophical, ethical or political position regarding them.

The "Invariant Sections" are certain Secondary Sections whose titles are designated, as being those of Invariant Sections, in the notice that says that the Document is released under this License. If a section does not fit the above definition of Secondary then it is not allowed to be designated as Invariant. The Document may contain zero Invariant Sections. If the Document does not identify any Invariant Sections then there are none.

The "Cover Texts" are certain short passages of text that are listed, as Front-Cover Texts or Back-Cover Texts, in the notice that says that the Document is released under this License. A Front-Cover Text may be at most 5 words, and a Back-Cover Text may be at most 25 words.

A "Transparent" copy of the Document means a machine-readable copy, represented in a format whose specification is available to the general public, that is suitable for revising the document straightforwardly with generic text editors or (for images composed of pixels) generic paint programs or (for drawings) some widely available drawing editor, and that is suitable for input to text formatters or for automatic translation to a variety of formats suitable for input to text formatters. A copy made in an otherwise Transparent file format whose markup, or absence of markup, has been arranged to thwart or discourage subsequent modification by readers is not Transparent. An image format is not Transparent if used for any substantial amount of text. A copy that is not "Transparent" is called "Opaque".

Examples of suitable formats for Transparent copies include plain ASCII without markup, Texinfo input format, LaTeX input format, SGML or XML using a publicly available DTD, and standard-conforming simple HTML, PostScript or PDF designed for human modification. Examples of transparent image formats include PNG, XCF and JPG. Opaque formats include proprietary formats that can be read and edited only by proprietary word processors, SGML or XML for which the DTD and/or processing tools are not generally available, and the machine-generated HTML, PostScript or PDF produced by some word processors for output purposes only.

The "Title Page" means, for a printed book, the title page itself, plus such following pages as are needed to hold, legibly, the material this License requires to appear in the title page. For works in formats which do not have any title page as such, "Title Page" means the text near the most prominent appearance of the work's title, preceding the beginning of the body of the text.

A section "Entitled XYZ" means a named subunit of the Document whose title either is precisely XYZ or contains XYZ in parentheses following text that translates XYZ in another language. (Here XYZ stands for a specific section name mentioned below, such as "Acknowledgements", "Dedications", "Endorsements", or "History".) To "Preserve the Title" of such a section when you modify the Document means that it remains a section "Entitled XYZ" according to this definition.

The Document may include Warranty Disclaimers next to the notice which states that this License applies to the Document. These Warranty Disclaimers are considered to be included by reference in this License, but only as regards disclaiming warranties: any other implication that these Warranty Disclaimers may have is void and has no effect on the meaning of this License.

2. VERBATIM COPYING

You may copy and distribute the Document in any medium, either commercially or noncommercially, provided that this License, the copyright notices, and the license notice saying this License applies to the Document are reproduced in all copies, and that you add no other conditions whatsoever to those of this License. You may not use technical measures to obstruct or control the reading or further copying of the copies you make or distribute. However, you may accept compensation in exchange for copies. If you distribute a large enough number of copies you must also follow the conditions in section 3.

You may also lend copies, under the same conditions stated above, and you may publicly display copies.

3. COPYING IN QUANTITY

If you publish printed copies (or copies in media that commonly have printed covers) of the Document, numbering more than 100, and the Document's license notice requires Cover Texts, you must enclose the copies in covers that carry, clearly and legibly, all these Cover Texts: Front-Cover Texts on the front cover, and Back-Cover Texts on the back cover. Both covers must also clearly and legibly identify you as the publisher of these copies. The front cover must present the full title with all words of the title equally prominent and visible. You may add other material on the covers in addition. Copying with changes limited to the covers, as long as they preserve the title of the Document and satisfy these conditions, can be treated as verbatim copying in other respects.

If the required texts for either cover are too voluminous to fit legibly, you should put the first ones listed (as many as fit reasonably) on the actual cover, and continue the rest onto adjacent pages.

If you publish or distribute Opaque copies of the Document numbering more than 100, you must either include a machine-readable Transparent copy along with each Opaque copy, or state in or with each Opaque copy a computer-network location from which the general network-using public has access to download using public-standard network protocols a complete Transparent copy of the Document, free of added material. If you use the latter option, you must take reasonably prudent steps, when you begin distribution of Opaque copies in quantity, to ensure that this Transparent copy will remain thus accessible at the stated location until at least one year after the last time you distribute an Opaque copy (directly or through your agents or retailers) of that edition to the public.

It is requested, but not required, that you contact the authors of the Document well before redistributing any large number of copies, to give them a chance to provide you with an updated version of the Document.

4. MODIFICATIONS

You may copy and distribute a Modified Version of the Document under the conditions of sections 2 and 3 above, provided that you release the Modified Version under precisely this License, with the Modified Version filling the role of the Document, thus licensing distribution and modification of the Modified Version to whoever possesses a copy of it. In addition, you must do these things in the Modified Version:

A. Use in the Title Page (and on the covers, if any) a title distinct from that of the Document, and from those of previous versions (which should, if there were any, be listed in the History section of the Document). You may use the same title as a previous version if the original publisher of that version gives permission.

B. List on the Title Page, as authors, one or more persons or entities responsible for authorship of the modifications in the Modified Version, together with at least five of the principal authors of the Document (all of its principal authors, if it has fewer than five), unless they release you from this requirement.

C. State on the Title page the name of the publisher of the Modified Version, as the publisher.

D. Preserve all the copyright notices of the Document.

E. Add an appropriate copyright notice for your modifications adjacent to the other copyright notices.

F. Include, immediately after the copyright notices, a license notice giving the public permission to use the Modified Version under the terms of this License, in the form shown in the Addendum below.

G. Preserve in that license notice the full lists of Invariant Sections and required Cover Texts given in the Document's license notice.

H. Include an unaltered copy of this License.

I. Preserve the section Entitled "History", Preserve its Title, and add to it an item stating at least the title, year, new authors, and publisher of the Modified Version as given on the Title Page. If there is no section Entitled "History" in the Document, create one stating the title, year, authors, and publisher of the Document as given on its Title Page, then add an item describing the Modified Version as stated in the previous sentence.

J. Preserve the network location, if any, given in the Document for public access to a Transparent copy of the Document, and likewise the network locations given in the Document for previous versions it was based on. These may be placed in the "History" section. You may omit a network location for a work that was published at least four years before the Document itself, or if the original publisher of the version it refers to gives permission.

K. For any section Entitled "Acknowledgements" or "Dedications", Preserve the Title of the section, and preserve in the section all the substance and tone of each of the contributor acknowledgements and/or dedications given therein.

L. Preserve all the Invariant Sections of the Document, unaltered in their text and in their titles. Section numbers or the equivalent are not considered part of the section titles.

M. Delete any section Entitled "Endorsements". Such a section may not be included in the Modified Version.

N. Do not retitle any existing section to be Entitled "Endorsements" or to conflict in title with any Invariant Section.

O. Preserve any Warranty Disclaimers.

If the Modified Version includes new front-matter sections or appendices that qualify as Secondary Sections and contain no material copied from the Document, you may at your option designate some or all of these sections as invariant. To do this, add their titles to the list of Invariant Sections in the Modified Version's license notice. These titles must be distinct from any other section titles.

You may add a section Entitled "Endorsements", provided it contains nothing but endorsements of your Modified Version by various parties--for example, statements of peer review or that the text has been approved by an organization as the authoritative definition of a standard.

You may add a passage of up to five words as a Front-Cover Text, and a passage of up to 25 words as a Back-Cover Text, to the end of the list of Cover Texts in the Modified Version. Only one passage of Front-Cover Text and one of Back-Cover Text may be added by (or through arrangements made by) any one entity. If the Document already includes a cover text for the same cover, previously added by you or by arrangement made by the same entity you are acting on behalf of, you may not add another; but you may replace the old one, on explicit permission from the previous publisher that added the old one.

The author(s) and publisher(s) of the Document do not by this License give permission to use their names for publicity for or to assert or imply endorsement of any Modified Version.

5. COMBINING DOCUMENTS

You may combine the Document with other documents released under this License, under the terms defined in section 4 above for modified versions, provided that you include in the combination all of the Invariant Sections of all of the original documents, unmodified, and list them all as Invariant Sections of your combined work in its license notice, and that you preserve all their Warranty Disclaimers.

The combined work need only contain one copy of this License, and multiple identical Invariant Sections may be replaced with a single copy. If there are multiple Invariant Sections with the same name but different contents, make the title of each such section unique by adding at the end of it, in parentheses, the name of the original author or publisher of that section if known, or else a unique number. Make the same adjustment to the section titles in the list of Invariant Sections in the license notice of the combined work.

In the combination, you must combine any sections Entitled "History" in the various original documents, forming one section Entitled "History"; likewise combine any sections Entitled "Acknowledgements", and any sections Entitled "Dedications". You must delete all sections Entitled "Endorsements."

6. COLLECTIONS OF DOCUMENTS

You may make a collection consisting of the Document and other documents released under this License, and replace the individual copies of this License in the various documents with a single copy that is included in the collection, provided that you follow the rules of this License for verbatim copying of each of the documents in all other respects.

You may extract a single document from such a collection, and distribute it individually under this License, provided you insert a copy of this License into the extracted document, and follow this License in all other respects regarding verbatim copying of that document.

7. AGGREGATION WITH INDEPENDENT WORKS

A compilation of the Document or its derivatives with other separate and independent documents or works, in or on a volume of a storage or distribution medium, is called an "aggregate" if the copyright resulting from the compilation is not used to limit the legal rights of the compilation's users beyond what the individual works permit. When the Document is included in an aggregate, this License does not apply to the other works in the aggregate which are not themselves derivative works of the Document.

If the Cover Text requirement of section 3 is applicable to these copies of the Document, then if the Document is less than one half of the entire aggregate, the Document's Cover Texts may be placed on covers that bracket the Document within the aggregate, or the electronic equivalent of covers if the Document is in electronic form. Otherwise they must appear on printed covers that bracket the whole aggregate.

8. TRANSLATION