Moduler i Pascal, i förhållande till huvuddelen av programmet, liknar subrutiner (procedurer och funktioner). Men per definition är de oberoende program vars resurser kan användas i andra program. Dessutom förekommer beskrivningen av moduler utanför den anropande applikationen, och i separat fil, så en modul är ett separat kompilerat program. Den kompilerade modulfilen (detta är exakt vad som behövs för användning) kommer att ha tillägget som tillhandahålls av programmeringsmiljön (till exempel .tpu, .ppu, .pcu).
Moduler skapas, som regel, för att säkerställa kodkompakthet, vilket stora projekt måste oroa sig för. Det är också värt att notera att användningen av moduler på sätt och vis tar bort begränsningen för minnessegmentering, eftersom koden för varje modul är placerad i ett separat segment.
Modulstrukturen ser ut så här:
Enhet<имя модуля>; Gränssnitt<интерфейсная часть>Genomförande<исполняемая часть>Börja<инициализация>Avsluta.
Modulnamnet efter nyckelordet Unit måste matcha namnet på filen (utan .pas) där dess kod finns. Med namnet kopplas modulen också till en annan modul eller till huvudprogrammet. För att göra detta måste du ange serviceordet Uses och lista listan över plugin-program separerade med kommatecken:
Används<список имен модулей>;
Gränssnittsdelen beskriver rubrikerna för objekt som andra moduler och program kommer att ha tillgång till. Dessa är konstanter, typer, variabler och subrutiner. Så här kan till exempel gränssnittsdelen av sökmodulen se ut, som innehåller algoritmer för att söka efter element i en array.
Enhetssökning; Gränssnittstyp arr = array av heltal; var s: sträng; procedure binary_search(x: heltal; Ar: arr; var s: sträng); procedure line_search(x: heltal; Ar: arr; var s: sträng);
För att deklarera denna modul måste du ange dess namn i programmet:
Därefter kommer det att vara möjligt att använda alla objekt som beskrivs i gränssnittsdelen.
Det här avsnittet börjar med ordet Implementering. Det är här du behöver beskriva subrutinerna som deklareras i gränssnittsdelen. Samtidigt är det tillåtet att inte ange i sina titlar formella parametrar, annars måste de helt sammanfalla med dem i gränssnittsdelen. Dessutom kan gränssnittsdelen innehålla objekt som är lokala (otillgängliga för det anropande programmet) för modulen.
Initierande del
Den initierande delen börjar sitt arbete innan exekveringen av huvudprogrammet börjar. Den (mellan Begin och Slut) beskriver som regel operatörer avsedda för olika typer av hjälparbete. Denna del kan saknas eller inte innehålla någon kod. I det första fallet måste du ange End med en punkt, i det andra lämnar du tomt utrymme inuti Start och End .
Du kan bara använda kompilerade moduler i programmet som har tillägget som tillhandahålls av din applikationsutvecklingsmiljö. Låt oss titta på de tre mest populära av dem:
Resultatet av att kompilera modulen till Turbo Pascal , kommer det att finnas en fil med filtillägget .tpu (Turbo Pascal enhet), lagrar dess kod.
Efter att ha kompilerat modulen i miljön Gratis Pascal, två filer skapas med olika upplösningar: .ppu Och .o. Den första innehåller gränssnittsdelen av modulen och den andra (nödvändig för att komponera programmet) innehåller en del av implementeringarna.
Pascal ABC.Net genererar inte maskinspråkskod under modulkompilering. Om kompileringen lyckas sparas koden i en fil med permission.pcu.
Det finns tre kompileringslägen för programmeringsmiljöerna Turbo Pascal och Free Pascal: Kompilera, Skapa och Bygg. I kompileringsläge måste alla moduler som används i programmet kompileras i förväg. Applikationen i Make-kompileringsläget kontrollerar alla anslutna moduler för närvaron av filer med lämplig upplösning för programmeringsmiljön (.tpu eller .o). Om någon av dem inte hittas, söks en fil med namnet på den ohittade modulen och filtillägget .pas. Det mest tillförlitliga läget är Build. Sökning och kompilering av filer (med tillägget .pas) i detta läge sker även när modulära filer redan finns.
Exempel: låt oss skapa en liten modul som innehåller procedurer för binär och linjär sökning av element i en array. Modulkod:
Enhetssökning; Gränssnittstyp arr = array av heltal;<=b do
begin
c:=a+(b-a) div 2;
if (x
för i:=1 till 5 börjar om (Ar[i]=x) och sedan börjar s:="JA"; bryta; avsluta; avsluta; avsluta; avsluta.
All denna kod bör finnas i en separat fil. Låt oss nu skriva huvudprogrammet som vi kommer att ansluta vår sökmodul till.
Program module_search;
använder Crt, Search; var mas: array av heltal;
n, j: heltal; str:sträng;
y:char; börja clrscr; writeln("Ange arrayelementen");för j:=1 till 5 gör readln(mas[j]);
Enhet<имя модуля>write("Ange nummersökning: "); readln(n);
write("Denna array är ordnad? (y/n) "); readln(y);
om y="y" då binär_sökning(n, mas, str) annars line_search(n, mas, str);
skriv(str); läsnyckel; avsluta. Efter att ha kompilerat filerna bör det här programmet fungera korrekt. Naturligtvis, om du svarar på frågan "Är denna array beställd?" Om du förser programmet med falsk information kan det komma att svara in natura. Plug-ins. 1. Grundläggande bestämmelser Plug-in modul – en fil som innehåller källtext på Pascal-språket, med en viss struktur, avsedd att användas både i huvudprogrammet och i andra plugin-program. Användning är att inkludera en modul i användningssektionen genom att ange dess namn. 2. Allmän struktur för plug-in-modulen ; Gränssnittsimplementering slut. Om prototyper av procedurer/funktioner deklareras i detta avsnitt, måste deras implementeringar garanteras finnas i implementeringsdelen. Huvudsyfte: definierar offentliga data/funktioner för användning från ett program eller en modul som använder denna modul.Exempel på en gränssnittssektion:
Gränssnitt (plugin-program) Använder AnotherUnit; (konstanter) Konst PI=3,14159265;
E=2,71828182; (anpassade datatyper) Typ TMyType=array[-3..7] av real; (variabler) Var temp:TMyType; (procedurer och funktioner) Procedur Fill(var x:TMyType); Funktion Find(const x:TMyType; const Value:real):Boolean; Genomförande
2.2. Genomförande avsnitt. Genomförande avsnitt Huvudsyfte:– området för plugin-modulen, som börjar med nyckelordsimplementeringen och slutar med modulens brödtext (om det finns en) eller nyckelordet slutar med en prick som indikerar slutet av modulen, i vilka implementeringar av procedurer och funktioner som deklareras i gränssnittssektionen finns, vilka kan innehålla: - en lista över plugin-moduler; 1. Grundläggande bestämmelser- konstanter;- anpassade datatyper;
- variabler;
- procedurer och funktioner som är nödvändiga för att implementera de procedurer/funktioner som anges i gränssnittssektionen.
implementering av procedurer och funktioner som beskrivs i gränssnittsavsnittet.
Vid implementering av procedurer och funktioner som beskrivs i gränssnittssektionen kan deras rubriker beskrivas i förkortad form. Undantag - PascalABC: vid användning av rubrikvariabler i implementeringstexten uppstår ett kompileringsfel.
Exempel 1 (rubriker i förkortad form): Unit DemoUnit; Gränssnitt (prototyp för procedur) Procedur Swap(var a,b:integer); Byte av genomförandeprocedur; Var Temp:heltal; Start Temp:=a; Huvudsyfte: a:=b;b:=Temp; avsluta; avsluta.
Unit DemoUnit; Gränssnittskonst N=50; Var Rötter:array av verkliga; Implementering använder matematik; Var I:integer; (modulkropp) Börja För i:=1 till N gör Rötter[i]:=sqrt(i); Avsluta.
Exempel på en modul utan text: (se exempel på en modul för rubriker i full form).
1. Grundläggande bestämmelser Programkoden som finns i modulens kropp exekveras en gång - när modulen laddas, innan koden börjar köras huvudprogrammet. – en fil som innehåller källtext på Pascal-språket, med en viss struktur, avsedd att användas både i huvudprogrammet och i andra plugin-program. Användning är att inkludera en modul i användningssektionen genom att ange dess namn. I det fall flera moduler som har initialiseringssektioner är anslutna i användningssektionen, exekveras koden för dessa sektioner i den ordning som modulerna är anslutna.2.4. Ytterligare avsnitt i modulstrukturen.
Free Pascal, Pascal ABC, Pascal ABC.Net-kompilatorerna tillåter, utöver de som anges ovan, ytterligare två sektioner: - en initialiseringssektion - en finaliseringssektion. 2.4.1. Initialiseringsavsnitt. Initialiseringsavsnitt – pluginområdet placerat efter slutet av implementeringsavsnittet, som börjar med initialiseringsnyckelordet och slutar med finaliseringsavsnittet, om det finns ett, eller slutnyckelordet följt av en prick. Syftet liknar modulkroppen. 2.4.2. Avslutningssektion. Huvudsyfte: Avslutningssektion
– ett insticksområde placerat i slutet av initialiseringssektionen, om det finns en, eller i slutet av implementeringssektionen, och slutar med slutnyckelordet följt av en punkt.
1. Grundläggande bestämmelser frigöra resurser som tilldelats för moduldrift. – en fil som innehåller källtext på Pascal-språket, med en viss struktur, avsedd att användas både i huvudprogrammet och i andra plugin-program. Användning är att inkludera en modul i användningssektionen genom att ange dess namn. enhet DemoUnit; gränssnitt var a:array av ^integer;(array av pekare) implementering (minnestilldelning och initiering med värden) procedur AllocateArray; var i:integer; börja för i:=1 till 20 börjar New(a[i]);a[i]^:=i;
avsluta; avsluta; (avallokera minne) procedur DeallocateArray; var i:integer; börja för i:=1 till 20 do Dispose(a[i]); avsluta; initiering AllocateArray;(initiering - start av arbete - allokera minne) finalization DeallocateArray;(slutförande - slut på arbete - frigör minne) slut.
Programkoden som placeras i de listade avsnitten exekveras en gång. Koden för initialiseringssektionerna är före start av exekvering av huvudprogramkoden, koden för finaliseringssektionerna är efter.
Om en modul innehåller någon av dessa två sektioner är närvaron av en modulkropp inte längre tillåten.
3.2. Sammanställning i Free Pascal.
Resultatet av att kompilera en plug-in-modul i Free Pascal är två filer: *.ppu - en fil som innehåller gränssnittsdelen av modulen, och en *.o-fil - en objektfil som innehåller en del av implementeringarna. Dessutom är det senare nödvändigt för att sammanställa ansökan.
3.3. Sammanställning i Pascal ABC.Net.
Till skillnad från miljöerna som listas ovan genererar Pascal ABC.Net inte maskinspråkskod under modulkompilering. Kompilatorn av den här miljön slutför sitt arbete efter att ha utfört en semantisk analys och sparat modulens semantiska träd i ett mellanformat - *.pcu - en fil som, till en första uppskattning, kan anses vara resultatet av kompilering med de angivna begränsningarna .
3.4. Påskyndar programsammanställningen.
Vid applikationslänkningsstadiet sätter länkaren ihop en körbar modul och tar objektmoduler som indata. Alltså, efter att ha kompilerat insticksprogram, går det snabbare att kompilera program som använder dem, eftersom de redan har bearbetats. Detta gäller för Turbo och Free Pascal. Men i Pascal ABC.Net uppnås kompileringshastigheten endast på grund av att det inte finns något behov av att utföra syntaktisk och semantisk analys. Slutsats: kompilerade versioner av körbara moduler är inte kompatibla mellan olika kompilatorer.
Text
Programlista
Enhet u1; gränssnittsprocedur PrintFirst; procedur PrintFirstSecond; implementering använder u2; (<--- Раньше было в Interface } procedure PrintFirst; begin writeln("Print first"); end; procedure PrintFirstSecond; begin writeln("Print first"); PrintSecond; end; end.
Enhetär en uppsättning konstanter, datatyper, variabler, procedurer och funktioner. Varje modul liknar ett separat Pascal-program: den kan ha en huvuddel, som anropas innan du startar ditt program och utför den nödvändiga initieringen. Kort sagt är en modul ett bibliotek med definitioner som du kan infoga i ditt program och låta dig dela upp ditt program i separat kompilerade delar.
Turbo Pascal ger dig tillgång till ett stort antal inbyggda konstanter, datatyper, variabler, procedurer och funktioner. Några av dem är specifika för Turbo Pascal; andra är specifika för IBM PC (och kompatibla datorer) eller MS-DOS operativsystem. Det finns ett stort antal av dem, men du använder dem sällan alla på en gång i ditt program. Därför är de indelade i relaterade grupper som kallas moduler. I det här fallet kan du bara använda de moduler som behövs i programmet.
Modulen tillhandahåller en uppsättning faciliteter genom procedurer och funktioner som stöds av konstanter, datatyper och variabler, men själva implementeringen av dessa faciliteter är dold på grund av att modulen är uppdelad i två sektioner: gränssnitt och implementering. Om ett program använder en modul, blir alla moduldefinitioner tillgängliga för det programmet som om de var definierade i själva programmet.
Modulstrukturen liknar programstrukturen, men det finns flera betydande skillnader. Tänk till exempel på modulen:
enhet<идентификатор>; gränssnittet använder<список модулей>; (Frivillig) (öppna beskrivningar) genomförande (sluten procedur och funktionsbeskrivningar) börja (initieringskod) avsluta.Modulhuvudet börjar med den reserverade ordenheten, följt av modulnamnet (identifierare) på samma sätt som ett programnamn. Nästa element i modulen är nyckelordet för gränssnittet. Det markerar början på en moduls gränssnittssektion - den sektion som är synlig för alla andra moduler eller program som använder den.
En modul kan använda andra moduler för detta ändamål, de definieras i användningssatsen. Uses-satsen, om den finns, kommer omedelbart efter gränssnittsnyckelordet. Observera att den allmänna regeln för användning av en uses-sats gäller här: om en modul vars namn anges i uses-satsen använder andra moduler, måste namnen på dessa moduler också anges i uses-satsen, och innan de används.
TURBO.TPL-filen innehåller alla standardpaket utom Graph och kompatibilitetspaket (Graph3 och Turbo3): System, Overlay, Crt, Dos och Printer. Dessa paket laddas in i minnet tillsammans med Turbo Pascal och är alltid tillgängliga för dig. Vanligtvis lagras filen TURBO.TPL i samma katalog som TURBO.EXE (eller TPC.EXE). Du kan lagra den i en annan katalog om den beskrivs som en Turbo Pascal-katalog. För att göra detta måste du ställa in den här katalogen i filen TURBO.EXE med TINST.EXE.
Använda paket: nej
Systemet innehåller alla standard och inbyggda procedurer och funktioner för Turbo Pascal. Alla Turbo Pascal-rutiner som inte är en del av standard Pascal och inte finns i någon annan modul finns i System. Denna modul är kopplad till alla program.
Använda paket: nej
DOS definierar många Pascal-procedurer och funktioner som motsvarar de vanligaste DOS-anropen, som GetTime, SetTime, DiskSize och så vidare. Dessutom definierar den två lågnivåprogram, MsDos och Intr, som låter dig aktivera alla MS-DOS-samtal eller systemavbrott. Register representerar datatypen för parametern i MsDos och Intr. Dessutom definieras flera andra konstanter och datatyper.
Använda paket: nej
Överlägg - innehåller verktyg för att skapa överläggsprogram. OVERKAY-programmet är ett program som inte laddas helt utan i delar.
Använda paket: nej
Crt tillhandahåller en uppsättning PC-specifika beskrivningar av konstanter, variabler och program för I/O-operationer. Den senare kan användas för att arbeta med skärmen (inställningsfönster, direkt markörkontroll, text och bakgrundsfärg). Dessutom kan du tillhandahålla "rå" tangentbordsinmatning och styra ljudsignalgenereringskortet på din persondator. Denna modul innehåller många av de rutiner som var standard i version 3.0.
Använda paket: Crt
Skrivarmodulen beskriver textfilvariabeln Lst, som är associerad med en enhetsdrivrutin som gör att standard Pascal-utdata kan skickas till en utskriftsenhet med Write och Writeln. Genom att till exempel inkludera skrivare i ditt program kan du göra följande:
Skriv (Lst,"Summan av ",A:4," och ",B:4," är " ); C:=A+B; Writeln(Lst,C:8);Använda paket: Crt
Graph3 stöder en komplett uppsättning grafikrutiner för version 3.0 - för vanlig, avancerad grafik och grafik med relativa kommandon. De är identiska i namn och funktionsparametrar med rutiner i version 3.0.
Använda paket: Crt
Denna modul innehåller två variabler och flera procedurer som inte längre stöds av Turbo Pascal. Dessa inkluderar den inbyggda filvariabeln Kbd, den booleska variabeln CBreak och de ursprungliga heltalsversionerna av MemAvail och MaxAvail (som returnerar storleken på ledigt minne i stycken snarare än bytes som de verkliga versionerna gör).
Använda paket: Crt
Graph tillhandahåller en uppsättning snabba, effektiva grafikrutiner som låter dig dra full nytta av din persondators grafikfunktioner.
Denna modul implementerar en enhetsoberoende grafikdrivrutin från Borland, som låter dig stödja grafikadaptrar som CGA, EGA, Hercules, ATT 400, MCGA, 3270 PC och VGA.
Låt oss säga att du skrev en IntLib-modul, skrev den till filen INTLIВ.PAS och översatte den till disk; den resulterande koden finns i filen INTLIВ.ТRU. För att använda den här modulen i ett program måste du inkludera en uses-sats för att tala om för kompilatorn vilken modul som används. Ditt program kan se ut så här:
programmet MyProg; använder IntLib;Observera att Turbo Pascal utgår från att filen som modulen finns i har samma namn som själva modulen. Om namnet på din modul är MyUtilities, kommer Turbo Pascal att leta efter en fil som heter MYUTILIT.PAS.
Kompilera en modul
Modulen kompileras på samma sätt som ett program kompileras: den skapas med hjälp av editorn och sedan anropas kommandot Compile / Compile (eller så trycks Alt-C-tangenterna ned). Men istället för en fil med filtillägget .EXE skapar Turbo Pascal en fil med filtillägget .TRU (Turbo Pascal Unit - Turbo Pascal-modul). Efter detta kan du lämna filen som den är eller infoga den i TURBO.TPL med TPUMOVER.EXE.
I vilket fall som helst är det vettigt att överföra *.TU-filerna (tillsammans med källfilerna) till enhetskatalogen, som definieras med kommandot O/D/Unit kataloger. Det kan bara finnas en modul per källfil, eftersom kompileringen slutar så snart slutsatsen påträffas.
Exempel:
Låt oss skriva en liten modul. Låt oss kalla det IntLib och infoga två enkla subrutiner för heltal i det - en procedur och en funktion:
enhet IntLib; gränssnittsprocedur ISwap(var I,J: heltal ); funktion IMax(I,J: heltal ): heltal ; implementeringsförfarande ISwap; var Temp: heltal; börja Temp:=I; I:=J; J:=Templar slut ; (slutet på ISwap-proceduren) funktion IMax; börja om I > J då IMax:=Jag annars IMax:=J slut ; (slutet på IMax-funktionen) avsluta. (slutet på IntLib-modulen)Låt oss introducera den här subrutinen, skriva den till filen INTLIВ.PAS och sedan översätta den till disk. Som ett resultat får vi modulkoden i filen INTLIВ.ТRU. Låt oss skicka det till modulkatalogen. Nästa program använder IntLib-modulen:
programIntTest; använder IntLib; var A,B: heltal ; börjaSkriv( "Ange två heltalsvärden: "); Readln(A,B); ISwap(A,B) ; Writeln("A=" ,A," B=" ,B) ; Skrivln ( "Maximalvärdet är",IMax(A,B)); avsluta. (slutet på IntTest-programmet)Alla beskrivningar inom en modul är relaterade till varandra. Crt-modulen innehåller till exempel alla beskrivningar som behövs för rutinerna för att arbeta med skärmen på din persondator.
Abs i Pascal, returnerar det absoluta värdet av en variabel. Resultatet som returneras av Abs-funktionen har samma som argumentet - parametern som skickas till funktionen. Denna parameter kan vara av vilken numerisk datatyp som helst.
Abs-funktionssyntax för heltal:
fungera Abs(L: LongInt) : LongInt;
fungera Abs(I: Int64): Int64;
Det sista alternativet är endast möjligt för och eftersom klassiska Pascal inte har datatypen Int64.
Abs-funktionssyntax för reella tal:
fungera Abs(D: ValReal) : ValReal;
ValRealär den verkliga datatypen med det största tillgängliga värdet i en given operativsystem. I själva verket är detta ett alias (alias) av en av de utökade eller dubbla typerna.
Och nu ett exempel på användning:
Program absfunc; var x: heltal = -100;
y:heltal; börja y:= Abs(x); //y = 100 WriteLn("Abs(-100) = ", y); //Utgångar 100 ReadLn; avsluta.
Här deklarerar vi först en variabel med ett initialt värde på -100 (ett negativt tal).
Vad beräknar Abs-funktionen?
I allmänhet är Abs en förkortning för Absolute. Som du kanske kan gissa är detta ord översatt som "absolut, ren, otvivelaktig."
Du måste komma ihåg från din matematikkurs i din skola att ett absolut tal, det vill säga absolutvärdet eller modulen för ett tal x, är ett icke-negativt tal, vars definition beror på typen av tal x.
I matematik betecknas modulen för ett tal x på följande sätt: |x|.
Det vill säga, Abs-funktionen returnerar ett positivt tal i alla fall. Denna funktion är tillgänglig på nästan alla programmeringsspråk, eftersom den används ganska ofta och är en del av matematikens grunder.
Således kan vi säga att funktionen Abs(x) beräknar modulen för talet x. Det vill säga Abs(x) i Pascal är samma som |x| i matematik.
Och slutligen, låt oss skapa vår egen analog till en funktion som returnerar modulen för ett tal. Så funktionen skulle vara ungefär så här:
Funktion MyAbs(iNum: heltal): heltal; börja om iNum
Här skickar vi ett heltal till funktionen, som kan vara antingen negativt eller positivt. I funktionen kontrollerar vi värdet på detta nummer. Om talet är negativt multiplicerar vi det med -1 och får därmed ett positivt tal. Om talet är positivt gör vi ingenting - vi returnerar helt enkelt numret som tagits emot genom parametern iNum.
Som du kan se är algoritmen ganska enkel.
