Abs Gibt in Pascal den absoluten Wert einer Variablen zurück. Das von der Abs-Funktion zurückgegebene Ergebnis hat dasselbe wie das Argument – ​​den an die Funktion übergebenen Parameter. Dieser Parameter kann einen beliebigen numerischen Datentyp haben.

Abs-Funktionssyntax für ganze Zahlen:

Funktion Abs(L: LongInt) : LongInt;

Funktion Abs(I: Int64) : Int64;

Die letzte Option ist nur für und möglich, da das klassische Pascal nicht über den Datentyp Int64 verfügt.

Abs-Funktionssyntax für reelle Zahlen:

Funktion Abs(D: ValReal) : ValReal;

ValReal ist der reale Datentyp mit dem größten verfügbaren Wert auf einem bestimmten Betriebssystem. Tatsächlich handelt es sich hierbei um einen Alias ​​(Alias) eines der Typen Extended oder Double.

Und nun ein Anwendungsbeispiel:

Programm absfunc; var x: Ganzzahl = -100; y:Ganzzahl; begin y:= Abs(x); //y = 100 WriteLn("Abs(-100) = ", y); //Ausgaben 100 ReadLn; Ende.

Hier deklarieren wir zunächst eine Variable mit einem Anfangswert von -100 (einer negativen Zahl).

Und im Programm verwenden wir die Abs-Funktion und als Ergebnis ist die Variable y gleich 100 (eine positive Zahl).

Was berechnet die Abs-Funktion?

Im Allgemeinen ist Abs die Abkürzung für „Absolut“. Wie Sie vielleicht erraten haben, wird dieses Wort mit „absolut, rein, zweifellos“ übersetzt.

Das müssen Sie sich aus Ihrem Schulmathematikkurs merken absolute Zahl, das heißt, der Absolutwert oder Modul einer Zahl x ist eine nicht negative Zahl, deren Definition von der Art der Zahl x abhängt.

In der Mathematik wird der Modul einer Zahl x wie folgt bezeichnet: |x|.

Das heißt, die Abs-Funktion gibt in jedem Fall eine positive Zahl zurück. Diese Funktion ist in fast allen Programmiersprachen verfügbar, da sie recht häufig verwendet wird und zu den Grundlagen der Mathematik gehört.

Wir können also sagen, dass die Funktion Abs(x) den Modul der Zahl x berechnet. Das heißt, Abs(x) in Pascal ist dasselbe wie |x| in Mathematik.

Und schließlich erstellen wir unser eigenes Analogon einer Funktion, die den Modul einer Zahl zurückgibt. Die Funktion würde also etwa so aussehen:

Funktion MyAbs(iNum: integer) : integer; begin if iNum

Hier übergeben wir der Funktion eine Ganzzahl, die entweder negativ oder positiv sein kann. In der Funktion prüfen wir den Wert dieser Zahl. Wenn die Zahl negativ ist, multiplizieren wir sie mit -1 und erhalten so eine positive Zahl. Wenn die Zahl positiv ist, tun wir nichts – wir geben einfach die über den iNum-Parameter erhaltene Zahl zurück.

Wie Sie sehen, ist der Algorithmus recht einfach.

Es stimmt, unsere Funktion kann nur mit ganzen Zahlen arbeiten. Aber das sind Kleinigkeiten...

Einheit ist eine Menge von Konstanten, Datentypen, Variablen, Prozeduren und Funktionen. Jedes Modul ist ähnlich separates Programm in Pascal: Es kann einen Hauptteil haben, der vor der Ausführung Ihres Programms aufgerufen wird und die notwendige Initialisierung durchführt. Kurz gesagt ist ein Modul eine Bibliothek von Definitionen, die Sie in Ihr Programm einfügen können und die es Ihnen ermöglicht, Ihr Programm in separat kompilierte Teile zu unterteilen.

Turbo Pascal bietet Ihnen Zugriff auf eine große Anzahl integrierter Konstanten, Datentypen, Variablen, Prozeduren und Funktionen. Einige davon sind spezifisch für Turbo Pascal; andere sind spezifisch für persönlicher Computer IBM PC (und kompatible Computer) oder für Betriebssystem MS-DOS. Es gibt eine große Anzahl davon, Sie verwenden sie jedoch selten alle auf einmal in Ihrem Programm. Daher sind sie in verwandte Gruppen, sogenannte Module, unterteilt. In diesem Fall können Sie nur die Module verwenden, die im Programm benötigt werden.

Modulstruktur

