Moodulid Pascalis programmi põhiosa suhtes meenutavad nad alamprogramme (protseduure ja funktsioone). Kuid definitsiooni järgi on need iseseisvad programmid, mille ressursse saab kasutada teistes programmides. Lisaks toimub moodulite kirjeldus väljaspool kutsuvat rakendust, kuid eraldi failis, seega on moodul eraldi koostatud programm. Koostatud mooduli failil (mida peate kasutama) on programmeerimiskeskkonna pakutav laiend (näiteks .tpu, .ppu, .pcu).
Moodulid luuakse reeglina koodi kompaktsuse tagamiseks, mille eest suured projektid peavad hoolitsema. Samuti väärib märkimist, et moodulite kasutamine kaotab teatud mõttes mälu segmenteerimise piirangu, kuna iga mooduli kood asub eraldi segmendis.
Mooduli struktuur näeb välja selline:
üksus<имя модуля>;
Liides
<интерфейсная часть>
Rakendamine
<исполняемая часть>
Alusta
<инициализация>
lõpp.
Mooduli nimi (ühik)
Märksõnale järgneva mooduli nimi üksus, peab ühtima selle koodi sisaldava faili nimega (ilma .pas-ta). Samuti ühendatakse moodul nime kasutades teise mooduliga ehk põhiprogrammiga. Selleks peate määrama teenindussõna kasutab ja lisage komadega eraldatud pistikprogrammide loend:
kasutab<список имен модулей>;
Liidese osa (liides)
Liidese osa kirjeldab objektide päiseid, millele teised moodulid ja programmid saavad juurdepääsu. Need on konstandid, tüübid, muutujad ja alamprogrammid. Näiteks võib selline välja näha otsingumooduli liidese osa, mis sisaldab algoritme massiivi elementide otsimiseks.
|
1 |
üksus Otsing; |
Selle mooduli deklareerimiseks peate programmis määrama selle nime:
Pärast seda on võimalik kasutada kõiki liidese osas kirjeldatud objekte.
Käivitatav osa (rakendamine)
See osa algab sõnaga Rakendamine(rakendamine). Siin peate kirjeldama liidese osas deklareeritud alamprogramme. Samal ajal on lubatud mitte määrata nende päistes formaalseid parameetreid, vastasel juhul peavad need täielikult ühtima liideseosas olevatega. Lisaks võib liidese osa sisaldada objekte, mis on mooduli jaoks lokaalsed (kutsuvale programmile ligipääsmatud).
Algav osa
Käivitusosa alustab oma tööd enne põhiprogrammi täitmise algust. Selles (alguse ja lõpu vahel) kirjeldatakse reeglina operaatoreid, mis on mõeldud mitmesugusteks abitöödeks. See osa võib puududa või selles puudub kood. Esimesel juhul peate määrama punktiga Lõpp, teisel juhul jätke Begin ja End sees tühi ruum.
Moodulite koostamine
Programmis saab kasutada ainult koostatud mooduleid, millel on teie rakenduste arenduskeskkonna pakutav laiendus. Mõelge neist kolmele kõige populaarsemale:
TurboPascal
Turbo Pascalis mooduli koostamise tulemuseks on laiendiga fail .tpu (Turbo Pascal ühik), mis salvestab selle koodi.
Tasuta Pascal
Pärast mooduli koostamist Free Pascal keskkonnas luuakse kaks erinevate õigustega faili: .ppu ja .o. Esimene sisaldab mooduli liidese osa ja teine (vajalik programmi linkimiseks) on rakendusosa.
Pascal ABC.NET
Pascal ABC.Net ei genereeri mooduli koostamise ajal masinkeelekoodi. Kui koostamine õnnestub, salvestatakse kood loaga faili .pcu.
Programmeerimiskeskkondade Turbo Pascal ja Free Pascal jaoks on kolm kompileerimisrežiimi: Kompileerida, teha ja ehitada. Kompileerimise režiimis tuleb kõik programmis kasutatavad moodulid eelnevalt kompileerida. Koostamisrežiimis olev rakendus kontrollib kõiki ühendatud mooduleid programmeerimiskeskkonna jaoks sobivate lubadega (.tpu või .o) failide olemasolu suhtes. Kui mõnda neist ei leita, siis otsitakse faili ei leitud mooduli nimega ja laiendiga .pas. Režiimidest kõige usaldusväärsem on Build. Failide otsimine ja kompileerimine (laiendiga .pas) selles režiimis toimub isegi siis, kui mooduli failid on juba olemas.
Näide
Loome väikese mooduli, mis sisaldab protseduure massiivi elementide binaarseks ja lineaarseks otsimiseks. Mooduli kood:
|
1 |
üksus Otsing; |
Kogu see kood peaks olema eraldi failis. Nüüd kirjutame põhiprogrammi, milles ühendame oma otsingumooduli.
Moodul (ühik) on konstantide, andmetüüpide, muutujate, protseduuride ja funktsioonide kogum. Iga moodul sarnaneb eraldi Pascali programmiga: sellel võib olla põhiosa, mis kutsutakse välja enne teie programmi käivitumist ja mis sooritab vajaliku lähtestamise. Lühidalt öeldes on moodul deklaratsioonide teek, mille saate oma programmi sisestada ja mis võimaldab jagada programmi osadeks, mis kompileeritakse eraldi.
Turbo Pascal annab teile juurdepääsu suurele hulgale sisseehitatud konstantidele, andmetüüpidele, muutujatele, protseduuridele ja funktsioonidele. Mõned neist on spetsiifilised Turbo Pascalile; teised on spetsiifilised IBM PC (ja ühilduvate arvutite) või MS-DOS operatsioonisüsteemi jaoks. Nende arv on suur, kuid teie programmis kasutate neid harva korraga. Seetõttu on need jagatud seotud rühmadeks, mida nimetatakse mooduliteks. Sel juhul saate kasutada ainult neid mooduleid, mis on programmis vajalikud.
Mooduli struktuur
Moodul pakub funktsioonide komplekti protseduuride ja funktsioonide kaudu, mida toetavad konstandid, andmetüübid ja muutujad, kuid nende funktsioonide tegelik rakendamine on peidetud, kuna moodul on jagatud kaheks osaks: liides ja juurutus. Kui programm kasutab moodulit, muutuvad kõik mooduli deklaratsioonid sellele programmile kättesaadavaks nii, nagu oleksid need iseenesest määratletud.
Mooduli struktuur sarnaneb programmi omaga, kuid sellel on mõned olulised erinevused. Näiteks vaadake moodulit:
üksus<идентификатор>; liides kasutab<список модулей>; (Valikuline) (avatud kirjeldused) rakendamine (suletud protseduuride ja funktsioonide kirjeldused) alustada (initsialiseerimiskood) lõpp.Mooduli päis algab reserveeritud sõnaühikuga, millele järgneb mooduli nimi (identifikaator) samamoodi nagu programmi nime puhul. Järgmine element moodulis on liidese märksõna. See tähistab mooduli liidese sektsiooni algust – osa, mis on nähtav kõigile teistele seda kasutavatele moodulitele või programmidele.
Moodul võib kasutada ka teisi mooduleid, selleks on need määratletud kasutusklauslis. Kasutamise klausel, kui see on olemas, järgneb kohe liidese märksõna järel. Pane tähele, et siin on täidetud kasutuslause kasutamise üldreegel: kui moodul, mille nimi on kasutusklauslis määratud, kasutab teisi mooduleid, siis tuleb ka nende moodulite nimed uses klauslisse määrata ja enne kasutamist.
Standardmoodulid
Fail TURBO.TPL sisaldab kõiki standardpakette, välja arvatud Graph ja ühilduvuspaketid (Graph3 ja Turbo3): System, Overlay, Crt, Dos ja Printer. Need paketid laaditakse mällu Turbo Pascaliga ja on teile alati saadaval. Tavaliselt salvestatakse fail TURBO.TPL samasse kataloogi kui TURBO.EXE (või TPC.EXE). Saate selle salvestada mõnda teise kataloogi, kui seda kirjeldatakse Turbo Pascali kataloogina. Selleks kasutage failis TURBO.EXE selle kataloogi määramiseks faili TINST.EXE.
Kasutatud paketid: nr
Süsteem sisaldab kõiki Turbo Pascali standardseid ja sisseehitatud protseduure ja funktsioone. Kõik Turbo Pascali alamprogrammid, mis ei ole standardse Pascali osa ja mida ei leidu üheski teises moodulis, sisalduvad süsteemis. See moodul on lisatud kõikidele programmidele.
Kasutatud paketid: nr
DOS määratleb arvukalt Pascaliani rutiine ja funktsioone, mis on samaväärsed kõige sagedamini kasutatavate DOS-i kõnedega, nagu GetTime, SetTime, DiskSize jne. Lisaks määratleb see kaks madala taseme programmi, MsDos ja Intr, mis võimaldavad teil aktiveerida mis tahes MS-DOS-i kõne või süsteemi katkestuse. Registrid on MsDos ja Intr parameetri andmetüüp. Lisaks on määratletud mõned muud konstandid ja andmetüübid.
Kasutatud paketid: nr
Overlay – sisaldab tööriistu ülekatteprogrammide loomiseks. OVERKAY programm on programm, mis ei lae kõike, vaid osade kaupa.
Kasutatud paketid: nr
Crt pakub arvutipõhiseid konstantide, muutujate ja programmide kirjeldusi I/O toimingute jaoks. Viimast saab kasutada ekraaniga töötamiseks (akende seadistamine, kursori otsejuhtimine, teksti- ja taustavärvid). Lisaks saab teha "toores" klaviatuurisisendi ja juhtida personaalarvuti heligeneraatori plaati. See moodul pakub palju rutiine, mis olid versioonis 3.0 standardsed.
Kasutatud paketid: Crt
Printeri moodul määratleb tekstifaili muutuja Lst, mis on seotud seadme draiveriga, mis võimaldab standardse Pascali väljundi saata printerisse, kasutades Write ja Writeln. Näiteks lisades oma programmi Printeri, saate teha järgmist.
Kirjutage (Lst,"Sum of " ,A:4 ," ja " ,B:4 ," võrdub " ) ; C:=A+B; WriteIn(Lst,C:8) ;Kasutatud paketid: Crt
Graph3 toetab täielikku graafikarutiinide komplekti versiooni 3.0 jaoks – tavalise graafika, täiustatud graafika ja suhtelisi käske kasutava graafika jaoks. Need on nime, funktsiooni parameetrite ja versiooni 3.0 rutiinide poolest identsed.
Kasutatud paketid: Crt
See moodul sisaldab kahte muutujat ja mitmeid protseduure, mida Turbo Pascal enam ei toeta. Nende hulka kuuluvad sisseehitatud failimuutuja Kbd, tõeväärtusmuutuja CBreak ning MemAvaili ja MaxAvaili algsed täisarvulised versioonid (mis tagastavad vaba mälu lõigetes, mitte baitides, nagu originaalversioonid).
Kasutatud paketid: Crt
Graph pakub kiireid ja tõhusaid graafikaprotseduure, mis võimaldavad teil oma personaalarvuti graafikavõimalusi täielikult ära kasutada.
See moodul rakendab Borlandi seadmest sõltumatut graafikadraiverit, et toetada CGA, EGA, Hercules, ATT 400, MCGA, 3270 PC ja VGA graafikaadaptereid.
Oma moodulite kirjutamine
Oletame, et kirjutasite IntLib mooduli, kirjutasite selle faili INTLIB.PAS ja tõlkisite selle kettale; saadud kood on failis INTLIB.TRU. Selle mooduli kasutamiseks oma programmis peate oma programmi lisama lause uses, mis ütleb kompilaatorile, millist moodulit kasutada. Teie programm võib välja näha selline:
programm MyProg; kasutab IntLib;Pange tähele, et Turbo Pascal eeldab, et moodulit sisaldaval failil on sama nimi, mis moodulil endal. Kui teie mooduli nimi on MyUtilities, otsib Turbo Pascal faili nimega MYUTILIT.PAS.
Mooduli koostamine
Moodul kompileeritakse täpselt samamoodi nagu programm: see luuakse redaktori abil ja seejärel kutsutakse välja käsk Compile / Сompile (Compile / Compile) (või vajutatakse Alt-C klahve). Laiendiga .EXE faili asemel loob Turbo Pascal aga faili laiendiga .TRU (Turbo Pascal Unit - Turbo Pascal Unit). Pärast seda saate jätta selle faili selliseks, nagu see on, või sisestada selle faili TURBO.TPL, kasutades TPUMOVER.EXE-i.
Mõlemal juhul on mõttekas saata *.TRU failid (koos lähtefailidega) üksuse kataloogi, mis on määratletud käsuga O/D/Unit directories. Ühe lähtefaili kohta saab olla ainult üks moodul, sest kompileerimine peatub kohe, kui tekib lõpetav lõpplause.
Näide:
Kirjutame väikese mooduli. Nimetagem seda IntLib-iks ja sisestame sellesse kaks lihtsat täisarvude alamprogrammi - protseduur ja funktsioon:
üksus IntLib; liidese protseduur ISwap(var I,J: täisarv ) ; funktsioon IMax(I,J: täisarv ) : täisarv ; rakendusprotseduur ISwap; var Temp: täisarv ; beginTemp:=I; I:=J; J:=temp lõpp ; (ISwap protseduuri lõpp) funktsioon IMax; algavad kui I > J siis IMax:=I else IMax:=J end ; (IMaxi funktsiooni lõpp) lõpp. (IntLib mooduli lõpp)Tutvustame seda alamprogrammi, kirjutame selle faili INTLIB.PAS ja tõlkime seejärel kettale. Selle tulemusena saame mooduli koodi failis INTLIB.TRU. Saadame selle moodulite kataloogi. Järgmine programm kasutab IntLib moodulit:
programm IntTest; kasutab IntLib; varA,B: täisarv ; alusta kirjutama ( "Sisestage kaks täisarvu väärtust: ") ; Readln(A,B) ; ISwap(A,B) ; WriteIn("A=" ,A," B=" ,B) ; kirjutatud ( "Maksimaalne väärtus on",IMax(A,B) ); lõpp. (IntTesti programmi lõpp)Kõik deklaratsioonid moodulis on omavahel seotud. Näiteks Crt-moodul sisaldab kõiki teie personaalarvuti ekraanirutiinide jaoks vajalikke kirjeldusi.
Pascali moodulid meenutavad programmi põhiosa suhtes alamprogramme (protseduure ja funktsioone). Kuid definitsiooni järgi on need iseseisvad programmid, mille ressursse saab kasutada teistes programmides. Lisaks toimub moodulite kirjeldus väljaspool kutsuvat rakendust, kuid eraldi failis, seega on moodul eraldi koostatud programm. Koostatud moodulifailil (mida peate kasutama) on programmeerimiskeskkonna pakutav laiend (näiteks .tpu , .ppu , .pcu).
Moodulid luuakse reeglina koodi kompaktsuse tagamiseks, mille eest suured projektid peavad hoolitsema. Samuti väärib märkimist, et moodulite kasutamine kaotab teatud mõttes mälu segmenteerimise piirangu, kuna iga mooduli kood asub eraldi segmendis.
Mooduli struktuur näeb välja selline:
üksus<имя модуля>; Liides<интерфейсная часть>Rakendamine<исполняемая часть>Alusta<инициализация>lõpp.
Mooduli nimi (ühik)
Märksõnale Unit järgnev mooduli nimi peab ühtima selle koodi sisaldava faili nimega (ilma .pas-ta). Samuti ühendatakse moodul nime kasutades teise mooduliga ehk põhiprogrammiga. Selleks peate määrama märksõna Kasutusalad ja lisama komadega eraldatud pistikprogrammide loendi:
kasutab<список имен модулей>;
Liidese osa (liides)
Liidese osa kirjeldab objektide päiseid, millele teised moodulid ja programmid saavad juurdepääsu. Need on konstandid, tüübid, muutujad ja alamprogrammid. Näiteks võib selline välja näha otsingumooduli liidese osa, mis sisaldab algoritme massiivi elementide otsimiseks.
üksuse otsing; Liidese tüüp arr = täisarvu massiiv; vars:string; protseduur binary_search(x: täisarv; Ar: arr; var s: string); protseduur line_search(x: täisarv; Ar: arr; var s: string);
Selle mooduli deklareerimiseks peate programmis määrama selle nime:
Pärast seda on võimalik kasutada kõiki liidese osas kirjeldatud objekte.
Käivitatav osa (rakendamine)
See jaotis algab sõnaga rakendamine. Siin peate kirjeldama liidese osas deklareeritud alamprogramme. Samal ajal on lubatud mitte määrata nende päistes formaalseid parameetreid, vastasel juhul peavad need täielikult ühtima liideseosas olevatega. Lisaks võib liidese osa sisaldada objekte, mis on mooduli jaoks lokaalsed (kutsuvale programmile ligipääsmatud).
Algav osa
Käivitusosa alustab oma tööd enne põhiprogrammi täitmise algust. Selles (alguse ja lõpu vahel) kirjeldatakse reeglina operaatoreid, mis on mõeldud mitmesugusteks abitöödeks. See osa võib puududa või selles puudub kood. Esimesel juhul peate määrama Lõpp punktiga, teisel juhul jätke algus ja lõpp sisse tühi ruum.
Moodulite koostamine
Programmis saab kasutada ainult koostatud mooduleid, millel on teie rakenduste arenduskeskkonna pakutav laiendus. Mõelge neist kolmele kõige populaarsemale:
moodulite koostamine Turbo Pascalis
Mooduli koostamise tulemus sisse TurboPascal, ilmub laiendiga fail .tpu (Turbo Pascal ühik), mis salvestab selle koodi.
moodulite koostamine Free Pascalis
Peale mooduli koostamist keskkonnas Tasuta Pascal, luuakse kaks erinevate õigustega faili: .ppu ja .o. Esimene sisaldab mooduli liidese osa ja teine (vajalik programmi linkimiseks) on rakendusosa.
moodulite koostamine Pascal ABC.NETis
Pascal ABC.Net ei genereeri mooduli koostamise ajal masinkeelekoodi. Kui koostamine õnnestub, salvestatakse kood .pcu eraldusvõimega faili.
Turbo Pascali ja Free Pascali programmeerimiskeskkondade jaoks on kolm kompileerimisrežiimi: kompileerimine, loomine ja koostamine. Kompileerimise režiimis tuleb kõik programmis kasutatavad moodulid eelnevalt kompileerida. Kompileerimisrežiimis olev rakendus kontrollib kõiki ühendatud mooduleid programmeerimiskeskkonna jaoks sobivate lubadega (.tpu või .o) failide olemasolu suhtes. Kui mõnda neist ei leita, siis otsitakse faili ei leitud mooduli nimega ja laiendiga .pas. Režiimidest kõige usaldusväärsem on Build. Failide otsimine ja kompileerimine (laiendiga .pas) selles režiimis toimub isegi siis, kui mooduli failid on juba olemas.
Näide: loome väikese mooduli, mis sisaldab protseduure massiivi elementide binaarseks ja lineaarseks otsimiseks. Mooduli kood:
üksuse otsing; Liidese tüüp arr = täisarvu massiiv; vars:string; protseduur binary_search(x: täisarv; Ar: arr; var s: string); protseduur line_search(x: täisarv; Ar: arr; var s: string); Teostus var a, b, c, i: täisarv; protseduur binary_search(x: täisarv; Ar: arr; var s: string); alusta a:=1; b:=5; s:="EI"; samas a<=b do
begin
c:=a+(b-a) div 2;
if (x
Kogu see kood peaks olema eraldi failis. Nüüd kirjutame põhiprogrammi, milles ühendame oma otsingumooduli.
Programmi mooduli_otsing; kasutab Crt, Search; var mas: täisarvude massiiv; n, j: täisarv; str:string; y: süsi; alustada clrscr; writeln("Sisesta massiivi elemendid"); j jaoks:=1 kuni 5 do readln(mas[j]); write("Sisesta numbriotsing: "); readln(n); write("See massiiv on järjestatud? (ja/n)"); readln(y); if y="y" siis binary_search(n, mas, str) else line_search(n, mas, str); kirjuta(str); lugemisklahv; lõpp.
Pärast failide koostamist peaks see rakendus korralikult töötama. Muidugi, kui vastate küsimusele "Kas see massiiv on järjestatud?" andke programmile valeandmeid, siis saab ta samaga vastata.
Pascali keeles kasutatakse moodulite abil struktureeritud programmeerimistehnoloogia rakendamiseks alamprogrammide teeke. Tekstiliselt ühendatakse teegid iseseisvateks programmiüksusteks, mida nimetatakse Pascali keele mooduliteks. Moodulid luuakse rutiinide teekide rakendamiseks. Tavaliselt ühendavad moodulid alamprogramme, mis täidavad sama klassi ülesandeid.
Moodul on iseseisev programmiüksus, mis kompileerib iseseisvalt ja millel on kindel struktuur.
Moodulil on järgmine struktuur:
Pascali mooduli pealkiri koosneb teenindussõnast Unit, millele järgneb mooduli nimi. Mooduli nimele kehtivad ranged nõuded ja see nimi peab ühtima kettafaili nimega .pas laiendiga, mis sisaldab mooduli teksti.
UnitMyType; //fail MyType.pas
Mooduli nime kasutatakse mooduli sidumiseks programmide ja muude moodulitega. Programmid ja moodulid lingivad programmi või mooduli jaotises Kasutamised vajalikule moodulile. Moodulid saavad oma töö jaoks kutsuda teisi mooduleid, kui moodul kutsub teist moodulit, siis peab jaotises Kasutamised järgnema märksõnale LIIDES.
Pascali keele liidese osa algab reserveeritud sõnaga INTERFACE. Seda kasutatakse mooduli sidumiseks hostprogrammi või teiste moodulitega. Liidese osa sisaldab kõigi mooduli globaalsete objektide deklaratsiooni. Esiteks deklareeritakse alamprogrammid ja lisaks globaalsed tüübid ja muutujad. Kui objekt on deklareeritud globaalselt, siis saab seda kasutada kutsuvas programmis ja moodulis ilma spetsiaalse deklaratsioonita.
Ühik veemass;
LIIDES
KASUTAB MyType'i;
[tüübi_nimi]:[tüüp];
[globaalsete_muutujate_loend]:[tüüp];
Liidese osas deklareeritakse alamprogrammid nende päistega, mis sisaldavad alamprogrammi nime ja formaalsete parameetrite loendit.
Pascali keele käivitatav osa algab teenindussõnaga IMPLEMENTATION ja sisaldab liideseosas deklareeritud alamprogrammide kirjeldust, lisaks saab käivitatavas osas deklareerida mooduli lokaalseid objekte (muutujad, konstandid). Alamprogrammi kirjeldus käivitatavas osas peab algama alamprogrammi pealkirjaga, samas kui formaalsete parameetrite loend jäetakse välja.
Pascali keele algatav osa lõpetab mooduli ja see osa võib puududa või olla tühi. Algatusosa tegemine ei ole soovitatav, kuna võib tekkida rippumisolukordi. See sisaldab käivitatavaid avaldusi, määrab globaalsete muutujate algväärtused, avab vajalikud failid ja loob lingid teiste failidega.
Moodulite koostamine Pascalis
Moodulitega töötamisel tuleb koostada moodulid ise ja koostada mooduleid kasutavad programmid. Teatavasti on Borland Pascal keskkonnas kolm kompileerimisrežiimi (Compile, Build, Make). Mooduli enda koostamisel kasutatakse tavaliselt kompileerimisrežiimi, kuigi on võimalikud ka muud režiimid, kui moodulit kasutavad teised moodulid. Mooduli koostamine ei loo käivitatavat programmi, vaid loob spetsiaalse kompileeritud mooduli faili laiendiga .tpw. Kompileeritud ühikufailid paigutatakse kataloogidesse, mille nimeks on tavaliselt Units (määratud keskkonna seadetes). Mooduleid sisaldavate programmide koostamisel saab kasutada kõiki kolme kompileerimisrežiimi. Erinevate režiimide koostamine erineb kestuse ja töökindluse poolest.
Režiim Koostada- kõige lihtsam ja kiirem. Selles režiimis kontrollib kompilaator lisandmoodulite olemasolu jaotises Kasutamised ja kompileerib programmid, kui need on olemas. Kui moodul puudub, kompileerimine peatub ja kuvatakse teade puuduva mooduli kohta.
Režiimis Tegema kompilaator kontrollib lisandmoodulite olemasolu ja kui mõnda moodulit ei leita, otsib kompilaator .pas laiendiga mooduli teksti, kompileerib mooduli ja seejärel koostab programmi. Lisaks kontrollib kompilaator .tpw ja .pas moodulite loomise kuupäevi. Kui ta leiab, et .pas-faili loomise kuupäev on hilisem kui .tpw-failil, järeldab ta, et mooduli tekstis on tehtud muudatusi, ja kompileerib moodulid uuesti. Seega on see usaldusväärsem.
Režiimis Ehitada kõiki .tpw faile eiratakse, kompilaator kompileerib uuesti kõik põhiprogrammis kasutatud moodulid ja kompileerib programmi. See on kõige usaldusväärsem režiim, kuid samal ajal pikim.
Moodul
(ÜHIK-moodul, üksus) on autonoomselt (eraldi) kompileeritud programmiüksus, mis sisaldab kirjeldusosa komponente (sildid, konstandid, tüübid, muutujad, protseduurid, funktsioonid) ja võib sisaldada ka lähtestavaid osaoperaatoreid.
Moodul ise ei ole käivitatav programm, vaid on mõeldud kasutamiseks teiste programmide ja moodulite jaoks.
Mooduli struktuur
Moodulil on järgmine struktuur:
ÜHIK<
mooduli nimi >
LIIDES
<
liidese sektsioon >
RAKENDAMINE
<
rakendamise jaotis >
ALUSTA
<
initsialiseerimise jaotis >
LÕPP.
Mooduli päis koosneb reserveeritud sõnast üksus(moodul) ja mooduli nimi.
Mooduli nimi valitakse vastavalt üldreeglitele ja see peab ühtima mooduli lähtekoodi sisaldava kettafaili nimega.
Mooduli nime laiend (. pas
) pole määratud, see on vaikimisi määratud.
Mooduli nime kasutatakse selle linkimiseks põhiprogrammiga koos klausliga kasutab .
Pakkumine kasutab m.b. asetatakse mooduli päise järele või sõnade taha
Liides ja Rakendamine .
Liidese osa Liides(liides, liigendus, ühendus) ja sisaldab viiteid muudele moodulitele ja globaalsete objektide deklaratsioonidele (kirjeldustele), st põhiprogrammile ja teistele moodulitele kättesaadavatele (st nähtavatele) protseduuride ja funktsioonide siltidele, konstantidele, tüüpidele, muutujatele ja päistele. väljast).
Rakendamise jaotis - algab märksõnaga Rakendamine(käivitamine) ja sisaldab mooduli lokaalsete objektide kirjeldust, st silte, konstante, tüüpe, muutujaid, mis pole põhiprogrammile ja teistele moodulitele kättesaadavad (st ei ole väljastpoolt nähtavad) ning protseduuride ja funktsioonide täielikku kirjeldust . Sel juhul võib alamprogrammide päises olla formaalsete parameetrite loend välja jäetud, kuid kui see on antud, peab see täpselt vastama liidese osas olevale kirjeldusele.
Initsialiseerimise jaotis
- sulgudes ALGUS LÕPP.
ja sisaldab avaldusi, mis käivitatakse enne juhtimise ülekandmist põhiprogrammi. See võib olla andmete (muutujate) initsialiseerimise operaatorid Näiteks määramis- ja sisendtehtereid, samuti failide linkimise ja avamise protseduure. Operaatorite sektsioon võib olla. tühi ALGUS LÕPP või lihtsalt puudub LÕPP .
Mooduli lõppu pannakse punkt.
Moodulite koostamine ja kasutamine
RAM-i süsteemil on segmendi struktuur (üks segment võrdub 64K = 65535 baiti). Programmi kood võib olla mitte rohkem kui üks segment, andmemaht ei tohi ületada ühte segmenti (välja arvatud juhul, kui kasutatakse dünaamilist mälu) ja ühte pinu segmenti. Virna suurus määratakse direktiiviga ($ M<>). Minimaalne virna suurus on 1K ja maksimaalne üksiku segmendi suurus on vaikimisi 16K. Kohalike muutujate väärtused lükatakse alamprogrammi kutsumisel pinu ja väljumisel hüppatakse pinust välja.
Mooduli kood paigutatakse eraldi segmenti, kuna see edastatakse autonoomselt põhiprogrammist ja programmis kasutatavate moodulite arv sõltub ainult saadaolevast OP-st. See võimaldab teil luua suuri programme.
Kompilaator genereerib sama nime, kuid laiendiga mooduli koodi tpu
(turbo Pascal üksus).
Mooduli kasutamiseks põhiprogrammis või teistes moodulites lisatakse selle nimi (ilma laiendita) soovituste loendisse kasutab
Kui moodul on kompaktne ja sageli mida kasutavad rakendusprogrammid, saab selle paigutada standardmooduliteeki TURBO.TPL (Turbo-Pasacal-raamatukogu )
utiliidi kasutades TPUMOVER.
Kuid seda tuleks teha ainult hädaolukorras. teek laaditakse OP-i ja see vähendab programmi jaoks ruumi.
Mooduli lähtekoodiga faili koostamisel ilmub laiendiga samanimeline fail tpu
ja asetatakse valikuga määratud kataloogi
VALIKUD/KATALOGID/ÜKSUSE kataloogid
või praeguses kataloogis, kui see valik puudub.
Põhiprogrammi koostamisel peavad kasutatavad moodulid olema valikuga määratud kataloogis
OPTIONS/DECTORIES/EXE & TPU kataloogid
või selle valiku puudumisel praeguses kataloogis
Saama EXEülesande fail valikus
KOMPLEERI/SIHTKOHT/KETT (MEMORI)
installida DISK
.
Moodulite koostamiseks on kolm režiimi:
- KOOSTA
- EHITA
- TEGEMA
Menüüga määratud režiimid KOOSTA
1. Režiim KOOSTA(nimetatakse Alt-F9
) . Sel juhul programm kompileeritakse ja kasutatavad moodulid peaksid olema. eelkoostatud ja salvestatud vastavatesse kataloogidesse.
2. Režiim EHITA(nimetatakse -
F9) . Sel juhul ignoreeritakse varem kompileeritud mooduleid ja laiendiga mooduleid pas
ja kompileeriti uuesti.
3. Režiim TEGEMA(nimetatakse F9) . Sel juhul kompileeritakse uuesti ainult need moodulid, mille tekstis on tehtud muudatusi.
Näide 16.1.
Failis inp.txt reaalarvude massiivi on kolm
2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Arvutusfunktsioon
kus Max_a, Max_b, Max_c, Sa, Sb, Sc, ka, kb, kc on maksimaalne element, vastavate massiivide a, b ja c positiivsete elementide summa ja arv.
Väljutage tulemus faili välja.
txt
ja ekraanil.
Mooduli tekst
UNMAS;
Liides
Const n = 10;
Tüüp vec=tõeliste massiivi;
Varz:vec;
i:täisarv;
f1,f2:tekst;
Protseduur SK1(z:vec; num:bait; Var s:real; Var k:bait);
Funktsioon MAX(z:vec; arv:bait):real;
Rakendamine
ProtseduurV(s:char; num:byte;Var z:vec);
Alusta
Writeln("Massiiv ",s);
For i:=1 to num do
Alusta
Loe(f1,z[i]); Write(z[i]:4:1," ":3);
lõpp;
readln(f1); Kirjalik;
lõpp;
Protseduur SK1(z:vec;arv:bait; Var s:real; Var k:bait);
Alusta
s:=0; k:=0;
i:=1 kuni num do, kui z[i]>0, siis
Alusta
s:=s+z[i];
k:=k+1
lõpp;
lõpp;
Funktsioon MAX(z:vec;arv:bait):real;
varm:real;
Alusta
m:=z;
kui i:=1 kuni num do, kui z[i]>m, siis m:=z[i];
MAX:=m
lõpp;
Alusta
Assign(f1"inp.txt"); lähtestamine(f1);
Assign(f2"out.txt"); Kirjuta ümber (f2)
lõpp.
Programmi tekst
Programm lr7_16;
Kasutab CRT, UNMAS;
Var
a,b,c:vec;
y,sa,sb,sc:real;
ka,kb,kc:bait;
Alusta
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("Tulemus:":20);
Write ("Massiiv a: ");
Writeln("sa=",sa:5:1," ka=",ka);
Write("Massiiv b: ");
Writeln("sb=",sb:5:1," kb=",kb);
Write("Massiiv 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);
sulge(f1);
Sule (f2)
lõpp.
Programmi tulemused
Massiiv a
-2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Massiiv b
2.3 -4.3 2.1 2.5 -3.7 -5.6 4.6 3.5 -7.5
Massiiv c
-2.1 4.3 -2.3 7.6 4.5 -8.9 5.7 -4.5 6.8 -5.8
Tulemus:
Massiiv a: sa= 17,6 ka=4
Massiiv b: sb = 15,0 kb = 5
Massiiv c: sc= 28,9 kc=5
y = 9,330E+01