Units - oder: Wie vereinigen wir uns...? 컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴컴 Dieses Kapitel soll die grundlegenden Dinge zur Arbeit mit sog. "Units", die in Pascal immer wieder vorkommen, erl꼞tern. Beginnen wir mal leicht: Man kann Progamme schreiben, die g꼗zlich ohne Units auskommen, doch wird man an ihnen nicht viel Freude haben, da Units als ein fester Bestandteil von Pascal-Programmen anzusehen sind. Das f꼗gt schon allein mit dem Befehl "ClrScr" in Pascal an. Diese Prozedur, die den Bildschirminhalt l봲cht, ist in der Unit CRT "deklariert". Man kann auf diesen Befehl nur dann zu- greifen, wenn man die Unit CRT eingebunden hat; und damit w꼛en wir auch schon bei der eigentlichen Erkl꼛ung f걊 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 lauff꼑ige EXE-Datei erzeugen kann. Doch wenn das schon nicht klappt, was bietet eine Unit denn dann f걊 Vorteile ? Nun, es gibt zwei Dinge, die f걊 Units sprechen. Zum einen w꼛e da nat걊lich die Sache, da� die sich die meisten Pascal-Befehle in Units befinden, die man zwangsl꼞fig einbinden mu�, um ein einigerma�en funktionst갷h- tiges Programm zu bekommen. Doch bietet sich noch ein weiter Vorteil: Jede Unit stellt f걊 sich ein eigenes Code-Segment zur Verf갾ung und kann bis zu 64 KByte Code umfassen - die Gesamt- gr붳e des Programms ist nur noch durch den zu Verf갾ung stehen- den Hauptspeicher begrenzt. Auch sollte der Gliederungsvorteil nicht au�er acht gelassen werden, denn durch die Aufteilung des Hauptprogramms in kleinere Teile (Units) wird der Quell-Code wesentlich 갶ersichtlicher. Hier noch einmal alle Vorteile von Units im 쉇erblick: o Units m걌sen nicht bei jeder Ver꼗derung des Hauptpro- gramms neu compiliert werden - die Compilierungszeiten werden k걊zer (soweit das bei Borland 갶erhaupt noch m봥lich ist...). o Jede Unit stellt ein eigenes Codesegment f걊 sich zur Verf갾ung, das bis zu 64 KByte umfassen kann. Somit ist die Gr붳e des Hauptprogramms nur noch auf den zur Ver- f갾ung stehenden Hauptspeicher begrenzt. o Durch die Aufteilung des Programms in Units wird eine wesentlich h봦ere 쉇ersichtlichkeit erreicht. Doch genug der Theorie 컴컴컴컴컴컴컴컴컴컴컴 Schreiben wir unser Programm mit Units...im folgenden gehe ich davon aus, da� wenigstens die grundlegenden Befehle f걊 Pascal bekannt sind. PROGRAM UnitTest; USES CRT; BEGIN ClrScr; WriteLn('Hallo'); END. Nun, wahrlich nicht sehr gro�, aber es wird eine Unit einge- bunden, n꼖lich "CRT". Diese Unit steht hinter der reservierten Anweisung USES, die f걊 die Einbindung der Units zur Verf갾ung 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 erw꼑nt, 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 gebr꼞chlichen 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 꼗dern, wie z.B. ClrScr , TextColor , TextBackGround... o DOS - Dies ist die Benutzerschnittstelle zum DOS. Hier sind alle Prozeduren enthalten, die Dateiverwaltungen unter DOS erm봥lichen, z.B. MkDir, Exec, GetFAttrib... o Graph - Alle Funktionen, Variablen, Konstanten und Proze- duren, die f걊 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 enth꼕t nicht viele Befehle. Mit ihrer Hilfe kann man Texte auf dem Drucker ausgeben oder den Drucker allgemein steuern. o Overlay - Diese Unit enth꼕t alle Routinen, die zur Verwal- tung von Overlays notwendig sind. In dieser Ausgabe unseres Disk-Mags gibt es auch 갶er Overlays einen Artikel. Schau' doch mal rein... Um es noch einmal zu verdeutlichen: Units sind Dateien, die Prozeduren, Funktionen und Datentypen beinhalten k봭nen. 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 f꼗gt anstelle von "PROGRAM" logischerweise mit...na..na..richtig, mit "UNIT" f꼗gt er an. Danach folgt ein Teil, der gew봦nlicherweise mit dem Wort "INTERFACE" bezeichnet wird. Ich habe es noch nicht mit einem anderen Wort versucht, aber es w걊de sowieso nicht klappen. In diesem "INTERFACE" sind alle Datentypen deklariert. Weiterhin stehen hier nur die Prozedur- oder Funktionsk봯fe derjenigen obigen, die sich in der Unit befinden und auf die man "봣fentlich" zugreifen kann. 셟fentlich hei�t hier, da� diese im "INTERFACE" genannten Prozeduren oder Funktionen im Haupt- programm verwendet werden d걊fen. Denn es gibt nat걊lich auch P+F (so werde ich im folgenden "Prozeduren und Funktionen" ab- k걊zen), die nur f걊 die Unit bestimmt sind, um z.B. eine klei- ne Nebenrechnung auszuf갿ren, die nur f걊 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 P걆ktchen k봭nen dann Initiali- sierungen vorgenommen werden, doch dazu kommen wir sp꼝er. Ich werde ein Beispiel f걊 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 w꼛e geschafft. Nun zur Erkl꼛ung: Ich werde die Pro- zeduren und Funktionen selbst nicht erkl꼛en, 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 k봭nen auch 봣fentliche Datentypen- Deklarationen stehen. F걊 unsere Unit brauchen wir aber keine. Wichtig zu sagen ist noch, da� auch Units andere Units verwen- den k봭nen. Die USES-Anweisung steht daf걊 auch im INTERFACE. 3. IMPLEMENTATION : Hier sind alle P+F und Datentypen in ihrer vollen L꼗ge aufgef갿rt. Hier ist auch die nicht-봣fentliche Variable "i". Sie kann sp꼝er nicht vom Hauptprogramm aus ver- 꼗dert werden. Die Prozeduren "Wri" und "Ton" sowie die sehr sinnige Funktion "IstWahr" sind 봣fentlich deklarierte, weil im INTERFACE aufgef갿rte P+F. Die Prozedur "Heraufz꼑len" ist nicht-봣fentlich, 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 k봭nen nun gaaaanz einfach die Prozedur mit den Parametern aufrufen, als w꼛en 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 - f걊 TP6 oder Compiler => Ausgabeziel Festplatte - f걊 TP7). Dann compilie- ren wir mit "F9" und die ".TPU"-Datei befindet sich in dem da- f걊 bestimmten Verzeichnis (Options => Directory Units - f걊 TP6 oder Option => Verzeichnisse Units - f걊 TP7). Zur Kon- trolle seht doch mal unter DOS nach. 쉇rigens: Sobald eine 럑derung an der Original-Unit im Editor stattfand, mu� die Unit wieder mit "F9" neu compiliert werden. Hoff'ma mal, da� es gr붳tenteils 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 갶er "Overlays", die eng mit den Units im Zusammenhang stehen, und das n꼊hste Mal gibts nochmal was 갶er Units, da es doch ein etwas komplexeres Thema ist. Nu' denn, euer Eric der Schreckliche 旼컴� 뇝뇝� 읏붫� 냅켸� � � � �