Das Modul bietet eine Reihe von Möglichkeiten durch Prozeduren und Funktionen, die durch Konstanten, Datentypen und Variablen unterstützt werden. Die tatsächliche Implementierung dieser Möglichkeiten bleibt jedoch verborgen, da das Modul in zwei Abschnitte unterteilt ist: Schnittstelle und Implementierung. Wenn ein Programm ein Modul verwendet, werden alle Moduldefinitionen für dieses Programm verfügbar, als wären sie im Programm selbst definiert.

Der Aufbau der Module ähnelt dem Aufbau des Studiengangs, es gibt jedoch einige wesentliche Unterschiede. Betrachten Sie zum Beispiel das Modul:

Einheit<идентификатор>; Schnittstelle verwendet<список модулей>; (Optional) (Beschreibungen öffnen) Implementierung (geschlossene Prozedur- und Funktionsbeschreibungen) beginnen (Initialisierungscode) Ende.

Der Modulkopf beginnt mit dem reservierten Wort Einheit, gefolgt vom Modulnamen (Bezeichner) wie bei einem Programmnamen. Nächstes Element im Modul ist das Schlüsselwort interface. Es markiert den Anfang des Schnittstellenabschnitts eines Moduls – den Abschnitt, der für alle anderen Module oder Programme sichtbar ist, die ihn verwenden.

Ein Modul kann andere Module nutzen; zu diesem Zweck werden diese in der use-Klausel definiert. Die Verwendungsklausel steht, falls vorhanden, unmittelbar danach Stichwort Schnittstelle. Beachten Sie, dass wir hier haben allgemeine Regel Verwendung einer Uses-Klausel: Wenn ein Modul, dessen Name in der Uses-Klausel angegeben ist, andere Module verwendet, müssen die Namen dieser Module auch in der Uses-Klausel angegeben werden, und zwar vor ihrer Verwendung.

Standardmodule

Die Datei TURBO.TPL enthält alle Standardpakete außer Graph und Kompatibilitätspakete (Graph3 und Turbo3): System, Overlay, Crt, Dos und Printer. Diese Pakete werden zusammen mit Turbo Pascal in den Speicher geladen und stehen Ihnen jederzeit 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, wenn es als Turbo Pascal-Verzeichnis bezeichnet wird. Dazu müssen Sie dieses Verzeichnis in der Datei TURBO.EXE mit TINST.EXE festlegen.

Verwendete Pakete: Nein

Das System enthält alle standardmäßigen und integrierten Prozeduren und Funktionen von Turbo Pascal. Jede Turbo Pascal-Routine, die nicht Teil von Standard-Pascal ist und in keinem anderen Modul gefunden wird, ist in System enthalten. Dieses Modul ist allen Programmen beigefügt.

Verwendete Pakete: Nein

DOS definiert zahlreiche Pascal-Prozeduren und -Funktionen, die den am häufigsten verwendeten DOS-Aufrufen wie GetTime, SetTime, DiskSize usw. entsprechen. Darüber hinaus definiert es zwei Low-Level-Programme, MsDos und Intr, mit denen Sie jeden MS-DOS-Aufruf oder Systeminterrupt aktivieren können. Register stellt den Datentyp für den Parameter in MsDos und Intr dar. Darüber hinaus werden mehrere weitere Konstanten und Datentypen definiert.

Verwendete Pakete: Nein

Overlay – enthält Tools zum Erstellen von Overlay-Programmen. Das OVERKAY-Programm ist ein Programm, das nicht vollständig, sondern in Teilen geladen wird.

Verwendete Pakete: Nein

Crt bietet eine Reihe PC-spezifischer Beschreibungen von Konstanten, Variablen und Programmen für E/A-Operationen. Letzteres ermöglicht die Arbeit mit dem Bildschirm (Einstellung von Fenstern, direkte Cursorsteuerung, Text- und Hintergrundfarbe). Darüber hinaus können Sie „rohe“ Tastatureingaben bereitstellen und die Generationsplatine steuern Tonsignal persönlicher Computer. Dieses Modul stellt viele der Routinen bereit, die in Version 3.0 Standard waren.

Verwendete Pakete: Crt

Das Druckermodul stellt eine Beschreibung der Variablen bereit Textdatei Lst, das mit einem Gerätetreiber kommuniziert, der es ermöglicht, Standard-Pascal-Ausgaben mithilfe von Write und Writeln an ein Druckgerät zu senden. Wenn Sie beispielsweise Printer in Ihr Programm einbinden, können Sie Folgendes tun:

Schreiben Sie (Lst, „Die Summe von „ ,A:4“ und „ ,B:4“ ist „ ); C:=A+B; Writeln(Lst,C:8) ;

Verwendete Pakete: Crt

