Module in Pascal bezogen auf den Hauptteil des Programms ähneln sie Unterprogrammen (Prozeduren und Funktionen). Per Definition handelt es sich jedoch um unabhängige Programme, deren Ressourcen in anderen Programmen verwendet werden können. Darüber hinaus erfolgt die Beschreibung von Modulen außerhalb der aufrufenden Anwendung, jedoch in einer separaten Datei, sodass ein Modul ein separat kompiliertes Programm ist. Die kompilierte Moduldatei (die Sie verwenden müssen) hat die von der Programmierumgebung bereitgestellte Erweiterung (z. B. .tpu, .ppu, .pcu).
Module werden in der Regel erstellt, um die Kompaktheit des Codes zu gewährleisten, auf die große Projekte achten müssen. Es ist auch erwähnenswert, dass die Verwendung von Modulen gewissermaßen die Einschränkung der Speichersegmentierung aufhebt, da sich der Code jedes Moduls in einem separaten Segment befindet.
Die Modulstruktur sieht wie folgt aus:
Einheit<имя модуля>;
Schnittstelle
<интерфейсная часть>
Implementierung
<исполняемая часть>
Start
<инициализация>
Ende.
Modulname (Einheit)
Der Name des Moduls nach dem Schlüsselwort Einheit, muss mit dem Namen der Datei (ohne .pas) übereinstimmen, die ihren Code enthält. Außerdem wird das Modul unter Verwendung des Namens mit einem anderen Modul oder mit dem Hauptprogramm verbunden. Dazu müssen Sie das Dienstwort angeben Verwendet, und führen Sie die Liste der Plug-Ins durch Kommas getrennt auf:
Verwendet<список имен модулей>;
Schnittstellenteil (Schnittstelle)
Der Schnittstellenteil beschreibt die Header von Objekten, auf die andere Module und Programme Zugriff haben. Dies sind Konstanten, Typen, Variablen und Unterprogramme. So könnte beispielsweise der Schnittstellenteil des Suchmoduls aussehen, der Algorithmen zum Suchen nach Elementen in einem Array enthält.
|
1 |
Einheit Suche; |
Um dieses Modul zu deklarieren, müssen Sie seinen Namen im Programm angeben:
Danach können alle im Schnittstellenteil beschriebenen Objekte verwendet werden.
Ausführbarer Teil (Implementierung)
Dieser Abschnitt beginnt mit dem Wort Implementierung(Implementierung). Hier müssen Sie die im Schnittstellenteil deklarierten Unterprogramme beschreiben. Gleichzeitig dürfen in ihren Headern keine Formalparameter angegeben werden, da diese sonst vollständig mit denen im Schnittstellenteil übereinstimmen müssen. Außerdem kann der Schnittstellenteil Objekte enthalten, die für das Modul lokal (für das aufrufende Programm nicht zugänglich) sind.
Einleitender Teil
Der initiierende Teil beginnt seine Arbeit vor Beginn der Ausführung des Hauptprogramms. Darin (zwischen Beginn und Ende) werden in der Regel Operatoren beschrieben, die für verschiedene Arten von Hilfsarbeiten vorgesehen sind. Dieser Teil kann fehlen oder keinen Code enthalten. Im ersten Fall müssen Sie End mit einem Punkt angeben, im zweiten Fall müssen Sie ein Leerzeichen zwischen Begin und End lassen.
Kompilieren von Modulen
Im Programm können nur kompilierte Module verwendet werden, die über eine Erweiterung verfügen, die von Ihrer Anwendungsentwicklungsumgebung bereitgestellt wird. Betrachten Sie die drei beliebtesten von ihnen:
TurboPascal
Das Ergebnis der Kompilierung eines Moduls in Turbo Pascal ist eine Datei mit der Erweiterung .tpu (Turbo Pascal-Einheit), die ihren Code speichert.
Kostenlos Pascal
Nach dem Kompilieren eines Moduls in der Free Pascal-Umgebung werden zwei Dateien mit unterschiedlichen Berechtigungen erstellt: .ppu und .Ö. Der erste enthält den Schnittstellenteil des Moduls, der zweite (erforderlich für die Verknüpfung des Programms) den Implementierungsteil.
Pascal ABC.NET
Pascal ABC.Net generiert während der Modulkompilierung keinen Maschinensprachcode. Wenn die Kompilierung erfolgreich ist, wird der Code mit Erlaubnis in einer Datei gespeichert .pcu.
Für die Programmierumgebungen Turbo Pascal und Free Pascal gibt es drei Kompilierungsmodi: Kompilieren, erstellen und erstellen. Im Compile-Modus müssen alle im Programm verwendeten Module vorher kompiliert werden. Die Anwendung im Make-Compilation-Modus überprüft alle angeschlossenen Module auf das Vorhandensein von Dateien mit der entsprechenden Berechtigung für die Programmierumgebung (.tpu oder .o). Wenn eines davon nicht gefunden wird, wird eine Datei mit dem Namen des nicht gefundenen Moduls und der Erweiterung .pas gesucht. Der zuverlässigste der Modi ist Build. Das Suchen und Kompilieren von Dateien (mit der Erweiterung .pas) erfolgt in diesem Modus auch dann, wenn bereits Moduldateien vorhanden sind.
Beispiel
Lassen Sie uns ein kleines Modul erstellen, das Prozeduren für die binäre und lineare Suche nach Elementen in einem Array enthält. Modulcode:
|
1 |
Einheit Suche; |
Dieser gesamte Code sollte sich in einer separaten Datei befinden. Lassen Sie uns nun das Hauptprogramm schreiben, in das wir unser Suchmodul einbinden.
Modul (Einheit) ist eine Menge von Konstanten, Datentypen, Variablen, Prozeduren und Funktionen. Jedes Modul ähnelt einem separaten Pascal-Programm: Es kann einen Hauptteil haben, der vor dem Start Ihres Programms aufgerufen wird und die notwendige Initialisierung durchführt. Kurz gesagt, ein Modul ist eine Bibliothek von Deklarationen, die Sie in Ihr Programm einfügen können und die es Ihnen ermöglichen, das Programm in Teile zu zerlegen, die separat kompiliert werden.
Turbo Pascal gibt Ihnen Zugriff auf eine große Anzahl eingebauter Konstanten, Datentypen, Variablen, Prozeduren und Funktionen. Einige von ihnen sind spezifisch für Turbo Pascal; andere sind spezifisch für den IBM PC (und kompatible Computer) oder das MS-DOS-Betriebssystem. Ihre Anzahl ist groß, aber in Ihrem Programm verwenden Sie sie selten alle auf einmal. Daher werden sie in verwandte Gruppen unterteilt, die als Module bezeichnet werden. In diesem Fall können Sie nur die Module verwenden, die im Programm notwendig sind.
Modulstruktur
Ein Modul bietet eine Reihe von Funktionen durch Prozeduren und Funktionen, die von Konstanten, Datentypen und Variablen unterstützt werden, aber die eigentliche Implementierung dieser Funktionen ist verborgen, da das Modul in zwei Abschnitte unterteilt ist: Schnittstelle und Implementierung. Wenn ein Programm ein Modul verwendet, werden alle Moduldeklarationen für dieses Programm verfügbar, als ob sie in sich selbst definiert wären.
Der Aufbau eines Moduls ähnelt dem eines Studiengangs, es gibt jedoch einige wesentliche Unterschiede. Betrachten Sie zum Beispiel das Modul:
Einheit<идентификатор>; Schnittstelle verwendet<список модулей>; (Optional) (offene Beschreibungen) Implementierung (geschlossene Verfahrens- und Funktionsbeschreibungen) Start (Initialisierungscode) Ende.Der Modulkopf beginnt mit dem reservierten Wort unit, gefolgt vom Modulnamen (Bezeichner), genau wie bei einem Programmnamen. Das nächste Element in einem Modul ist das Interface-Schlüsselwort. Es markiert den Beginn des Schnittstellenabschnitts eines Moduls – des Abschnitts, der für alle anderen Module oder Programme sichtbar ist, die ihn verwenden.
Ein Modul kann andere Module verwenden, dazu werden sie in der uses-Klausel definiert. Die uses-Klausel folgt, falls vorhanden, unmittelbar nach dem Interface-Schlüsselwort. Beachten Sie, dass die allgemeine Regel für die Verwendung der uses-Klausel hier erfüllt ist: Wenn das Modul, dessen Name in der uses-Klausel angegeben ist, andere Module verwendet, dann müssen die Namen dieser Module auch in der uses-Klausel angegeben werden, und zwar bevor sie verwendet werden.
Standardmodule
Die Datei TURBO.TPL enthält alle Standardpakete außer Graph und den Kompatibilitätspaketen (Graph3 und Turbo3): System, Overlay, Crt, Dos und Printer. Diese Pakete werden mit Turbo Pascal in den Speicher geladen und stehen Ihnen immer zur Verfügung. Normalerweise wird die Datei TURBO.TPL im selben Verzeichnis wie TURBO.EXE (oder TPC.EXE) gespeichert. Sie können es in einem anderen Verzeichnis speichern, solange es als Turbo Pascal-Verzeichnis beschrieben wird. Verwenden Sie dazu TINST.EXE, um dieses Verzeichnis in der Datei TURBO.EXE festzulegen.
Verwendete Pakete: nein
Das System enthält alle standardmäßigen und integrierten Prozeduren und Funktionen von Turbo Pascal. Jede Subroutine von Turbo Pascal, die nicht Teil von Standard-Pascal ist und in keinem anderen Modul gefunden wird, ist in System. Dieses Modul ist allen Programmen beigefügt.
Verwendete Pakete: nein
DOS definiert zahlreiche Pascalian-Routinen und -Funktionen, die den am häufigsten verwendeten DOS-Aufrufen wie GetTime, SetTime, DiskSize usw. entsprechen. Außerdem definiert es zwei Low-Level-Programme, MsDos und Intr, mit denen Sie jeden MS-DOS-Aufruf oder Systeminterrupt aktivieren können. Registers ist der Datentyp für den Parameter in MsDos und Intr. Außerdem sind einige andere Konstanten und Datentypen definiert.
Verwendete Pakete: nein
Overlay - enthält Tools zum Erstellen von Overlay-Programmen. Das OVERKAY-Programm ist ein Programm, das nicht alles lädt, aber in Teilen.
Verwendete Pakete: nein
Crt bietet eine Reihe PC-spezifischer Beschreibungen von Konstanten, Variablen und Programmen für E/A-Operationen. Letzteres kann zum Arbeiten mit dem Bildschirm verwendet werden (Fenster einstellen, direkte Cursorsteuerung, Text- und Hintergrundfarben). Darüber hinaus können Sie "rohe" Tastatureingaben vornehmen und die Klangerzeugungskarte eines Personalcomputers steuern. Dieses Modul bietet viele Routinen, die in Version 3.0 Standard waren.
Verwendete Pakete: Crt
Das Printer-Modul definiert eine Textdateivariable, Lst, die einem Gerätetreiber zugeordnet ist, der es ermöglicht, eine Standard-Pascal-Ausgabe mit Write und Writeln an einen Drucker zu senden. Wenn Sie beispielsweise einen Drucker in Ihr Programm aufnehmen, können Sie Folgendes tun:
Write (Lst,"Summe von " ,A:4 ," und " ,B:4 ," ist gleich " ) ; C:=A+B; WriteIn(Lst,C:8) ;Verwendete Pakete: Crt
Graph3 unterstützt den vollständigen Satz von Grafikroutinen für Version 3.0 - für normale Grafiken, erweiterte Grafiken und Grafiken, die relative Befehle verwenden. Sie sind in Namen, Funktionsparametern und Routinen der Version 3.0 identisch.
Verwendete Pakete: Crt
Dieses Modul enthält zwei Variablen und mehrere Prozeduren, die von Turbo Pascal nicht mehr unterstützt werden. Dazu gehören die eingebaute Dateivariable Kbd, die boolesche Variable CBreak und die ursprünglichen Integer-Versionen von MemAvail und MaxAvail (die freien Speicher in Absätzen zurückgeben, nicht in Bytes wie die Originalversionen).
Verwendete Pakete: Crt
Graph bietet eine Reihe schneller, effizienter Grafikroutinen, mit denen Sie die Grafikfunktionen Ihres PCs voll ausnutzen können.
Dieses Modul implementiert den geräteunabhängigen Grafiktreiber von Borland zur Unterstützung von CGA-, EGA-, Hercules-, ATT 400-, MCGA-, 3270 PC- und VGA-Grafikkarten.
Schreiben Sie Ihre eigenen Module
Angenommen, Sie haben ein IntLib-Modul geschrieben, es in die INTLIB.PAS-Datei geschrieben und es auf die Festplatte übersetzt; der resultierende Code befindet sich in der INTLIB.TRU-Datei. Um dieses Modul in Ihrem Programm zu verwenden, müssen Sie eine uses-Anweisung in Ihr Programm einfügen, um dem Compiler mitzuteilen, welches Modul verwendet werden soll. So könnte Ihr Programm aussehen:
Programm MyProg; verwendet IntLib;Beachten Sie, dass Turbo Pascal davon ausgeht, dass die Datei, die das Modul enthält, denselben Namen wie das Modul selbst hat. Wenn Ihr Modulname MyUtilities ist, sucht Turbo Pascal nach einer Datei namens MYUTILIT.PAS.
Modulzusammenstellung
Ein Modul wird genauso kompiliert wie ein Programm: Es wird mit dem Editor erstellt, und dann wird der Befehl Compile / Сcompile aufgerufen (Compile / Compile) (oder die Tasten Alt-C gedrückt). Anstelle einer Datei mit der Erweiterung .EXE erstellt Turbo Pascal jedoch eine Datei mit der Erweiterung .TRU (Turbo Pascal Unit - Turbo Pascal Unit). Danach können Sie diese Datei so lassen, wie sie ist, oder sie mit TPUMOVER.EXE in TURBO.TPL einfügen.
In beiden Fällen ist es sinnvoll, die *.TRU-Dateien (zusammen mit den Quelldateien) an das Unit-Verzeichnis zu senden, das mit dem Befehl O/D/Unit directories definiert wird. Es kann nur ein Modul pro Quelldatei geben, da die Kompilierung stoppt, sobald die abschließende end-Anweisung auftritt.
Beispiel:
Lassen Sie uns ein kleines Modul schreiben. Nennen wir es IntLib und fügen zwei einfache Unterroutinen für ganze Zahlen ein - eine Prozedur und eine Funktion:
Einheit IntLib; Schnittstellenprozedur ISwap(var I,J: integer ) ; Funktion IMax(I,J: Ganzzahl ) : Ganzzahl ; Implementierungsverfahren ISwap; var Temp: Ganzzahl ; beginTemp:=I; I:=J; J:=temp end ; (Ende des ISwap-Vorgangs) Funktion IMax; start if I > J then IMax:=I else IMax:=J end ; (Ende der IMax-Funktion) Ende. (Ende des IntLib-Moduls)Wir führen diese Subroutine ein, schreiben sie in die Datei INTLIB.PAS und übersetzen sie dann auf die Festplatte. Als Ergebnis erhalten wir den Modulcode in der Datei INTLIB.TRU. Lassen Sie uns es an das Modulverzeichnis senden. Das folgende Programm verwendet das IntLib-Modul:
Programm IntTest; verwendet IntLib; varA,B: Ganzzahl ; beginnen Schreiben ( "Geben Sie zwei ganzzahlige Werte ein: ") ; Lesen(A,B) ; ISwap(A,B) ; WriteIn("A=" ,A," B=" ,B) ; schreiben ( „Der Höchstwert ist“,IMax(A,B) ) ; Ende. (Ende des IntTest-Programms)Alle Deklarationen innerhalb eines Moduls stehen in Beziehung zueinander. Beispielsweise enthält das Crt-Modul alle Beschreibungen, die für die Bildschirmroutinen auf Ihrem Personalcomputer benötigt werden.
Module in Pascal ähneln in Bezug auf den Hauptteil des Programms Subroutinen (Prozeduren und Funktionen). Per Definition handelt es sich jedoch um unabhängige Programme, deren Ressourcen in anderen Programmen verwendet werden können. Darüber hinaus erfolgt die Beschreibung von Modulen außerhalb der aufrufenden Anwendung, jedoch in einer separaten Datei, sodass ein Modul ein separat kompiliertes Programm ist. Die kompilierte Moduldatei (die Sie verwenden müssen) hat die von der Programmierumgebung bereitgestellte Erweiterung (z. B. .tpu , .ppu , .pcu).
Module werden in der Regel erstellt, um die Kompaktheit des Codes zu gewährleisten, auf die große Projekte achten müssen. Es ist auch erwähnenswert, dass die Verwendung von Modulen gewissermaßen die Einschränkung der Speichersegmentierung aufhebt, da sich der Code jedes Moduls in einem separaten Segment befindet.
Die Modulstruktur sieht wie folgt aus:
Einheit<имя модуля>; Schnittstelle<интерфейсная часть>Implementierung<исполняемая часть>Start<инициализация>Ende.
Modulname (Einheit)
Der Name des Moduls nach dem Schlüsselwort Unit muss mit dem Namen der Datei (ohne .pas) übereinstimmen, die seinen Code enthält. Außerdem wird das Modul unter Verwendung des Namens mit einem anderen Modul oder mit dem Hauptprogramm verbunden. Dazu müssen Sie das Schlüsselwort Uses angeben und die Liste der Plug-Ins durch Kommas getrennt auflisten:
Verwendet<список имен модулей>;
Schnittstellenteil (Schnittstelle)
Der Schnittstellenteil beschreibt die Header von Objekten, auf die andere Module und Programme Zugriff haben. Dies sind Konstanten, Typen, Variablen und Unterprogramme. So könnte beispielsweise der Schnittstellenteil des Suchmoduls aussehen, der Algorithmen zum Suchen nach Elementen in einem Array enthält.
Einheitssuche; Schnittstellentyp arr = Array of Integer; vars:string; Prozedur Binary_search(x: Integer; Ar: arr; var s: string); Prozedur line_search(x: integer; Ar: arr; var s: string);
Um dieses Modul zu deklarieren, müssen Sie seinen Namen im Programm angeben:
Danach können alle im Schnittstellenteil beschriebenen Objekte verwendet werden.
Ausführbarer Teil (Implementierung)
Dieser Abschnitt beginnt mit dem Wort Implementierung. Hier müssen Sie die im Schnittstellenteil deklarierten Unterprogramme beschreiben. Gleichzeitig dürfen in ihren Headern keine Formalparameter angegeben werden, da diese sonst vollständig mit denen im Schnittstellenteil übereinstimmen müssen. Außerdem kann der Schnittstellenteil Objekte enthalten, die für das Modul lokal (für das aufrufende Programm nicht zugänglich) sind.
Einleitender Teil
Der initiierende Teil beginnt seine Arbeit vor Beginn der Ausführung des Hauptprogramms. Darin (zwischen Beginn und Ende) werden in der Regel Operatoren beschrieben, die für verschiedene Arten von Hilfsarbeiten vorgesehen sind. Dieser Teil kann fehlen oder keinen Code enthalten. Im ersten Fall müssen Sie End mit einem Punkt angeben, im zweiten Fall lassen Sie ein Leerzeichen zwischen Begin und End .
Kompilieren von Modulen
Im Programm können nur kompilierte Module verwendet werden, die über eine Erweiterung verfügen, die von Ihrer Anwendungsentwicklungsumgebung bereitgestellt wird. Betrachten Sie die drei beliebtesten von ihnen:
Kompilieren von Modulen in Turbo Pascal
Das Ergebnis der Kompilierung des Moduls in TurboPascal, gibt es eine Datei mit der Erweiterung .tpu (Turbo Pascal-Einheit), die ihren Code speichert.
Kompilieren von Modulen in Free Pascal
Nach dem Kompilieren des Moduls in der Umgebung Kostenlos Pascal, werden zwei Dateien mit unterschiedlichen Berechtigungen erstellt: .ppu und .Ö. Der erste enthält den Schnittstellenteil des Moduls, der zweite (erforderlich für die Verknüpfung des Programms) den Implementierungsteil.
Kompilieren von Modulen in Pascal ABC.NET
Pascal ABC.Net generiert während der Modulkompilierung keinen Maschinensprachcode. Bei erfolgreicher Kompilierung wird der Code in einer Datei mit .pcu-Auflösung gespeichert.
Es gibt drei Kompilierungsmodi für die Programmierumgebungen Turbo Pascal und Free Pascal: Compile, Make und Build. Im Compile-Modus müssen alle im Programm verwendeten Module vorher kompiliert werden. Die Anwendung im Make-Compilation-Modus überprüft alle angeschlossenen Module auf das Vorhandensein von Dateien mit der entsprechenden Berechtigung für die Programmierumgebung (.tpu oder .o). Wenn eines davon nicht gefunden wird, wird eine Datei mit dem Namen des nicht gefundenen Moduls und der Erweiterung .pas gesucht. Der zuverlässigste der Modi ist Build. Das Suchen und Kompilieren von Dateien (mit der Erweiterung .pas) erfolgt in diesem Modus auch dann, wenn bereits Moduldateien vorhanden sind.
Beispiel: Lassen Sie uns ein kleines Modul erstellen, das Prozeduren für die binäre und lineare Suche nach Elementen in einem Array enthält. Modulcode:
Einheitssuche; Schnittstellentyp arr = Array of Integer; vars:string; Prozedur Binary_search(x: Integer; Ar: arr; var s: string); Prozedur line_search(x: integer; Ar: arr; var s: string); Implementierung var a, b, c, i: ganze Zahl; Prozedur Binary_search(x: Integer; Ar: arr; var s: string); Beginn a:=1; b:=5; s:="NEIN"; während ein<=b do
begin
c:=a+(b-a) div 2;
if (x
Dieser gesamte Code sollte sich in einer separaten Datei befinden. Lassen Sie uns nun das Hauptprogramm schreiben, in das wir unser Suchmodul einbinden.
Programm module_search; verwendet Crt, Suche; var mas: Array von ganzen Zahlen; n, j: ganze Zahl; str:string; y: Zeichen; clrscr beginnen; writeln("Geben Sie die Array-Elemente ein"); für j:=1 bis 5 do readln(mas[j]); write("Nummernsuche eingeben: "); readln(n); write("Dieses Array ist geordnet? (j/n)"); readln(y); if y="y" then binary_search(n, mas, str) else line_search(n, mas, str); schreiben (str); Schlüssel einlesen; Ende.
Nach dem Kompilieren der Dateien sollte diese Anwendung ordnungsgemäß funktionieren. Wenn Sie natürlich die Frage „Ist dieses Array bestellt?“ beantworten. Geben Sie dem Programm falsche Informationen, dann kann es in gleicher Weise reagieren.
In der Pascal-Sprache werden Bibliotheken von Subroutinen verwendet, um eine strukturierte Programmiertechnologie unter Verwendung von Modulen zu implementieren. Textlich werden Bibliotheken zu eigenständigen Programmeinheiten zusammengefasst, die als Module der Sprache Pascal bezeichnet werden. Module werden erstellt, um Bibliotheken von Routinen zu implementieren. Typischerweise kombinieren Module Unterprogramme, die Aufgaben derselben Klasse ausführen.
Modul ist eine eigenständige Programmeinheit, die selbstständig kompiliert und eine bestimmte Struktur hat.
Das Modul hat folgenden Aufbau:
Der Titel eines Pascal-Moduls besteht aus dem Dienstwort Unit gefolgt vom Namen des Moduls. Für den Modulnamen gelten strenge Anforderungen, und dieser Name muss mit dem Namen der Datenträgerdatei mit der Erweiterung .pas übereinstimmen, die den Modultext enthält.
UnitMyType; //Datei MyType.pas
Der Modulname wird verwendet, um das Modul mit Programmen und anderen Modulen zu verknüpfen. Programme und Module verlinken auf das erforderliche Modul im Uses-Abschnitt des Programms oder Moduls. Module können andere Module für ihre Arbeit aufrufen, wenn ein Modul ein anderes Modul aufruft, dann muss der Uses-Abschnitt auf das INTERFACE-Schlüsselwort folgen.
Der Schnittstellenteil der Pascal-Sprache beginnt mit dem reservierten Wort INTERFACE. Sie dient der Verknüpfung des Moduls mit dem Host-Programm oder anderen Modulen. Der Schnittstellenteil enthält die Deklaration aller globalen Objekte des Moduls. Zunächst werden Unterprogramme und darüber hinaus globale Typen und Variablen deklariert. Wird ein Objekt global deklariert, so kann es im aufrufenden Programm und Modul ohne besondere Deklaration verwendet werden.
Einheit Wassermasse;
SCHNITTSTELLE
VERWENDET MyType;
[typ_name]:[typ];
[Liste_der_globalen_Variablen]:[Typ];
Im Schnittstellenteil werden Unterprogramme durch ihre Kopfzeilen deklariert, die den Namen des Unterprogramms und eine Liste formaler Parameter enthalten.
Der ausführbare Teil der Sprache Pascal beginnt mit dem Dienstwort IMPLEMENTATION und enthält eine Beschreibung der im Schnittstellenteil deklarierten Unterprogramme, zusätzlich können im ausführbaren Teil modullokale Objekte (Variablen, Konstanten) deklariert werden. Die Beschreibung eines Unterprogramms im ausführbaren Teil muss mit dem Titel des Unterprogramms beginnen, während die Liste der formalen Parameter weggelassen wird.
Der einleitende Teil der Pascal-Sprache beendet das Modul, und dieser Teil kann fehlen oder leer sein. Es wird nicht empfohlen, den einleitenden Teil zu machen, da es zu Hängesituationen kommen kann. Es enthält ausführbare Anweisungen, setzt die Anfangswerte globaler Variablen, öffnet die erforderlichen Dateien und stellt Verknüpfungen mit anderen Dateien her.
Kompilieren von Modulen in Pascal
Wenn Sie mit Modulen arbeiten, müssen Sie die Module selbst kompilieren und Programme kompilieren, die die Module verwenden. Wie Sie wissen, gibt es in der Borland Pascal-Umgebung drei Kompilierungsmodi (Compile, Build, Make). Beim Kompilieren des Moduls selbst wird normalerweise der Compile-Modus verwendet, obwohl andere Modi verwendet werden können, wenn das Modul von anderen Modulen verwendet wird. Beim Kompilieren eines Moduls wird kein ausführbares Programm erstellt, sondern eine spezielle kompilierte Moduldatei mit der Erweiterung .tpw. Kompilierte Unit-Dateien werden in Verzeichnissen abgelegt, die normalerweise Units heißen (in den Umgebungseinstellungen angegeben). Beim Kompilieren von Programmen, die Module enthalten, können alle drei Kompilierungsmodi verwendet werden. Das Kompilieren verschiedener Modi unterscheidet sich in Dauer und Zuverlässigkeit.
Modus Kompilieren- die einfachste und schnellste. In diesem Modus sucht der Compiler im Uses-Abschnitt nach Plug-Ins und kompiliert Programme, falls diese verfügbar sind. Wenn das Modul fehlt, wird die Kompilierung angehalten und eine Meldung über das fehlende Modul angezeigt.
Im Modus Machen Der Compiler prüft das Vorhandensein von Plug-Ins, und wenn ein Modul nicht gefunden wird, sucht der Compiler nach dem Text des Moduls mit der Erweiterung .pas, kompiliert das Modul und kompiliert dann das Programm. Außerdem überprüft der Compiler die Erstellungsdaten der .tpw- und .pas-Module. Wenn es feststellt, dass das Erstellungsdatum der .pas-Datei nach dem der .tpw-Datei liegt, folgert es, dass Änderungen am Modultext vorgenommen wurden, und kompiliert die Module neu. Daher ist es zuverlässiger.
Im Modus Bauen Alle .tpw-Dateien werden ignoriert, der Compiler wird alle im Hauptprogramm verwendeten Module neu kompilieren und das Programm kompilieren. Dies ist der zuverlässigste Modus, aber gleichzeitig auch der längste.
Modul
(EINHEIT-Modul, Unit) ist eine autonom (getrennt) kompilierte Programmeinheit, die die Komponenten des Beschreibungsteils (Marken, Konstanten, Typen, Variablen, Prozeduren, Funktionen) enthält und möglicherweise auch initialisierende Teiloperatoren enthält.
Das Modul selbst ist kein ausführbares Programm, sondern soll von anderen Programmen und Modulen verwendet werden.
Modulstruktur
Das Modul hat folgenden Aufbau:
EINHEIT<
Modulname >
SCHNITTSTELLE
<
Schnittstellenabschnitt >
IMPLEMENTIERUNG
<
Abschnitt Umsetzung >
START
<
Initialisierungsabschnitt >
ENDE.
Modulkopf besteht aus einem reservierten Wort Einheit(Modul) und Modulname.
Der Name des Moduls wird nach den allgemeinen Regeln gewählt und muss mit dem Namen der Plattendatei übereinstimmen, die den Quellcode des Moduls enthält.
Erweiterung des Modulnamens (. pas
) nicht angegeben ist, wird es standardmäßig festgelegt.
Der Name des Moduls wird verwendet, um es mit einer Klausel an das Hauptprogramm zu binden Verwendet .
Angebot Verwendet m.b. nach dem Modulkopf oder hinter den Wörtern platziert
Schnittstelle und Implementierung .
Schnittstellenteil Schnittstelle(Schnittstelle, Artikulation, Verbindung) und enthält Verweise auf andere Module und Deklarationen (Beschreibungen) von globalen Objekten, d. h. Labels, Konstanten, Typen, Variablen und Kopfzeilen von Prozeduren und Funktionen, die dem Hauptprogramm und anderen Modulen (d. h. sichtbar von außen).
Abschnitt Umsetzung - beginnt mit Schlüsselwort Implementierung(Ausführung) und enthält eine Beschreibung von modullokalen Objekten, d. h. Labels, Konstanten, Typen, Variablen, die dem Hauptprogramm und anderen Modulen nicht zur Verfügung stehen (d. h. von außen nicht sichtbar sind) und eine vollständige Beschreibung von Prozeduren und Funktionen . In diesem Fall kann im Kopf von Unterprogrammen die Liste der Formalparameter stehen weggelassen, aber wenn es angegeben wird, muss es genau mit der Beschreibung im Schnittstellenteil übereinstimmen.
Abschnitt Initialisierung
- in Klammern eingeschlossen ANFANG ENDE.
und enthält Anweisungen, die ausgeführt werden, bevor die Steuerung an das Hauptprogramm übertragen wird. Das könnte sein Initialisierungsanweisungen für Daten (Variablen) Zum Beispiel Zuweisungs- und Eingabeanweisungen sowie Prozeduren zum Verknüpfen und Öffnen von Dateien. Betreiber Abschnitt kann sein. leer ANFANG ENDE oder einfach abwesend ENDE .
Am Ende des Moduls wird ein Punkt gesetzt.
Kompilieren und Verwenden von Modulen
Das RAM-System hat eine Segmentstruktur (ein Segment entspricht 64 K = 65535 Bytes). Der Programmcode kann sein nicht mehr als ein Segment, die Datenmenge darf ein Segment (es sei denn, es wird dynamischer Speicher verwendet) und ein Segment für den Stack nicht überschreiten. Die Stapelgröße wird durch die Direktive festgelegt ($M<>). Die minimale Stapelgröße beträgt standardmäßig 1 KB und die maximale Einzelsegmentgröße 16 KB. Die Werte lokaler Variablen werden beim Aufruf des Unterprogramms auf den Stack geschoben und beim Verlassen vom Stack geholt.
Der Modulcode wird in einem separaten Segment platziert, weil es wird unabhängig vom Hauptprogramm ausgestrahlt, und die Anzahl der vom Programm verwendeten Module hängt nur von dem verfügbaren OP ab. Damit können Sie umfangreiche Programme erstellen.
Der Compiler generiert Modulcode mit demselben Namen, aber Erweiterung TPU
(Turbopascal-Einheit).
Um das Modul vom Hauptprogramm oder anderen Modulen zu verwenden, wird sein Name (ohne Erweiterung) in die Vorschlagsliste aufgenommen Verwendet
Wenn das Modul kompakt und oft ist von Anwendungsprogrammen verwendet wird, kann es in die Standardmodulbibliothek gestellt werden TURBO.TPL (Turbo-Pasacal-Bibliothek )
Verwenden des Dienstprogramms TPUMOVER.
Dies sollte aber nur im Notfall erfolgen. die Bibliothek wird in das OP geladen und verringert den Speicherplatz für das Programm.
Beim Kompilieren der Datei mit dem Quellcode des Moduls erscheint eine gleichnamige Datei mit der Endung TPU
und in dem durch die Option angegebenen Verzeichnis abgelegt
OPTIONEN/VERZEICHNISSE/EINHEITENVERZEICHNISSE
oder im aktuellen Verzeichnis, wenn diese Option nicht vorhanden ist.
Beim Kompilieren des Hauptprogramms müssen die verwendeten Module verwendet werden in dem durch die Option angegebenen Verzeichnis
OPTIONEN/VERZEICHNISSE/EXE- & TPU-VERZEICHNISSE
oder im aktuellen Verzeichnis, wenn diese Option nicht vorhanden ist
Bekommen EXE Task-Datei in Option
KOMPILIEREN/ZIEL/DISK(MEMORI)
Installieren SCHEIBE
.
Es gibt drei Modi zum Kompilieren von Modulen:
- KOMPILIEREN
-BAUEN
- MACHEN
Modi per Menü eingestellt KOMPILIEREN
1.Modus KOMPILIEREN(namens Alt-F9
) . In diesem Fall wird das Programm kompiliert, und die Module sollten verwendet werden. vorkompiliert und in den entsprechenden Verzeichnissen abgelegt.
2.Modus BAUEN(namens -
F9) . In diesem Fall werden zuvor kompilierte Module ignoriert und Module mit der Erweiterung pas
und neu kompiliert.
3.Modus MACHEN(namens F9) . In diesem Fall werden nur Module mit Textänderungen neu kompiliert.
Beispiel 16.1.
Im Ordner inp.txt Es gibt drei Arrays reeller Zahlen
2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Funktion berechnen
wobei Max_a, Max_b, Max_c, Sa, Sb, Sc, ka, kb, kc das maximale Element, die Summe und die Anzahl der positiven Elemente der entsprechenden Arrays a, b und c sind.
Ausgabe des Ergebnisses in eine Datei aus.
txt
und auf dem Bildschirm.
Modultext
UNMAS;
Schnittstelle
Konstante n=10;
Geben Sie vec=Array von Real ein;
Varz:vec;
i: ganze Zahl;
f1,f2:text;
Prozedur SK1(z:vec; num:byte; Var s:real; Var k:byte);
Funktion MAX(z:vec; num:byte):real;
Implementierung
ProcedureV(s:char; num:byte;Var z:vec);
Start
Writeln("Array", s);
Für i:=1 bis num tun
Start
Lesen(f1,z[i]); Write(z[i]:4:1," ":3);
Ende;
readln(f1); Writeln;
Ende;
Prozedur SK1(z:vec;num:byte; Var s:real; Var k:byte);
Start
s:=0; k:=0;
for i:=1 to num do if z[i]>0 then
Start
s:=s+z[i];
k:=k+1
Ende;
Ende;
Funktion MAX(z:vec;num:byte):real;
varm: real;
Start
m:=z;
for i:=1 to num do if z[i]>m then m:=z[i];
MAX:=m
Ende;
Start
Assign(f1,"inp.txt"); zurücksetzen (f1);
Assign(f2,"out.txt"); Umschreiben (f2)
Ende.
Programmtext
Programm lr7_16;
Verwendet CRT,UNMAS;
Var
a,b,c:vec;
y,sa,sb,sc:real;
ka,kb,kc:Byte;
Start
clrscr;
Vv("a",8,a);
vv("b",9,b);
vv("c",n,c);
SK1(a,8,sa,ka);
SK1(b,9,sb,kb);
SK1(c,n,sc,kc);
y:=(MAX(a,8)+MAX(b,9)+MAX(c,n))+(sa+sb+sc+ka+kb+kc);
Writeln("Ergebnis:":20);
Schreiben ("Array a: ");
Writeln("sa=",sa:5:1," ka=",ka);
Write("Array b: ");
Writeln("sb=",sb:5:1," kb=",kb);
Write("Array c: ");
Writeln("sc=",sc:5:1," kc=",kc);
Writeln(" ":10,"y=",y:10);
readln;
Writeln(f2,"ђҐ§g"mv to:");
Writeln(f2," ":10,"y=",y:10);
schließen (f1);
Schließen (f2)
Ende.
Programmergebnisse
Reihe a
-2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Reihe b
2.3 -4.3 2.1 2.5 -3.7 -5.6 4.6 3.5 -7.5
Reihe c
-2.1 4.3 -2.3 7.6 4.5 -8.9 5.7 -4.5 6.8 -5.8
Ergebnis:
Reihe a: sa= 17,6 ka=4
Array b: sb= 15,0 kb=5
Reihe c: sc= 28,9 kc=5
y=9.330E+01