Units - oder: Wie vereinigen wir uns...? Dieses Kapitel soll die grundlegenden Dinge zur Arbeit mit sog. "Units", die in Pascal immer wieder vorkommen, erlutern. Beginnen wir mal leicht: Man kann Progamme schreiben, die gnzlich ohne Units auskommen, doch wird man an ihnen nicht viel Freude haben, da Units als ein fester Bestandteil von Pascal-Programmen anzusehen sind. Das fngt schon allein mit dem Befehl "ClrScr" in Pascal an. Diese Prozedur, die den Bildschirminhalt lscht, ist in der Unit CRT "deklariert". Man kann auf diesen Befehl nur dann zu- greifen, wenn man die Unit CRT eingebunden hat; und damit wren wir auch schon bei der eigentlichen Erklrung fr Units: Units sind Dateien, die genau wie ein Pascal-Programm selbst Befehle (Prozeduren und Funktionen), Konstanten, Datentypen u.s.w. be- inhalten, auf die man zugreifen kann. Eine Unit ist simpler- weise nichts anderes als ein Programm selbst, nur hat sie den Nachteil, da man aus ihr nicht eine lauffhige EXE-Datei erzeugen kann. Doch wenn das schon nicht klappt, was bietet eine Unit denn dann fr Vorteile ? Nun, es gibt zwei Dinge, die fr Units sprechen. Zum einen wre da natrlich die Sache, da die sich die meisten Pascal-Befehle in Units befinden, die man zwangslufig einbinden mu, um ein einigermaen funktionstch- tiges Programm zu bekommen. Doch bietet sich noch ein weiter Vorteil: Jede Unit stellt fr sich ein eigenes Code-Segment zur Verfgung und kann bis zu 64 KByte Code umfassen - die Gesamt- gre des Programms ist nur noch durch den zu Verfgung stehen- den Hauptspeicher begrenzt. Auch sollte der Gliederungsvorteil nicht auer acht gelassen werden, denn durch die Aufteilung des Hauptprogramms in kleinere Teile (Units) wird der Quell-Code wesentlich bersichtlicher. Hier noch einmal alle Vorteile von Units im berblick: o Units mssen nicht bei jeder Vernderung des Hauptpro- gramms neu compiliert werden - die Compilierungszeiten werden krzer (soweit das bei Borland berhaupt noch mglich ist...). o Jede Unit stellt ein eigenes Codesegment fr sich zur Verfgung, das bis zu 64 KByte umfassen kann. Somit ist die Gre des Hauptprogramms nur noch auf den zur Ver- fgung stehenden Hauptspeicher begrenzt. o Durch die Aufteilung des Programms in Units wird eine wesentlich hhere bersichtlichkeit erreicht. Doch genug der Theorie Schreiben wir unser Programm mit Units...im folgenden gehe ich davon aus, da wenigstens die grundlegenden Befehle fr Pascal bekannt sind. PROGRAM UnitTest; USES CRT; BEGIN ClrScr; WriteLn('Hallo'); END. Nun, wahrlich nicht sehr gro, aber es wird eine Unit einge- bunden, nmlich "CRT". Diese Unit steht hinter der reservierten Anweisung USES, die fr die Einbindung der Units zur Verfgung steht. Wollte man mehrere Units einbinden, so geschieht das genauso, nur werden die Units durch ein Komma getrennt angege- ben ( USES CRT, Dos; ). Nur durch die Einbindung der Unit CRT erhalten wir Zugriff auf die Prozedur "ClrScr". Diese ist, wie oben schon erwhnt, in dieser Unit deklariert. Doch woher wei ich, da ich die Unit CRT einbinden mu ? Es gibt insgesamt 5 von Borland/Turbo Pascal vordeklarierte Units (von 2 weniger gebruchlichen abgesehen). Diese Units sind im einzelnen: o CRT - Diese Unit dient zum steuern des Bildschirms. Hier sind die Prozeduren enthalten, die des Aussehen des Pogramms im Textmodus ndern, wie z.B. ClrScr , TextColor , TextBackGround... o DOS - Dies ist die Benutzerschnittstelle zum DOS. Hier sind alle Prozeduren enthalten, die Dateiverwaltungen unter DOS ermglichen, z.B. MkDir, Exec, GetFAttrib... o Graph - Alle Funktionen, Variablen, Konstanten und Proze- duren, die fr den Umgang mit dem Grafikmodus von Bedeutung sind, sind hier deklariert, z.B. Circle, SetColor, SetLine- Style, InitGraph... o Printer - Dies ist die Schnittstelle zum Drucker. Diese Unit enthlt nicht viele Befehle. Mit ihrer Hilfe kann man Texte auf dem Drucker ausgeben oder den Drucker allgemein steuern. o Overlay - Diese Unit enthlt alle Routinen, die zur Verwal- tung von Overlays notwendig sind. In dieser Ausgabe unseres Disk-Mags gibt es auch ber Overlays einen Artikel. Schau' doch mal rein... Um es noch einmal zu verdeutlichen: Units sind Dateien, die Prozeduren, Funktionen und Datentypen beinhalten knnen. Sie sind von der Grundlegenden Struktur zwar etwas anders, die pro- grammierung der Prozeduren etc. ist aber gleich. Deshalb ist es auch ein leichtes, Units selbst zu schreiben, wenn man einige grundlegende Dinge beachtet. Der Kopf einer Unit fngt anstelle von "PROGRAM" logischerweise mit...na..na..richtig, mit "UNIT" fngt er an. Danach folgt ein Teil, der gewhnlicherweise mit dem Wort "INTERFACE" bezeichnet wird. Ich habe es noch nicht mit einem anderen Wort versucht, aber es wrde sowieso nicht klappen. In diesem "INTERFACE" sind alle Datentypen deklariert. Weiterhin stehen hier nur die Prozedur- oder Funktionskpfe derjenigen obigen, die sich in der Unit befinden und auf die man "ffentlich" zugreifen kann. ffentlich heit hier, da diese im "INTERFACE" genannten Prozeduren oder Funktionen im Haupt- programm verwendet werden drfen. Denn es gibt natrlich auch P+F (so werde ich im folgenden "Prozeduren und Funktionen" ab- krzen), die nur fr die Unit bestimmt sind, um z.B. eine klei- ne Nebenrechnung auszufhren, die nur fr die Unit relevant ist. Auf den "INTERFACE"-Teil folgt der "IMPLEMENTATION"-Teil, in dem sich alle P+F befinden. Abgeschlossen wird die Unit mit einem "END.", wenn keine Initialisierung beim Aufruf der Pro- zedur vorgenommen werden soll. Wenn doch, so endet eine Unit mit BEGIN ... END. In den drei Pnktchen knnen dann Initiali- sierungen vorgenommen werden, doch dazu kommen wir spter. Ich werde ein Beispiel fr eine Unit mit zwei Prozeduren und einer Funktion geben: *************************************************************** UNIT BspUnit; INTERFACE USES Crt; PROCEDURE Wri(x, y : INTEGER; Text : STRING); PROCEDURE Ton(Laenge : INTEGER); FUNCTION IstWahr(Zahl : Byte) : BOOLEAN; IMPLEMENTATION VAR i : BYTE; PROCEDURE Wri(x, y : INTEGER; Text : STRING); BEGIN GotoXY(x, y); Write(Text); END; PROCEDURE Heraufzaehlen; BEGIN i := i+1; END; PROCEDURE Ton(Laenge : INTEGER); BEGIN i := 1; REPEAT Sound(300); Delay(Laenge); NoSound; Delay(100); Heraufzaehlen; UNTIL i = 5; END; FUNCTION IstWahr(Zahl : Byte) : BOOLEAN; BEGIN IF Zahl = 1 THEN IstWahr := TRUE ELSE IstWahr := FALSE; END; END. *************************************************************** So, dies wre geschafft. Nun zur Erklrung: Ich werde die Pro- zeduren und Funktionen selbst nicht erklren, denn es geht nur um den Aufbau von Units. 1. UNIT : Dies ist der Bezeichner, da es sich um eine Unit handelt. Hinter UNIT kommt der Name der Unit. Unter diesem Namen mu die Unit nacher auch gespeichert werden. 2. INTERFACE : Nun folgen die P+F-Deklarationen. Auf diese P+F kann man nacher zugreifen, d.h. nur diese kann man vom Haupt- programm aus aufrufen. Hier knnen auch ffentliche Datentypen- Deklarationen stehen. Fr unsere Unit brauchen wir aber keine. Wichtig zu sagen ist noch, da auch Units andere Units verwen- den knnen. Die USES-Anweisung steht dafr auch im INTERFACE. 3. IMPLEMENTATION : Hier sind alle P+F und Datentypen in ihrer vollen Lnge aufgefhrt. Hier ist auch die nicht-ffentliche Variable "i". Sie kann spter nicht vom Hauptprogramm aus ver- ndert werden. Die Prozeduren "Wri" und "Ton" sowie die sehr sinnige Funktion "IstWahr" sind ffentlich deklarierte, weil im INTERFACE aufgefhrte P+F. Die Prozedur "Heraufzhlen" ist nicht-ffentlich, sie kann nur von den P+F der Unit verwendet werden. 4. END. : Unsere Unit braucht keinen Hauptteil oder besser keine Initialisierung. Deshalb steht nur ein "END." Ich hoffe, es war nicht zu kompliziert. Nun folgt eine weitere Aufgabe: Die Nutzung unserer Unit. Ein Programm hilft uns wei- ter: *************************************************************** PROGRAM UnitDemo; USES BspUnit, Crt; BEGIN ClrScr; Wri(3,10,'HALLO, ANWENDER!!!'); Ton(200); END. *************************************************************** In der USES-Anweisung haben wir nun unsere Unit "BspUnit" einge- bunden. Wir knnen nun gaaaanz einfach die Prozedur mit den Parametern aufrufen, als wren sie im Hauptprogramm deklariert. Aber, es mu noch etwas geschehen: Die Unit mu zu einer ".TPU"- Datei compiliert werden. Dazu mu das Ziel die Disk sein und nicht der Memory. (Compile => Destination Disk - fr TP6 oder Compiler => Ausgabeziel Festplatte - fr TP7). Dann compilie- ren wir mit "F9" und die ".TPU"-Datei befindet sich in dem da- fr bestimmten Verzeichnis (Options => Directory Units - fr TP6 oder Option => Verzeichnisse Units - fr TP7). Zur Kon- trolle seht doch mal unter DOS nach. brigens: Sobald eine nderung an der Original-Unit im Editor stattfand, mu die Unit wieder mit "F9" neu compiliert werden. Hoff'ma mal, da es grtenteils klar geworden ist, wie die ganze Sache funktioniert. Wenn nicht, die ganze Geschichte am besten nochmal durchlesen, die OnLine-Hilfe von Pascal fragen oder uns schreiben. Wenn ihr weiter Interesse habt: In dieser Ausgabe befindet sich ein Artikel ber "Overlays", die eng mit den Units im Zusammenhang stehen, und das nchste Mal gibts nochmal was ber Units, da es doch ein etwas komplexeres Thema ist. Nu' denn, euer Eric der Schreckliche Ŀ ٳ