Graph3 unterstützt einen vollständigen Satz an Grafikroutinen für Version 3.0 – für normale, erweiterte Grafiken und Grafiken mit relativen Befehlen. Sie sind im Namen und in den Funktionsparametern mit den 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 integrierte Dateivariable Kbd, die boolesche Variable CBreak und die ursprünglichen Ganzzahlversionen von MemAvail und MaxAvail (die die Größe zurückgeben). freier Speicher in Absätzen, nicht in Bytes, wie es bei den echten Versionen der Fall ist).

Verwendete Pakete: Crt

Graph bietet eine Reihe schneller, effizienter Grafikroutinen, mit denen Sie die Grafikfunktionen Ihres PCs optimal nutzen können.

Dieses Modul implementiert einen geräteunabhängigen Grafiktreiber von Borland, der die Unterstützung von Grafikadaptern wie CGA, EGA, Hercules, ATT 400, MCGA, 3270 PC und VGA ermöglicht.

Schreiben Sie Ihre eigenen Module

Nehmen wir an, Sie haben ein IntLib-Modul geschrieben, es in die Datei INTLIВ.PAS geschrieben und auf die Festplatte übersetzt; Der resultierende Code befindet sich in der Datei INTLIВ.ТRU. Um dieses Modul in einem Programm zu verwenden, müssen Sie eine use-Anweisung einfügen, um dem Compiler mitzuteilen, welches Modul verwendet wird. Ihr Programm könnte so aussehen:

Programm MyProg; verwendet IntLib;

Beachten Sie, dass Turbo Pascal davon ausgeht, dass die Datei, in der sich das Modul befindet, denselben Namen hat wie das Modul selbst. Wenn der Name Ihres Moduls MyUtilities lautet, sucht Turbo Pascal nach einer Datei namens MYUTILIT.PAS.

Kompilieren eines Moduls

Das Modul wird auf die gleiche Weise kompiliert wie ein Programm: Es wird mit dem Editor erstellt und dann wird der Befehl „Kompilieren/Kompilieren“ aufgerufen (oder die Alt-C-Tasten gedrückt). Anstelle einer Datei mit der Erweiterung .EXE erstellt Turbo Pascal jedoch eine Datei mit der Erweiterung .TRU (Turbo Pascal Unit – Turbo Pascal-Modul). Danach können Sie diese Datei unverändert lassen oder sie mit TPUMOVER.EXE in TURBO.TPL einfügen.

In jedem Fall ist es sinnvoll, die *.TU-Dateien (zusammen mit den Quelldateien) in das Unit-Verzeichnis zu übertragen, das mit dem Befehl O/D/Unit-Verzeichnisse definiert wird. In Eins Quelldatei Es kann nur ein Modul vorhanden sein, da die Kompilierung stoppt, sobald die End-Anweisung angetroffen wird.

Beispiel:

Schreiben wir ein kleines Modul. Nennen wir es IntLib und fügen darin zwei einfache Unterroutinen für Ganzzahlen 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; begin Temp:=I; I:=J; J:=Temp Ende ; (Ende des ISwap-Vorgangs) Funktion IMax; begin if I > J then IMax:=I else IMax:=J end ; (Ende der IMax-Funktion) Ende. (Ende des IntLib-Moduls)

Lassen Sie uns diese Unterroutine vorstellen, sie in die Datei INTLIВ.PAS schreiben und sie dann auf die Festplatte übersetzen. Als Ergebnis erhalten wir den Modulcode in der Datei INTLIВ.ТRU. Senden wir es an das Modulverzeichnis. Das folgende Programm verwendet das IntLib-Modul:

programIntTest; verwendet IntLib; var A,B: Ganzzahl ; beginWrite( „Geben Sie zwei ganzzahlige Werte ein:“); Readln(A,B) ; ISwap(A,B) ; Writeln("A=" ,A," B=" ,B) ; Writeln( „Der Maximalwert beträgt“,IMax(A,B) ) ; Ende. (Ende des IntTest-Programms)

Alle Beschreibungen innerhalb eines Moduls stehen in Beziehung zueinander. Das CRT-Modul enthält beispielsweise alle Beschreibungen, die für Routinen zum Arbeiten mit dem Bildschirm Ihres PCs erforderlich sind.

Module in Pascal ähneln in Bezug auf den Hauptteil des Programms Unterprogrammen (Prozeduren und Funktionen). Aber per Definition sind sie es unabhängige Programme, deren Ressourcen in anderen Programmen genutzt werden können. Darüber hinaus werden die Module außerhalb der aufrufenden Anwendung beschrieben, jedoch in einer separaten Datei, sodass ein Modul ein separat kompiliertes Programm ist. Die kompilierte Moduldatei (dies ist genau das, was zur Verwendung benötigt wird) wird die von der Programmierumgebung bereitgestellte Erweiterung haben (z. B. .tpu, .ppu, .pcu).

