Programmierkurs: Delphi: Pascal: Aufbau eines Delphi-Programms

Aus Wikibooks
Zur Navigation springen Zur Suche springen

Aufbau eines Delphi-Programms[Bearbeiten]

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.

Aufbau des Hauptprogramms[Bearbeiten]

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.“

Delphi Programmaufbau.png


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:

Delphi Prozeduraufbau.png


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

Aufbau von Units[Bearbeiten]

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 Nachnamen 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.


Reihenfolge der Deklarationen[Bearbeiten]

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 zu 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.


Arrow left.png Warum Delphi Inhaltsverzeichnis Pascal: Das erste Programm Arrow right.png