|
6. Programm: UseUnit
Das folgende Beispielprogramm zeigt, wie man eine Unit erzeugt und sie dann in einer Anwendung einsetzt. Das Programm ist bewusst extrem einfach gehalten, damit man nicht den Blick für das Wesentliche (nämlich Programmierung und Anwendung einer Unit) verliert. Das Programm soll einen vom Benutzer eingegebenen Satz in verkehrter Reihenfolge (von rechts nach links geschrieben) anzeigen.
Dazu erzeugen wir uns die Funktion ReverseString, die als Eingangsparameter einen String übernimmt und als Ergebnis den von rechts nach links gelesenen String zurück gibt. Da diese Funktion universell brauchbar ist, wird sie in einer Bibliothek (=unit) angelegt, so dass man später diese Funktion immer wieder verwenden kann. In die Bibliothek stellen wir außerdem die Funktion CalcMax, die wir schon vorher geschrieben haben.
Bevor wir das eigentliche Programm schreiben, erzeugen wir die Unit TestUnit:
| Schritt |
Aktivität |
Anmerkungen |
| 1. |
Leere Unit erzeugen (Befehl "File/New/Unit") und speichern |
Delphi erzeugt eine leere Hülle mit Namen, Interface und Implementation. Wir speichern diese leere Hülle unter dem Namen "testunit" ab. |
| 2. |
Füllen des Implementation-Bereichs mit den zwei Funktionen |
Die Funktion CalcMax hat für unser Programm keine Bedeutung, wir bauen sie nur ein, da auch sie universell verwendbar ist und wir außerdem sehen wie mehrere Routinen zu einer Bibliothek zusammengefasst werden. Die Funktion ReverseString sei hier nicht näher erklärt; im Prinzip wird der umgekehrte String durch Austauschen der Buchstaben des Strings erzeugt.
function CalcMax (v1, v2: double): double;
begin
if v1 > v2
then CalcMax := v1
else CalcMax := v2;
end;
function ReverseString (InString: string): string;
var
i,j : integer;
cc : char;
begin
result := InString;
i := 1;
j := length(InString);
while (i < j) do
begin
cc := result[i];
result[i] := result[j];
result[j] := cc;
inc (i);
dec (j);
end;
end;
|
| 3. |
Kopieren der Funktionsköpfe in den Interface-Teil |
Durch das Kopieren der Funktionsköpfe in den Interface-Teil werden die beiden Funktionen öffentlich zugänglich.
interface
function CalcMax (v1, v2: double): double;
function ReverseString (InString: string): string;
Damit ist die Programmierung der Unit abgeschlossen und wir können uns dem Hauptprogramm zuwenden. Vergessen Sie nicht die Unit zu speichern.
|
| 4. |
Erzeugung des Hauptprogramms |
Erzeugen Sie ein neue Applikation, und bringen Sie die beiden Komponenten Edit und Label (beide auf der Standard-Palette) auf das Formular. Wir benennen die Komponenten ausnahmsweise nicht um, nehmen also als Name Edit1 und Label1. |
| 5. |
OnChange-Event von der Edit-Komponente programmieren |
Wir nehmen nun den OnChange-Event der Edit-Komponente und übergeben den aktuellen Text der Editbox and die Funktion ReverseString. Der Rückgabewert wird Label1.Caption zugewiesen und damit angezeigt:
Label1.Caption := ReverseString(Edit1.Text);
|
| 6. |
uses-Statement einbauen. |
Würden wir jetzt das Programm übersetzen, so würde der Compiler uns erklären, dass der Bezeichner ReverseString unbekannt ist. Wir müssen also noch definieren, wo der Compiler nach unbekannten Bezeichnern suchen soll. Dazu dient das uses-Statement, das wir im Implementation-Bereich einbauen:
uses
testunit;
|
| 7. |
Fertig! |
Das Programm läuft und zeigt den verkehrten String an. |
| Beispiel: |
Um den Überblick zu bewahren nochmals die Unit und das Programm als Ganzes. Die wichtigen Bezeichner sind fett geschrieben:
unit testunit;
{------------------------------------------------}
interface
{------------------------------------------------}
function CalcMax (v1, v2: double): double;
function ReverseString (InString: string): string;
{------------------------------------------------}
implementation
{------------------------------------------------}
(************************************************)
function CalcMax (v1, v2: double): double;
(************************************************)
begin
if v1 > v2
then CalcMax := v1
else CalcMax := v2;
end;
(************************************************)
function ReverseString (InString: string): string;
(************************************************)
var
i,j : integer;
cc : char;
begin
result := InString;
i := 1;
j := length(InString);
while (i < j) do
begin
cc := result[i];
result[i] := result[j];
result[j] := cc;
inc (i);
dec (j);
end;
end;
end.
Und hier noch das aufrufende Programm (das aber auch eine Unit ist, da Delphi ja jedes Formular als Unit anlegt):
unit Unit1;
interface
uses
Windows, Messages, SysUtils, Variants,
Classes, Graphics, Controls, Forms,
Dialogs, StdCtrls;
type
TForm1 = class(TForm)
Edit1: TEdit;
Label1: TLabel;
procedure Edit1Change(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;
var
Form1: TForm1;
implementation
{$R *.dfm}
uses
testunit;
procedure TForm1.Edit1Change(Sender: TObject);
begin
Label1.Caption := ReverseString(Edit1.Text);
end;
end.
|
|
Unterprogramme, Units und Libraries 