Module werden in der Regel erstellt, um die Kompaktheit des Codes sicherzustellen, um die sich große Projekte kümmern müssen. Es ist auch erwähnenswert, dass durch die Verwendung von Modulen gewissermaßen die Einschränkung der Speichersegmentierung aufgehoben wird, da sich der Code für jedes Modul in einem separaten Segment befindet.

Der Modulaufbau sieht so aus:

Einheit<имя модуля>; Schnittstelle<интерфейсная часть>Implementierung<исполняемая часть>Beginnen<инициализация>Ende.

Einheitenname

Der Modulname nach dem Schlüsselwort Unit muss mit dem Namen der Datei (ohne .pas) übereinstimmen, in der sich der Code befindet. Außerdem wird das Modul über den Namen mit einem anderen Modul oder mit dem Hauptprogramm verbunden. Dazu müssen Sie das Dienstwort Uses angeben und die Liste der Plug-Ins durch Kommas getrennt auflisten:

Verwendet<список имен модулей>;

Schnittstellenteil

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 von Elementen in einem Array enthält.

Einheitensuche; Schnittstellentyp arr = Array von Ganzzahlen; var s: string; procedure Binary_search(x: integer; Ar: arr; var s: string); procedure 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.

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 formalen Parameter angegeben werden, da diese sonst vollständig mit denen im Schnittstellenteil übereinstimmen müssen. Darüber hinaus kann der Schnittstellenteil Objekte enthalten, die lokal (für das aufrufende Programm nicht zugänglich) für das Modul sind.
Einleitender Teil

Der initiierende Teil beginnt seine Arbeit, bevor die Ausführung des Hauptprogramms beginnt. Es (zwischen Begin und End) beschreibt in der Regel Operatoren, die für verschiedene Arten von Hilfsarbeiten vorgesehen sind. Dieser Teil fehlt möglicherweise oder enthält keinen Code. Im ersten Fall müssen Sie „Ende“ mit einem Punkt angeben, im zweiten Fall mit „Verlassen“. leerer Ort innerhalb von Begin und End .

Kompilieren von Modulen

Sie können im Programm nur kompilierte Module verwenden, die über die von Ihrer Anwendungsentwicklungsumgebung bereitgestellte Erweiterung verfügen. Schauen wir uns die drei beliebtesten davon an:

Kompilieren von Modulen in Turbo Pascal

Das Ergebnis der Kompilierung des Moduls Turbo Pascal, es wird eine Datei mit der Erweiterung geben .tpu (Turbo-Pascal-Einheit) und speichert seinen Code.

Kompilieren von Modulen in Free Pascal

Nach dem Kompilieren des Moduls in der Umgebung Kostenloses Pascal werden zwei Dateien mit unterschiedlichen Auflösungen erstellt: .ppu Und .Ö. Der erste enthält den Schnittstellenteil des Moduls und der zweite (notwendig zum Erstellen des Programms) enthält einen Teil der Implementierungen.

Kompilieren von Modulen in Pascal ABC.NET

Pascal ABC.Net generiert während der Modulkompilierung keinen Maschinensprachencode. Bei erfolgreicher Kompilierung wird der Code in einer Datei mit der Erlaubnis.pcu gespeichert.

Für die Programmierumgebungen Turbo Pascal und Free Pascal gibt es drei Kompilierungsmodi: Compile, Make und Build. Im Kompilierungsmodus müssen alle im Programm verwendeten Module vorab kompiliert werden. Die Anwendung im Make-Kompilierungsmodus überprüft alle angeschlossenen Module auf das Vorhandensein von Dateien mit der entsprechenden Auflösung 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 durchsucht. Der zuverlässigste Modus ist Build. Das Suchen und Kompilieren von Dateien (mit der Erweiterung .pas) in diesem Modus erfolgt auch dann, wenn bereits modulare Dateien 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:

Einheitensuche; Schnittstellentyp arr = Array von Ganzzahlen; var s: string; procedure Binary_search(x: integer; Ar: arr; var s: string); procedure line_search(x: integer; Ar: arr; var s: string); Implementierung var a, b, c, i: integer; procedure Binary_search(x: integer; Ar: arr; var s: string); begin a:=1; b:=5; s:="NEIN"; während ein<=b do begin c:=a+(b-a) div 2; if (xAr[c]) then a:=c+1 else begin s:="YES"; brechen; Ende; Ende; Ende; procedure line_search(x: integer; Ar: arr; var s: string); begin s:="NEIN"; for i:=1 to 5 do begin if (Ar[i]=x) then begin s:="YES"; brechen; Ende; Ende; Ende; Ende.

Der gesamte Code sollte sich in einer separaten Datei befinden. Schreiben wir nun das Hauptprogramm, in das wir unser Suchmodul einbinden.

Programm module_search; verwendet Crt, Suche; var mas: Array von Ganzzahlen; n, j: ganze Zahl; str:string; y:char; begin clrscr; writeln("Array-Elemente eingeben"); for j:=1 to 5 do readln(mas[j]); write("Suchnummer eingeben: "); readln(n); write("Dieses Array ist geordnet? (y/n) "); readln(y); wenn y="y" dann binäre_suche(n, mas, str) sonst line_search(n, mas, str); write(str); Schlüssel einlesen; Ende.

Nach dem Kompilieren der Dateien sollte diese Anwendung ordnungsgemäß funktionieren. Wenn Sie natürlich die Frage „Ist dieses Array geordnet?“ beantworten. Wenn Sie dem Programm falsche Informationen zur Verfügung stellen, kann es sein, dass es gleich reagiert.

Modul stellt kein ausführbares Programm dar, sondern enthält nur eine Reihe von Werkzeugen zur Verwendung in einem ausführbaren Programm: Datentypen, Variablen, Prozeduren und Funktionen. Der Quelltext des Moduls hat die Erweiterung .pas. Das Modul wird separat vom Hauptprogramm kompiliert; das kompilierte Modul hat die Erweiterung .tpu (Turbo Pascal Unit). Das fertig kompilierte Modul kann im Hauptprogramm über die use-Klausel verwendet werden, die unmittelbar nach dem Programmnamen geschrieben wird.

Turbo Pascal verfügt über Standardmodule: DOS, CRT (Kathodenstrahlröhre), Drucker, Grafik, System und andere. Sie müssen nicht beschrieben werden, können aber mit einer Uses-Klausel sofort in das Programm eingebunden werden. Das Systemmodul wird in allen Programmen verwendet, daher wurde für es eine Ausnahme gemacht; es muss nicht in die use-Klausel aufgenommen werden, es wird automatisch eingebunden. Andere Module erfordern die Aufnahme in eine Uses-Klausel, wenn das Programm Modulressourcen wie Prozeduren und Funktionen verwendet.

Modulstruktur

Das Modul hat folgenden Aufbau:
Einheit< имя >;
Schnittstelle
< интерфейсная часть >
Implementierung
< исполняемая часть >
[ Beginnen< инициирующая часть > ]
Ende.

Hier:
Einheit- Codewort (Englischmodul); Titel des Anfangsmoduls;
<имя> - Modulname (richtige Kennung);
Schnittstelle– ein Codewort, das den Schnittstellenteil des Moduls beginnt;
Implementierung- Codewort (englische Implementierung); startet den ausführbaren Teil;
Beginnen– ein Codewort, das den auslösenden Teil beginnt;
(Teil des Begin-Moduls< инициирующая часть >Optional);
Ende.- Zeichen für das Ende des Moduls.

Ein Modul besteht also aus einem Header und drei Komponenten, von denen jede leer sein kann.

Der Schnittstellenteil öffnet sich mit einem Codewort Schnittstelle. Dieser Teil enthält Deklarationen aller modulglobalen Objekte (Typen, Konstanten, Variablen und Unterroutinen), die für das Hauptprogramm und/oder andere Module verfügbar werden sollen.

Es ist zu beachten, dass alle im Schnittstellenteil des Moduls deklarierten Konstanten und Variablen sowie globale Objekte des Hauptprogramms vom Turbo-Pascal-Compiler in einem großen Datensegment platziert werden (maximale Segmentlänge 65521 Bytes).

Die Reihenfolge und Anzahl der einzelnen Anzeigenabschnitte kann beliebig sein.

Sie können im Schnittstellenteil von Modulen keine Vorwärtsbeschreibung verwenden.

Ausführbarer Teil

Der ausführbare Teil beginnt mit einem Codewort Implementierung und enthält die im Schnittstellenteil deklarierten Prozedur- und Funktionskörper. Dieser Teil kann auch für das Modul lokale Objekte deklarieren: Hilfstypen, Konstanten, Variablen und Blöcke sowie Labels, wenn sie im ersten Teil verwendet werden. Globale Prozeduren und Funktionen, die zuvor im Schnittstellenteil deklariert wurden, müssen in derselben Reihenfolge beschrieben werden, in der ihre Header im Schnittstellenteil erscheinen. Der Beschreibung eines globalen Blocks im ausführbaren Teil muss ein Header vorangestellt werden, in dem die Liste der formalen Variablen (und der Ergebnistyp für die Funktion) weggelassen werden darf, da diese bereits im Schnittstellenteil beschrieben sind.

Wenn aber der Blockheader vollständig angegeben wird, d.h. Mit einer Liste formaler Parameter und einer Ergebnisdeklaration muss es mit dem im Frontend deklarierten Header übereinstimmen.

Lokale Variablen und Konstanten sowie der gesamte Programmcode, der während der Modulkompilierung generiert wird, werden in einem gemeinsamen Speichersegment abgelegt.

Kompilieren von Modulen

Die Turbo Pascal-Umgebung umfasst Tools, die steuern, wie Module kompiliert werden, und die Entwicklung großer Softwareprojekte erleichtern. Insbesondere sind drei Kompilierungsmodi definiert: Compile, Make und Build. Die Modi unterscheiden sich nur in der Art und Weise, wie das zu kompilierende Modul oder das zu kompilierende Hauptprogramm mit anderen in der Uses-Klausel deklarierten Modulen verknüpft ist.

Beim Kompilieren eines Moduls oder Hauptprogramms im Kompilierungsmodus müssen alle in der Uses-Klausel genannten Module vorkompiliert werden und die Ergebnisse ihrer Kompilierung in gleichnamige Dateien mit der Erweiterung .TPU abgelegt werden. Wenn ein Programm (Modul) beispielsweise über eine Uses Global-Klausel verfügt, sollte sich die Datei GLOBAL.TPU bereits auf der Festplatte in dem durch die Unit-Verzeichnisse-Option deklarierten Verzeichnis befinden. Als Ergebnis der Modulkompilierung wird eine Datei mit der Erweiterung .TPU (von englisch Turbo-Pascal Unit) erstellt.

Im MAKE-Modus prüft der Compiler für jedes deklarierte Modul, ob TPU-Dateien vorhanden sind. Wenn eine der Dateien nicht gefunden wird, versucht das System, eine gleichnamige Datei mit der Erweiterung .PAS zu finden, d. h. Datei mit dem Quellcode des Moduls und beginnt mit der Kompilierung, wenn die PAS-Datei gefunden wird. Darüber hinaus überwacht das System in diesem Fall mögliche Änderungen Quellentext jedes verwendete Modul. Wenn Änderungen an der PAS-Datei (Modulquellcode) vorgenommen werden, kompiliert das System diese vor dem Kompilieren des Hauptprogramms, unabhängig davon, ob bereits eine entsprechende TPU-Datei im Verzeichnis vorhanden ist oder nicht.

Wenn außerdem Änderungen am Schnittstellenteil eines Moduls vorgenommen werden, werden auch alle anderen Module, die darauf zugreifen, neu kompiliert. Der Make-Modus vereinfacht somit den Prozess der Entwicklung großer Programme mit vielen Modulen erheblich: Der Programmierer wird von der Notwendigkeit befreit, die Übereinstimmung bestehender TPU-Dateien und deren Quelltext zu überwachen, da das System dies automatisch erledigt.

Im Build-Modus werden vorhandene TPU-Dateien ignoriert und das System versucht, die entsprechende PAS-Datei für jedes in Uses deklarierte Modul zu finden (und zu kompilieren). Nach dem Kompilieren im Build-Modus kann der Programmierer sicher sein, dass alle Änderungen, die er in einem der Module vorgenommen hat, berücksichtigt werden.

Die Anbindung von Modulen an das Hauptprogramm und deren eventuelle Kompilierung erfolgt in der Reihenfolge ihrer Deklaration in der Uses-Klausel. Beim Wechsel zum nächsten Modul sucht das System zunächst nach allen Modulen, auf die es sich bezieht. Verknüpfungen von Modulen untereinander können eine Baumstruktur beliebiger Komplexität bilden, ein expliziter oder indirekter Verweis eines Moduls auf sich selbst ist jedoch verboten.

Frage 6

Das CRT-Modul ist eine Bibliothek mit Verfahren und Beschreibungen, die die Möglichkeiten des Benutzers beim Arbeiten mit Text, dem Textbildschirm und der Tastatur erweitert. Schauen wir uns einige davon an.

1). TextMode(mode: integer) – wählt den angegebenen Textmodus aus. CRT-Modi:

2).TextBackground (Farbe: Byte) – Wählt die Hintergrundfarbe aus.

Der Farbparameter ist ein Ausdruck vom Typ Integer, zum Beispiel:

• 0- schwarz
• 1-blau
• 2-grün
• 3-blau

3). ClrScr – Bildschirmlöschung. Alle Zeichenpositionen werden mit Leerzeichen aufgefüllt. Dabei wird die aktuelle Hintergrundfarbe verwendet, die in der TextBackGround-Prozedur angegeben ist.

4). TextColor (color:byte) – Legt die Farbe der Zeichen fest. (Konstanten zum Einstellen der Farbe)

5). Window(x1,y1,x2,y2) – Definiert ein Textfenster auf dem Bildschirm. Die Parameter x1,y1 sind die Koordinaten der oberen linken Ecke des Fensters, die Parameter x2,y2 sind die Koordinaten der unteren rechten Ecke. Die Mindestgröße beträgt eine Spalte pro Zeile. Maximum - X=80, Y=25. Wenn die Koordinaten ungültig sind, wird der Aufruf der Window-Prozedur ignoriert. Standardmäßig ist das Fenster so eingestellt, dass es den gesamten Bildschirm ausfüllt.

6).GoToXY(x,y: Byte) – Positioniert den Cursor. Der Cursor bewegt sich an die Position innerhalb des aktuellen Fensters, die durch die x- und y-Koordinaten angegeben wird (x – gibt die Spalte an, y – gibt die Zeile an). Die obere linke Ecke wird durch die Koordinaten (1,1) angegeben. Beispiel: Fenster(1,10,60,20); GoToXY(1,1); Dadurch bewegt sich der Cursor zu dem Punkt mit den absoluten Koordinaten (1,10).

7).WhereX und WhereY geben die X- bzw. Y-Koordinaten für die aktuelle Cursorposition relativ zum aktuellen Fenster zurück. Ergebnistyp Byte.

8).Delay(ms: Wort) – Führt eine Verzögerung für die angegebene Anzahl von Millisekunden durch. Der Parameter msec gibt die Anzahl der zu wartenden Millisekunden an. Da es sich bei diesem Verfahren jedoch um Näherungswerte handelt, ist die Verzögerungszeit nicht genau gleich angegebene Nummer Millisekunden

9).READKey – Liest ein Zeichen von der Tastatur.

10).Sound – ist ein Vorgang, der den internen Lautsprecher einschaltet; Beschreibung: Ton(Hertz: Wort); Dabei gibt der Parameter „Hertz“ die Frequenz des erzeugten Signals in Hertz an. Der Ton ertönt, bis er durch Aufrufen der NoSound-Prozedur ausgeschaltet wird;

11).NoSound – Schaltet den internen Lautsprecher aus.

Beispiel für die Verwendung von „Sound“, „Delay“, „NoSound“.

Ton(220); (Ton einschalten)

Verzögerung(300); (300 ms warten)

Keinen Ton; (schalte den Ton aus)

Frage 7

Diagrammmodul

TP verfügt über eine ganze Reihe von Tools für die Arbeit mit einem Standard-VGA-Bildschirm.

Der VGA-Adapter hat eine Auflösung von 640 x 480 Pixel (Punkt (0,0) in der oberen linken Ecke des Bildschirms), 16 Farben.

Bevor Sie mit der Arbeit mit Grafiken beginnen, müssen Sie diese initialisieren und wenn Sie fertig sind, „schließen“. Alle grafischen Prozeduren und Funktionen befinden sich im Graph-Modul, daher ist auch dessen Anbindung erforderlich.

Allgemeine Struktur Grafikprogramm:

Verwendet crt, graph;
var Gd, Gm: Ganzzahl;
beginnen
Gd:= Erkennen;
InitGraph(Gd, Gm, "c:\bp\bgi");
...
(Hier ist der Aufbau des Bildes)
...
Schlüssel einlesen;
CloseGraph;
Ende.

Der Pfad c:\bp\bgi gibt den Speicherort der Datei egavga.bgi (Grafiktreiber) an. An verschiedene Computer Dieser Pfad kann variieren. Wenn die Datei egavga.bgi im Verzeichnis des Programms abgelegt wird, muss der Pfad nicht angegeben werden.

Grundlegende grafische Vorgehensweisen und Funktionen:

Figuren konstruieren

PutPixel(x,y,c)
- zeigt einen Punkt auf dem Bildschirm mit Koordinaten (x,y) und Farbe an c

Linie(x1,y1,x2,y2)
- zeichnet eine Linie mit dem Anfang beim Punkt (x1,y1) und dem Ende bei (x2,y2)

Rechteck(x1,y1,x2,y2)
- zeichnet den Umriss eines Rechtecks ​​mit der Diagonale (x1,y1) - (x2,y2)

Balken(x1,y1,x2,y2)
- zeichnet ein gefülltes Rechteck mit der Diagonale (x1,y1) - (x2,y2)

Kreis(x,y,r)
- Zeichnet einen Kreis mit Mittelpunkt (x,y) und Radius r

Ellipse(x,y,ba,ea,xr,yr)
- Zeichnet einen Ellipsenbogen mit Mittelpunkt bei (x,y), horizontalem und vertikalem Radius xr und yr sowie Start- und Endwinkel ba und ea

FillEllipse(x,y,xr,yr)
- zeichnet eine gefüllte Ellipse mit Mittelpunkt bei (x,y), horizontalem und vertikalem Radius xr und yr

Pascal verwendet Unterprogrammbibliotheken, um strukturierte Programmiertechnologie mithilfe von Modulen zu implementieren. Textlich werden Bibliotheken zu unabhängigen Softwareeinheiten, sogenannten Modulen, zusammengefasst Pascal-Sprache. Module werden erstellt, um Bibliotheken von Routinen zu implementieren. Typischerweise kombinieren Module Unterprogramme, die Aufgaben derselben Klasse ausführen.

Modul ist eine eigenständige Softwareeinheit, die autonom kompiliert und eine bestimmte Struktur aufweist.

Das Modul hat folgenden Aufbau:

Der Modulkopf in der Pascal-Sprache 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 Festplattendatei mit der Erweiterung .pas übereinstimmen, in der sich der Modultext befindet.

Unit MyType; //Datei MyType.pas

Der Modulname wird verwendet, um das Modul mit Programmen und anderen Modulen zu verbinden. Programme und Module stellen eine Verbindung mit dem erforderlichen Modul im Abschnitt „Verwendungen“ des Programms oder Moduls her. Module können für ihre Arbeit andere Module aufrufen; wenn ein Modul ein anderes Modul aufruft, muss der Abschnitt „Uses“ auf das INTERFACE-Dienstwort folgen.

Der Schnittstellenteil der Pascal-Sprache beginnt mit dem reservierten Wort INTERFACE. Es dient der Verbindung des Moduls mit dem Hauptprogramm 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. Wenn ein Objekt global deklariert ist, kann es im aufrufenden Programm und Modul ohne spezielle Deklaration verwendet werden.

Einheit Wodmass;

SCHNITTSTELLE

VERWENDET MyType;

[Typname]:[Typ];

[list_global_variables]:[Typ];

Im Schnittstellenteil werden Unterprogramme über ihre Header deklariert, die den Namen des Unterprogramms und eine Liste formaler Parameter enthalten.

Der ausführbare Teil der Pascal-Sprache beginnt mit dem Dienstwort IMPLEMENTATION und enthält eine Beschreibung der im Schnittstellenteil deklarierten Unterprogramme; außerdem können im ausführbaren Teil modullokale Objekte (Variablen, Konstanten) deklariert werden. Die Beschreibung eines Unterprogramms im ausführbaren Teil muss mit dem Unterprogrammtitel beginnen und die Liste der formalen Parameter wird weggelassen.

Der Pascal-Startteil beendet das Modul und dieser Teil kann fehlen oder leer sein. Es wird nicht empfohlen, den Einleitungsteil durchzuführen, da es zu Einfriersituationen kommen kann. Es enthält ausführbare Anweisungen, legt die Anfangswerte globaler Variablen fest und öffnet sich notwendigen Dateien, werden Verbindungen zu anderen Dateien hergestellt.

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 üblicherweise der Compile-Modus verwendet, es sind jedoch auch andere Modi möglich, wenn das Modul andere Module verwendet. Beim Kompilieren eines Moduls wird kein ausführbares Programm erstellt, sondern eine spezielle Datei des kompilierten Moduls mit der Erweiterung .tpw. Dateien kompilierter Module werden in Verzeichnissen abgelegt, die normalerweise Units heißen (in den Umgebungseinstellungen festgelegt). Beim Kompilieren von Programmen, die Module enthalten, können alle drei Kompilierungsmodi verwendet werden. Zusammenstellung verschiedene Modi unterscheiden sich in Haltbarkeit und Zuverlässigkeit.

Modus Kompilieren- einfach und schnell. In diesem Modus prüft der Compiler, ob Plug-in-Module im Abschnitt „Verwendungen“ vorhanden sind, und kompiliert die Programme, wenn sie vorhanden sind. Wenn ein Modul fehlt, wird die Kompilierung angehalten und eine Meldung angezeigt, dass das Modul fehlt.

Im Modus Machen Der Compiler prüft, ob Plug-Ins vorhanden sind. Wenn ein Modul nicht gefunden wird, sucht der Compiler nach dem Text des Moduls mit der Erweiterung .pas, kompiliert das Modul und dann das Programm. Darüber hinaus prüft der Compiler die Erstellungsdaten der .tpw- und .pas-Module. Wenn festgestellt wird, dass das Erstellungsdatum der .pas-Datei nach dem der .tpw-Datei liegt, schließt es daraus, dass Änderungen am Modultext vorgenommen wurden und kompiliert die Module erneut. Dies macht es zuverlässiger.

Im Modus Bauen Alle .tpw-Dateien werden ignoriert. Der Compiler kompiliert alle im Hauptprogramm verwendeten Module neu und kompiliert das Programm. Das ist das meiste zuverlässiger Modus, aber gleichzeitig auch der längste.