Moduli (KITENGO-moduli, kitengo) ni kitengo cha programu kilichoundwa kwa uhuru (kando) ambacho kina vipengee vya sehemu ya maelezo (lebo, viunga, aina, vigezo, taratibu, kazi), na pia kinaweza kuwa na waendeshaji wa sehemu ya kuanzisha.
Moduli yenyewe sio programu inayoweza kutekelezwa, lakini imekusudiwa kutumiwa na programu na moduli zingine.

Muundo wa moduli

Moduli ina muundo ufuatao:
KITENGO< jina la moduli >
INTERFACE
< sehemu ya interface >
UTEKELEZAJI
< sehemu ya utekelezaji >
ANZA
< sehemu ya uanzishaji >
MWISHO.

Kichwa cha moduli lina neno lililohifadhiwa Kitengo(moduli) na jina la moduli.

Jina la moduli huchaguliwa kulingana na sheria za jumla na lazima lifanane na jina la faili ya diski iliyo na msimbo wa chanzo wa moduli.
Ugani katika jina la moduli (. pasi ) haijabainishwa, imewekwa na chaguo-msingi.

Jina la moduli hutumiwa kuiunganisha na programu kuu kwa kutumia kifungu Matumizi .
Toa Matumizi M.B. kuwekwa baada ya kichwa cha moduli au baada ya maneno

Kiolesura Na Utekelezaji .

Sehemu ya kiolesura Kiolesura(kiolesura, matamshi, muunganisho) na ina marejeleo ya moduli na matamko mengine (maelezo) ya vitu vya kimataifa, yaani, lebo, viunganishi, aina, vigeu, na vichwa vya taratibu na vitendakazi ambavyo vinapatikana kwa programu kuu na moduli zingine (yaani zinazoonekana). kutoka nje).

Sehemu ya utekelezaji - huanza na neno kuu Utekelezaji(utekelezaji) na ina maelezo ya vitu vya ndani kwa moduli, yaani maandiko, mara kwa mara, aina, vigezo ambavyo hazipatikani kwa programu kuu na moduli nyingine (yaani hazionekani kutoka nje) na maelezo kamili ya taratibu na kazi. Katika kesi hii, katika kichwa cha subroutines kuna orodha ya vigezo rasmi. imeachwa, lakini ikiwa imetolewa, lazima ilingane kabisa na maelezo katika sehemu ya kiolesura.

Sehemu ya uanzishaji - iliyofungwa katika mabano ya maneno ANZA MWISHO.
na ina taarifa ambazo zitatekelezwa kabla ya udhibiti kuhamishiwa kwenye programu kuu. Hii inaweza kuwa data (variable) waendeshaji wa uanzishaji Kwa mfano, kazi na waendeshaji wa pembejeo, pamoja na taratibu za kuunganisha na kufungua faili. Sehemu ya waendeshaji m.b. tupu ANZA MWISHO au kutokuwepo tu MWISHO .
Kuna kipindi mwishoni mwa moduli.

Kukusanya na Kutumia Moduli

RAM ya mfumo ina muundo wa sehemu (sehemu moja ni sawa na 64K = 65535 byte). Msimbo wa programu m.b. si zaidi ya sehemu moja, kiasi cha data hakiwezi kuzidi sehemu moja (isipokuwa kumbukumbu inayobadilika itatumiwa) na sehemu moja ya rafu. Saizi ya rafu imewekwa na maagizo ($M<>) Saizi ya chini ya rafu ni 1K, kiwango cha juu cha juu cha sehemu moja ni 16K. Thamani za vigeu vya ndani husukumwa kwenye rafu wakati wa kuita utaratibu mdogo, na kuchomoza kutoka kwenye rafu wakati wa kutoka.
Nambari ya moduli imewekwa katika sehemu tofauti, kwa sababu inatafsiriwa kwa kujitegemea kutoka kwa programu kuu, na idadi ya modules zinazotumiwa na programu inategemea tu OP inapatikana. Hii inakuwezesha kuunda programu kubwa.
Mkusanyaji huunda msimbo wa moduli kwa jina moja, lakini kwa ugani tpu (kitengo cha pascal cha turbo).
Ili kutumia moduli na programu kuu au moduli zingine, jina lake (bila ugani) limewekwa kwenye orodha ya sentensi Matumizi
Ikiwa moduli ni fupi na mara nyingi m.b. inayotumiwa na programu za programu, inaweza kuwekwa kwenye maktaba ya moduli za kawaida TURBO.TPL (Turbo-Pasacal-library ) kutumia shirika TPUMOVER.
Lakini hii inapaswa kufanywa tu katika kesi ya dharura kwa sababu ... maktaba imepakiwa kwenye OP na inapunguza nafasi ya programu.
Wakati wa kuandaa faili na maandishi ya chanzo cha moduli, faili ya jina moja inaonekana na ugani tpu na imewekwa kwenye saraka iliyoainishwa na chaguo

CHAGUO/DIRECTORY/DIRECTORYES

au katika saraka ya sasa ikiwa chaguo hili halipatikani.
Wakati wa kuandaa programu kuu, moduli zinazotumiwa lazima ziwe kwenye saraka iliyoainishwa na chaguo
CHAGUO/DIRECTORIES/EXE & TPU DIRECTORIES

au kwenye saraka ya sasa ikiwa chaguo hili halipo
Kwa kupata EXE faili ya kazi katika chaguo

COMPILE/DESTINATION/DISK(MEMORI)
sakinisha DISK .
Kuna njia tatu za ujumuishaji wa moduli:
- COMPILE
- JENGA
- FANYA

Njia zimewekwa na menyu COMPILE

1. Hali COMPILE(inaitwa Alt-F9 ). Katika kesi hii, programu imeundwa na moduli zinazotumiwa lazima ziwekwe. iliyokusanywa mapema na kuhifadhiwa katika saraka zinazofaa.
2. Hali JENGA(inaitwa - F9). Katika kesi hii, moduli zilizokusanywa hapo awali hazizingatiwi, na moduli zilizo na kiendelezi hutafutwa pasi na zinakusanywa tena.
3. Hali FANYA(inaitwa F9). Katika kesi hii, moduli tu ambazo zilikuwa na mabadiliko katika maandishi zinakusanywa tena.

Mfano 16.1.

Katika faili inp.txt kuna safu tatu za nambari halisi

2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6

Tathmini utendakazi

ambapo Max_a, Max_b, Max_c, Sa, Sb, Sc, ka, kb, kc - kipengele cha juu, jumla na idadi ya vipengele vyema vya safu zinazofanana a, b, na c.
Toa matokeo kwa faili nje. txt na kwenye skrini.

Nakala ya moduli

Kitengo cha UNMAS;
Kiolesura
Const n=10;
Chapa vec=safu ya halisi;
Var z:vec;
i: nambari kamili;
f1,f2:maandishi;

Utaratibu SK1(z:vec; num:byte; Var s:real; Var k:byte);
Kazi MAX(z:vec; num:byte):real;

Utekelezaji
Utaratibu Vv(s:char; num:byte;Var z:vec);
Anza
Writeln("Array",s);
Kwa i:=1 hadi num do
Anza
Soma(f1,z[i]); Andika(z[i]:4:1," ":3);
Mwisho;
Soma(f1); Writeln;
Mwisho;

Utaratibu SK1(z:vec;num:byte; Var s:real; Var k:byte);
Anza
s:=0; k:=0;
kwa i:=1 hadi num do if z[i]>0 basi
Anza
s:=s+z[i];
k:=k+1
Mwisho;
Mwisho;
Kazi MAX(z:vec;num:byte):halisi;
Var m:halisi;
Anza
m:=z;
kwa i:=1 hadi num do if z[i]>m basi m:=z[i];
MAX:=m
Mwisho;

Anza
Agiza(f1,"inp.txt"); Weka upya(f1);
Agiza(f2,"out.txt"); Andika upya(f2)
Mwisho.

Maandishi ya programu

Mpango lr7_16;
Inatumia CRT,UNMAS;
Var
a,b,c:vec;
y,sa,sb,sc:halisi;
ka,kb,kc:baiti;
Anza
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("Matokeo:":20);
Andika("Safu a:");
Writeln("sa=",sa:5:1," ka=",ka);
Andika("Safu b:");
Writeln("sb=",sb:5:1," kb=",kb);
Andika("Safu c:");
Writeln("sc=",sc:5:1," kc=",kc);
Writeln(" ":10,"y=",y:10);
Readln;
Writeln(f2,"ђҐ§г"мв в:");
Writeln(f2," ":10,"y=",y:10);
Funga(f1);
Funga(f2)
Mwisho.

Matokeo ya programu

Safu a
-2.1 3.1 -2.4 5.6 5.4 -6.7 3.5 -3.6
Safu b
2.3 -4.3 2.1 2.5 -3.7 -5.6 4.6 3.5 -7.5
safu c
-2.1 4.3 -2.3 7.6 4.5 -8.9 5.7 -4.5 6.8 -5.8
Matokeo:
Safu a: sa= 17.6 ka=4
Mkusanyiko b: sb=15.0 kb=5
Safu c: sc= 28.9 kc=5
y= 9.330E+01

Modules katika Pascal, kuhusiana na sehemu kuu ya programu, inafanana na subroutines (taratibu na kazi). Lakini kwa ufafanuzi, ni mipango ya kujitegemea ambayo rasilimali zinaweza kutumika katika programu nyingine. Kwa kuongezea, moduli zinaelezewa nje ya programu ya kupiga simu, lakini katika faili tofauti, kwa hivyo moduli ni programu iliyokusanywa tofauti. Faili ya moduli iliyokusanywa (hii ndiyo hasa inahitajika kwa matumizi) itakuwa na ugani unaotolewa na mazingira ya programu (kwa mfano, .tpu, .ppu, .pcu).

Moduli huundwa, kama sheria, ili kuhakikisha upatanishi wa nambari, ambayo ni jambo ambalo miradi mikubwa inapaswa kuwa na wasiwasi nayo. Inafaa pia kuzingatia kuwa utumiaji wa moduli, kwa maana, huondoa kizuizi cha sehemu ya kumbukumbu, kwani nambari ya kila moduli iko katika sehemu tofauti.

Muundo wa moduli unaonekana kama hii:

Kitengo<имя модуля>; Kiolesura<интерфейсная часть>Utekelezaji<исполняемая часть>Anza<инициализация>Mwisho.

Jina la kitengo

Jina la moduli linalofuata neno kuu la Kitengo lazima lilingane na jina la faili (bila .pas) ambamo msimbo wake unapatikana. Pia, kwa kutumia jina, moduli imeunganishwa na moduli nyingine, au kwa programu kuu. Ili kufanya hivyo, unahitaji kutaja neno la huduma Matumizi, na kuorodhesha orodha ya programu-jalizi iliyotenganishwa na koma:

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

Sehemu ya kiolesura

Sehemu ya kiolesura inaelezea vichwa vya vitu ambavyo moduli na programu zingine zitapata ufikiaji. Hizi ni mara kwa mara, aina, vigezo na subroutines. Kwa mfano, hivi ndivyo sehemu ya kiolesura cha moduli ya Utafutaji inavyoweza kuonekana, iliyo na algoriti za kutafuta vipengele katika safu.

Utafutaji wa Kitengo; Aina ya kiolesura arr = safu ya nambari kamili; var s: kamba; utaratibu binary_search(x: integer; Ar: arr; var s: string); utafutaji_wa_utaratibu(x: nambari kamili; Ar: arr; var s: kamba);

Ili kutangaza moduli hii, unahitaji kutaja jina lake katika programu:

Baada ya hapo itawezekana kutumia vitu vyote vilivyoelezwa kwenye sehemu ya interface.

Utekelezaji

Sehemu hii inaanza na neno Utekelezaji. Hapa ndipo unahitaji kuelezea subroutines zilizotangazwa katika sehemu ya kiolesura. Wakati huo huo, inaruhusiwa kutoonyesha vigezo rasmi katika vichwa vyao, vinginevyo lazima sanjari kabisa na wale walio katika sehemu ya interface. Kwa kuongeza, sehemu ya kiolesura inaweza kuwa na vitu ambavyo ni vya ndani (haviwezi kufikiwa na programu ya kupiga simu) kwa moduli.
Sehemu ya kuanzishwa

Sehemu ya kuanzisha huanza kazi yake kabla ya utekelezaji wa programu kuu kuanza. Ni (kati ya Anza na Mwisho), kama sheria, inaelezea waendeshaji waliokusudiwa kwa aina anuwai za kazi za usaidizi. Sehemu hii inaweza kukosa au haina msimbo wowote. Katika kesi ya kwanza, unahitaji kutaja Mwisho na dot, kwa pili, kuondoka nafasi tupu ndani Anza na Mwisho .

Kuandaa moduli

Unaweza tu kutumia moduli zilizokusanywa katika programu ambazo zina kiendelezi kilichotolewa na mazingira yako ya usanidi wa programu. Wacha tuangalie tatu maarufu zaidi kati yao:

kuandaa moduli katika Turbo Pascal

Matokeo ya kuandaa moduli kuwa Turbo Pascal, kutakuwa na faili iliyo na kiendelezi .tpu (Kitengo cha Turbo Pascal), kuhifadhi msimbo wake.

kuandaa moduli katika Pascal ya Bure

Baada ya kuandaa moduli katika mazingira Bure Pascal, faili mbili zinaundwa na maazimio tofauti: .ppu Na .o. Ya kwanza ina sehemu ya kiolesura cha moduli, na ya pili (muhimu kwa ajili ya kutunga programu) ina sehemu ya utekelezaji.

kuandaa moduli katika Pascal ABC.NET

Pascal ABC.Net haitoi msimbo wa lugha ya mashine wakati wa uundaji wa moduli. Ukusanyaji ukifaulu, msimbo huhifadhiwa katika faili yenye permit.pcu.

Kuna njia tatu za ujumuishaji wa mazingira ya programu ya Turbo Pascal na Bure ya Pascal: Kusanya, Tengeneza na Unda. Katika hali ya Kukusanya, moduli zote zinazotumiwa katika programu lazima zijumuishwe mapema. Programu katika modi ya Ukusanyaji hukagua moduli zote zilizounganishwa kwa uwepo wa faili zilizo na azimio linalofaa kwa mazingira ya programu (.tpu au .o). Ikiwa yeyote kati yao haipatikani, basi faili hutafutwa kwa jina la moduli isiyopatikana na ugani .pas. Njia ya kuaminika zaidi ni Jenga. Kutafuta na kukusanya faili (kwa kiendelezi cha .pas) katika hali hii hutokea hata wakati faili za moduli tayari zipo.

Mfano: wacha tuunde moduli ndogo iliyo na taratibu za utafutaji wa binary na mstari wa vipengele katika safu. Msimbo wa moduli:

Utafutaji wa Kitengo; Aina ya kiolesura arr = safu ya nambari kamili; var s: kamba; utaratibu binary_search(x: integer; Ar: arr; var s: string); utafutaji_wa_utaratibu(x: nambari kamili; Ar: arr; var s: kamba); Utekelezaji var a, b, c, i: integer; utaratibu binary_search(x: integer; Ar: arr; var s: string); anza a:=1; b:=5; s:="NO"; wakati a<=b do begin c:=a+(b-a) div 2; if (xAr[c]) kisha a:=c+1 mwingine anza s:="NDIYO"; mapumziko; mwisho; mwisho; mwisho; utafutaji_wa_utaratibu(x: nambari kamili; Ar: arr; var s: kamba); anza s:="NO"; kwa i:=1 hadi 5 huanza ikiwa (Ar[i]=x) kisha anza s:="NDIYO"; mapumziko; mwisho; mwisho; mwisho; mwisho.

Nambari hii yote inapaswa kuwa katika faili tofauti. Sasa hebu tuandike programu kuu ambayo tutaunganisha moduli yetu ya Utafutaji.

Utafutaji wa moduli ya programu; hutumia Crt, Tafuta; var mas: safu ya nambari kamili; n, j: nambari kamili; str:kamba; y:char; anza clrscr; writeln("Ingiza vitu vya safu"); kwa j:=1 hadi 5 fanya readln(mas[j]); andika ("Ingiza utaftaji wa nambari:"); readln(n); andika ("Safu hii imeagizwa? (y/n) "); readln(y); ikiwa y="y" basi binary_search(n, mas, str) vinginevyo line_search(n, mas, str); andika (str); ufunguo wa kusoma; mwisho.

Baada ya kukusanya faili, programu tumizi hii inapaswa kufanya kazi vizuri. Kwa kweli, ukijibu swali "Je, safu hii imeagizwa?" Ikiwa utaipatia programu habari ya uwongo, inaweza kujibu kwa njia fulani.

Moduli haiwakilishi programu inayoweza kutekelezwa, lakini ina tu seti ya zana za matumizi katika programu inayoweza kutekelezwa: aina za data, vigezo, taratibu na kazi. Maandishi chanzo cha moduli yana kiendelezi .pas. Moduli imeundwa tofauti na programu kuu; Moduli iliyokamilishwa inaweza kutumika katika programu kuu kwa kutumia kifungu cha matumizi, ambacho kimeandikwa mara baada ya jina la programu.

Turbo Pascal ina moduli za kawaida: DOS, CRT (Cathode Ray Tube), Printer, Graph, System na wengine. Hazihitaji kuelezewa, lakini zinaweza kujumuishwa mara moja kwenye programu na kifungu cha matumizi. Moduli ya Mfumo hutumiwa katika programu zote, hivyo ubaguzi umefanywa kwa ajili yake hauhitaji kuingizwa katika kifungu cha matumizi, itajumuishwa moja kwa moja. Moduli zingine zinahitaji kujumuishwa katika kifungu cha matumizi ikiwa programu itatumia rasilimali za moduli, kama vile taratibu na utendakazi.

Muundo wa moduli

Moduli ina muundo ufuatao:
Kitengo< имя >;
Kiolesura
< интерфейсная часть >
Utekelezaji
< исполняемая часть >
[Anza< инициирующая часть > ]
Mwisho.

Hapa:
Kitengo- neno la kificho (moduli ya Kiingereza); kichwa cha moduli ya mwanzo;
<имя> - jina la moduli (kitambulisho sahihi);
Kiolesura- neno la kificho linaloanza sehemu ya interface ya moduli;
Utekelezaji- neno la kificho (utekelezaji wa Kiingereza); huanza sehemu inayoweza kutekelezwa;
Anza- neno la kificho ambalo huanza sehemu ya kuanzisha;
(sehemu ya moduli ya Anza< инициирующая часть >hiari);
Mwisho.- ishara ya mwisho wa moduli.

Kwa hivyo, moduli ina kichwa na vipengele vitatu, yoyote ambayo inaweza kuwa tupu.

Sehemu ya kiolesura inafungua na neno la kificho Kiolesura. Sehemu hii ina matamko ya moduli zote za vipengee vya kimataifa (aina, vibadilishio, viambajengo na subroutines) ambavyo vinapaswa kupatikana kwa programu kuu na/au moduli zingine.

Ikumbukwe kwamba vipengele vyote na vigezo vilivyotangazwa katika sehemu ya interface ya moduli, pamoja na vitu vya kimataifa vya programu kuu, vimewekwa na mkusanyaji wa Turbo-Pascal katika sehemu kubwa ya data (urefu wa sehemu ya juu 65521 bytes).

Mpangilio ambao sehemu mbalimbali za matangazo huonekana na idadi yao inaweza kuwa ya kiholela.

Huwezi kutumia maelezo ya mbele katika sehemu ya kiolesura cha moduli.

Sehemu inayoweza kutekelezwa

Sehemu inayoweza kutekelezwa huanza na neno la msimbo Utekelezaji na ina miili ya taratibu na kazi zilizotangazwa katika sehemu ya kiolesura. Sehemu hii inaweza pia kutangaza vitu vya ndani kwa moduli: aina za wasaidizi, mara kwa mara, vigezo na vitalu, pamoja na maandiko ikiwa hutumiwa katika sehemu ya awali. Taratibu za kimataifa na utendakazi zilizotangazwa hapo awali katika sehemu ya kiolesura lazima zifafanuliwe kwa mlolongo ule ule ambao vichwa vyake huonekana katika sehemu ya kiolesura. Ufafanuzi wa kizuizi cha kimataifa katika sehemu inayoweza kutekelezwa lazima itanguliwe na kichwa ambacho inaruhusiwa kuacha orodha ya vigezo rasmi (na aina ya matokeo ya kazi), kwa kuwa tayari imeelezwa katika sehemu ya interface.

Lakini ikiwa kichwa cha kuzuia kinatolewa kwa ukamilifu, i.e. na orodha ya vigezo rasmi na tamko la matokeo, lazima lifanane na kichwa kilichotangazwa katika sehemu ya mbele.

Vigezo vya mitaa na vipengele, pamoja na msimbo wote wa programu unaozalishwa wakati wa mkusanyiko wa moduli, huwekwa kwenye sehemu ya kumbukumbu ya kawaida.

Kuandaa moduli

Mazingira ya Turbo Pascal yanajumuisha zana zinazodhibiti jinsi moduli zinavyotungwa na kuwezesha uundaji wa miradi mikubwa ya programu. Hasa, njia tatu za ujumuishaji zinafafanuliwa: Kusanya, Tengeneza, na Unda Njia hutofautiana tu kwa jinsi moduli inavyotungwa au programu kuu inayotungwa inahusishwa na moduli zingine zilizotangazwa katika kifungu cha Matumizi.

Wakati wa kuandaa moduli au programu kuu katika modi ya Kukusanya, moduli zote zilizotajwa katika kifungu cha Matumizi lazima ziwe zimekusanywa na matokeo ya mkusanyo wao lazima yawekwe kwenye faili za jina moja na kiendelezi cha .TPU. Kwa mfano, ikiwa programu (moduli) ina kifungu cha Matumizi ya Ulimwenguni, basi faili ya GLOBAL.TPU inapaswa kuwa tayari iko kwenye diski katika saraka iliyotangazwa na chaguo la saraka za Kitengo. Faili yenye kiendelezi .TPU (kutoka Kiingereza Turbo-Pascal Unit) imeundwa kutokana na mkusanyiko wa moduli.

Katika hali ya MAKE, mkusanyaji huangalia uwepo wa faili za TPU kwa kila moduli iliyotangazwa. Ikiwa faili yoyote haipatikani, mfumo unajaribu kupata faili ya jina moja na ugani wa .PAS, i.e. faili na msimbo wa chanzo wa moduli, na, ikiwa faili ya PAS inapatikana, huanza kuitayarisha. Kwa kuongeza, katika kesi hii, mfumo unafuatilia mabadiliko iwezekanavyo kwa msimbo wa chanzo wa moduli yoyote inayotumiwa. Ikiwa mabadiliko yoyote yanafanywa kwa faili ya PAS (msimbo wa chanzo cha moduli), basi bila kujali ikiwa tayari kuna faili inayofanana ya TPU kwenye saraka au la, mfumo unaikusanya kabla ya kuandaa programu kuu.

Kwa kuongezea, ikiwa mabadiliko yanafanywa kwa sehemu ya kiolesura cha moduli, basi moduli zingine zote zinazoifikia pia zitakusanywa tena. Njia ya Tengeneza kwa hivyo hurahisisha sana mchakato wa kutengeneza programu kubwa na moduli nyingi: mpangaji ameachiliwa kutoka kwa hitaji la kufuatilia mawasiliano ya faili zilizopo za TPU na maandishi yao ya chanzo, kwani mfumo hufanya hivi kiatomati.

Katika hali ya Kujenga, faili zilizopo za TPU hazizingatiwi na mfumo unajaribu kupata (na kukusanya) faili inayolingana ya PAS kwa kila sehemu iliyotangazwa katika Matumizi. Baada ya kuandaa katika hali ya Kujenga, mpangaji programu anaweza kuwa na uhakika kwamba mabadiliko yote aliyofanya katika moduli yoyote yanazingatiwa.

Uunganisho wa moduli kwenye programu kuu na mkusanyiko wao unaowezekana unafanywa kwa mpangilio wa tamko lao katika kifungu cha Matumizi. Wakati wa kuhamia moduli inayofuata, mfumo kwanza hutafuta moduli zote ambazo inarejelea. Viungo vya moduli kwa kila mmoja vinaweza kuunda muundo wa mti wa utata wowote, lakini marejeleo ya wazi au yasiyo ya moja kwa moja ya moduli yenyewe ni marufuku.

Swali la 6

Moduli ya CRT ni maktaba ya taratibu na maelezo ambayo huongeza uwezo wa mtumiaji wakati wa kufanya kazi na maandishi, skrini ya maandishi na kibodi. Hebu tuangalie baadhi yao.

1). TextMode (mode: integer) - huchagua modi maalum ya maandishi ya CRT:

2).Usuli wa maandishi (rangi: baiti) - Huchagua rangi ya usuli.

Kigezo cha rangi ni kielelezo cha aina kamili, kwa mfano:

• 0 - nyeusi
• 1-bluu
• 2-kijani
• 3-bluu

3). ClrScr - Kusafisha skrini. Nafasi zote za wahusika zimejaa nafasi. Hii hutumia rangi ya mandharinyuma ya sasa iliyobainishwa katika utaratibu wa TextBackGround.

4). TextColor (rangi:byte) - Inaweka rangi ya wahusika. (mara kwa mara kwa kuweka rangi)

5). Dirisha(x1,y1,x2,y2) - Inafafanua dirisha la maandishi kwenye skrini. Vigezo x1,y1 ni kuratibu za kona ya juu kushoto ya dirisha, vigezo x2,y2 ni kuratibu za kona ya chini ya kulia Ukubwa wa chini ni safu moja kwa kila safu. Upeo - X=80, Y=25 Ikiwa kuratibu ni batili, basi wito kwa utaratibu wa Dirisha hautazingatiwa. Kwa chaguo-msingi, dirisha limewekwa ili kujaza skrini nzima.

6).GoToXY(x,y: byte) - Inaweka kielekezi. Mshale husogea kwenye nafasi ndani ya dirisha la sasa, ambalo limeainishwa na viwianishi vya x na y (x - inabainisha safu, y - inabainisha safu ya juu kushoto imeainishwa na kuratibu (1,1) mfano. Dirisha(1,10,60,20); GoToXY(1,1); Hii itasababisha mshale kuhamia kwa uhakika na kuratibu kabisa (1,10).

7).WhereX na WhereY hurejesha viwianishi vya X na Y kwa nafasi ya sasa ya kishale inayohusiana na dirisha la sasa, mtawalia. Matokeo aina ya Byte.

8).Kuchelewa(ms: neno) - Hufanya ucheleweshaji kwa idadi iliyobainishwa ya milisekunde. Kigezo cha msec kinabainisha idadi ya milisekunde ya kusubiri. Lakini utaratibu huu ni wa takriban, kwa hivyo muda wa kuchelewa hautakuwa sawa kabisa na idadi maalum ya milliseconds.

9).READKey - Husoma herufi kutoka kwenye kibodi.

10).Sauti - ni utaratibu unaowasha msemaji wa ndani; Maelezo: Sauti(hertz: neno); ambapo parameter ya "hertz" inataja mzunguko wa ishara inayozalishwa katika hertz Sauti itasikika mpaka itazimwa kwa kupiga utaratibu wa NoSound;

11).NoSound - Huzima kipaza sauti cha ndani.

Mfano wa kutumia Sauti,Kuchelewa,NoSound

Sauti(220); (washa sauti)

Kuchelewa (300); (subiri ms 300)

Hakuna sauti; (zima sauti)

Swali la 7.

Moduli ya grafu

TP ina zana nyingi za kufanya kazi na skrini ya kawaida ya VGA.

Adapta ya VGA ina azimio la saizi 640x480 (dot (0,0) kwenye kona ya juu kushoto ya skrini), rangi 16.

Kabla ya kuanza kufanya kazi na graphics, unahitaji kuianzisha, na ukimaliza, "ifunge". Taratibu zote za kielelezo na kazi ziko kwenye moduli ya Grafu, kwa hivyo unganisho lake pia ni muhimu.

Muundo wa jumla wa programu ya graphics:

Hutumia crt, grafu;
var Gd, Gm: Nambari;
kuanza
M-ngu:= Tambua;
InitGraph(Gd, Gm, "c:\bp\bgi");
...
(Hapa kuna ujenzi wa picha)
...
ReadKey;
CloseGraph;
mwisho.

Njia c:\bp\bgi inabainisha eneo la faili ya egavga.bgi (kiendesha michoro). Njia hii inaweza kuwa tofauti kwenye kompyuta tofauti. Ikiwa faili ya egavga.bgi imewekwa kwenye saraka na programu, basi njia haifai kutajwa.

Taratibu za kimsingi za picha na kazi:

Kuunda takwimu

PutPixel(x,y,c)
- huonyesha nukta kwenye skrini na viwianishi (x, y) na rangi c

Mstari(x1,y1,x2,y2)
- huchora mstari na mwanzo katika uhakika (x1,y1) na mwisho kwa (x2,y2)

Mstatili(x1,y1,x2,y2)
- huchota muhtasari wa mstatili na diagonal (x1,y1) - (x2,y2)

Upau(x1,y1,x2,y2)
- huchota mstatili uliojazwa na ulalo (x1,y1) - (x2,y2)

Mduara(x,y,r)
- huchota mduara na kituo (x, y) na radius r

Ellipse(x,y,ba,ea,xr,mwaka)
- huchota safu ya duaradufu yenye katikati kwa (x,y), radius ya mlalo na wima xr na mwaka, na pembe ya kuanzia na mwisho ba na ea

JazaEllipse(x,y,xr,mwaka)
- huchota duaradufu iliyojaa katikati kwa (x,y), radius mlalo na wima xr na mwaka

Abs katika Pascal, hurejesha thamani kamili ya kigezo. Matokeo yaliyorejeshwa na kazi ya Abs yana sawa na hoja - parameta iliyopitishwa kwa kazi. Kigezo hiki kinaweza kuwa cha aina yoyote ya data ya nambari.

Sintaksia ya utendakazi wa Abs kwa nambari kamili:

kazi Abs(L: LongInt) : LongInt;

kazi Abs(I: Int64) : Int64;

Chaguo la mwisho linawezekana tu na , kwani Pascal ya zamani haina aina ya data ya Int64.

Sintaksia ya kazi ya Abs kwa nambari halisi:

kazi Abs(D: ValReal) : ValReal;

ValReal ni aina halisi ya data yenye thamani kubwa zaidi inayopatikana kwenye mfumo fulani wa uendeshaji. Kwa kweli, hii ni pak (pak) ya moja ya aina Iliyopanuliwa au Mara mbili.

Na sasa mfano wa matumizi:

Programu haifanyi kazi; var x: nambari kamili = -100; y: nambari kamili; anza y:= Abs(x); //y = 100 WriteLn("Abs(-100) = ", y); //Matokeo 100 ReadLn; mwisho.

Hapa tunatangaza kwanza kigezo chenye thamani ya awali ya -100 (nambari hasi).

Na katika programu tunatumia kazi ya Abs na matokeo yake kutofautiana y itakuwa sawa na 100 (nambari nzuri).

Je, kazi ya Abs inakokotoa nini?

Kwa ujumla, Abs ni kifupi cha Absolute. Kama unavyoweza kukisia, neno hili linatafsiriwa kama "kabisa, safi, lisilo na shaka."

Lazima ukumbuke kutoka kwa kozi yako ya hisabati ya shule kwamba nambari kamili, ambayo ni, thamani kamili au moduli ya nambari x, ni nambari isiyo hasi, ufafanuzi wake unategemea aina ya nambari x.

Katika hisabati, moduli ya nambari x inaonyeshwa kama ifuatavyo: |x|.

Hiyo ni, kazi ya Abs inarudisha nambari chanya kwa hali yoyote. Kazi hii inapatikana katika karibu lugha zote za programu, kwani hutumiwa mara nyingi na ni sehemu ya misingi ya hisabati.

Kwa hivyo, tunaweza kusema kwamba kazi Abs(x) huhesabu moduli ya nambari x. Hiyo ni, Abs(x) katika Pascal ni sawa na |x| katika hisabati.

Na mwishowe, wacha tuunde analog yetu ya chaguo la kukokotoa ambayo inarudisha moduli ya nambari. Kwa hivyo kazi itakuwa kitu kama hiki:

Kazi MyAbs(iNum: integer) : nambari kamili; anza ikiwa iNum

Hapa tunapitisha nambari kamili kwa kazi, ambayo inaweza kuwa hasi au chanya. Katika kazi tunaangalia thamani ya nambari hii. Ikiwa nambari ni hasi, basi tunaizidisha kwa -1, na hivyo kupata nambari nzuri. Ikiwa nambari ni chanya, basi hatufanyi chochote - tunarudisha nambari iliyopokelewa kupitia paramu ya iNum.

Kama unaweza kuona, algorithm ni rahisi sana.

Kweli, utendaji wetu unaweza kufanya kazi na nambari kamili tu. Lakini haya ni mambo madogo...

Programu-jalizi.

1. Masharti ya msingi

Moduli ya programu-jalizi- faili iliyo na maandishi ya chanzo katika lugha ya Pascal, yenye muundo fulani, iliyokusudiwa kutumika katika programu kuu na katika programu-jalizi zingine. Matumizi ni kujumuisha moduli katika sehemu ya matumizi kwa kubainisha jina lake.

2. Muundo wa jumla wa moduli ya kuziba

Kitengo<имя модуля>; Mwisho wa Utekelezaji wa Kiolesura.

Kimuundo, moduli ya programu-jalizi inaweza kugawanywa katika sehemu tatu: 1) Sehemu ya kiolesura - kiolesura (lazima itangazwe, inaweza kuwa tupu) 2) Sehemu ya utekelezaji - utekelezaji (lazima itangazwe, inaweza kuwa tupu) 3) Mwili wa moduli - anza -mwisho. (inaweza kukosa)

2.1. Sehemu ya kiolesura.

Sehemu ya kiolesura- eneo la programu-jalizi, kuanzia na neno kuu la kiolesura na kuishia na neno kuu la utekelezaji, ambalo linaweza kuwa na: - orodha ya programu-jalizi; - mara kwa mara; - aina za data maalum; - vigezo; - prototypes ya taratibu na kazi zinazopatikana kutoka kwa uhakika wa uunganisho wa moduli hii. Kumbuka 1: vigezo vilivyotangazwa katika sehemu ya violesura ni vya kimataifa. Hiyo ni, zipo mahali popote kwenye programu ambapo moduli hii imeunganishwa, ikiwa ni pamoja na katika sehemu ya utekelezaji wa moduli yenyewe. Kumbuka 2: kama ilivyo katika programu, sehemu zilizo hapo juu (matangazo ya vibadilishio, vigeuzi, n.k., isipokuwa sehemu ya matumizi) katika sehemu hii zinaweza kupangwa kwa mlolongo wowote na kwa wingi wowote. Kumbuka 3: Ikiwa prototypes za taratibu/kazi zimetangazwa katika sehemu hii, basi utekelezaji wake lazima uhakikishwe kuwepo katika sehemu ya utekelezaji. Kusudi kuu: inafafanua data ya umma/utendakazi kwa matumizi kutoka kwa programu au moduli inayotumia moduli hii.

Mfano wa sehemu ya kiolesura:

Kiolesura (plug-ins) Hutumia AnotherUnit; (mara kwa mara) Const PI=3.14159265; E=2.71828182; (aina za data maalum) Aina TMyType=array[-3..7] ya halisi; (vigezo) Var temp:TMyType; (taratibu na utendakazi) Ujazaji wa Utaratibu(var x:TMyType); Tafuta Kazi(const x:TMyType; const Thamani:halisi):Boolean; Utekelezaji

2.2. Sehemu ya utekelezaji.

Sehemu ya utekelezaji- eneo la moduli ya programu-jalizi, kuanzia na utekelezaji wa neno kuu na kuishia na mwili wa moduli (ikiwa kuna moja) au mwisho wa neno kuu na nukta inayoonyesha mwisho wa moduli, ambayo utekelezaji wa taratibu na kazi zilizotangazwa katika sehemu ya interface ziko, ambazo zinaweza kuwa na: - orodha ya moduli za kuziba; - mara kwa mara; - aina za data maalum; - vigezo; - taratibu na kazi zinazohitajika kutekeleza taratibu/kazi zilizotangazwa katika sehemu ya kiolesura. Kusudi kuu: utekelezaji wa taratibu na kazi zilizoelezwa katika sehemu ya interface. Kumbuka 1: Wakati wa kutekeleza taratibu na kazi zilizoelezwa katika sehemu ya interface, vichwa vyao vinaweza kuelezewa kwa fomu iliyofupishwa. Isipokuwa - PascalABC: wakati wa kutumia vigezo vya kichwa katika maandishi ya utekelezaji, hitilafu ya mkusanyiko hutokea.

Mfano 1 (vichwa katika ufupisho):

Kitengo cha Demo; Kiolesura (mfano wa utaratibu) Ubadilishanaji wa Utaratibu(var a,b:integer); Mabadilishano ya Utaratibu wa Utekelezaji; Var Temp: integer; Anza Muda:=a; a:=b; b:=Kipindi; mwisho; mwisho.

Mfano 2 (vichwa katika umbo kamili):

Kitengo cha Demo; kiolesura (mfano wa kazi) Kazi ya GetMax(a,b:integer):jumla; Utekelezaji wa Kazi GetMax(a,b:integer):jumla; Anza Kama a>b kisha GetMax:=a Else GetMax:=b; Mwisho; Mwisho.

2.3. Mwili wa moduli.

Mwili wa moduli- eneo la mwisho la moduli ya programu-jalizi, iliyoundwa na jozi ya maneno: "anza" na "mwisho.", Ambayo msimbo wa programu unaweza kuwekwa kwa njia sawa na programu kuu. Mwili wa moduli unaweza kukosa. Katika kesi hii, neno kuu "anza" halijaandikwa, lakini "mwisho." inaashiria mwisho wa moduli. Kusudi kuu: uanzishaji wa vigezo vya moduli, ugawaji wa rasilimali muhimu kwa uendeshaji wake, nk.

Mfano wa moduli iliyo na mwili:

Kitengo cha Demo; Kiolesura Const N=50; Var Roots:safu ya kweli; Utekelezaji Hutumia Hisabati; Var I: integer; (mwili wa moduli) Anza Kwa i:=1 hadi N do Roots[i]:=sqrt(i); Mwisho.

Mfano wa moduli isiyo na mwili: (tazama mfano wa moduli ya vichwa katika umbo kamili).

Kumbuka 1: Nambari ya programu iko kwenye mwili wa moduli inatekelezwa mara moja - wakati moduli inapakiwa, kabla ya utekelezaji wa kanuni kuu ya programu kuanza. Kumbuka 2: Katika kesi wakati moduli kadhaa ambazo zina sehemu za uanzishaji zimeunganishwa katika sehemu ya matumizi, msimbo wa sehemu hizi unatekelezwa kwa utaratibu ambao moduli zimeunganishwa.

2.4. Sehemu za ziada katika muundo wa moduli.

Vikusanyaji vya Bure vya Pascal, Pascal ABC, Pascal ABC.Net vinaruhusu, pamoja na zile zilizoorodheshwa hapo juu, sehemu mbili zaidi: - sehemu ya uanzishaji - sehemu ya kukamilisha. 2.4.1. Sehemu ya uanzishaji. Sehemu ya uanzishaji- eneo la programu-jalizi lililowekwa baada ya mwisho wa sehemu ya utekelezaji, kuanzia na neno kuu la uanzishaji na kuishia na sehemu ya kukamilisha, ikiwa kuna moja, au neno kuu la mwisho likifuatiwa na dot. Kusudi ni sawa na mwili wa moduli. 2.4.2. Sehemu ya kukamilisha. Sehemu ya kukamilisha- eneo la programu-jalizi lililowekwa mwishoni mwa sehemu ya uanzishaji, ikiwa kuna moja, au mwishoni mwa sehemu ya utekelezaji, na kuishia na neno kuu la mwisho likifuatiwa na nukta. Kusudi kuu: ikitoa rasilimali zilizotengwa kwa ajili ya uendeshaji wa moduli.

kitengo DemoUnit; interface var a:safu ya ^integer;(safu ya viashiria) utekelezaji (mgao wa kumbukumbu na uanzishaji kwa maadili) utaratibu wa AllocateArray; var i: integer; anza kwa i:=1 hadi 20 naanza Mpya(a[i]); a[i]^:=i; mwisho; mwisho; (deallocating memory) utaratibu DeallocateArray; var i: integer; anza kwa i:=1 hadi 20 do Dispose(a[i]); mwisho; uanzishaji AllocateArray;(kuanzisha - kuanza kwa kazi - kutenga kumbukumbu) kukamilishwa DeallocateArray;(kukamilisha - mwisho wa kazi - fungua kumbukumbu) mwisho.

Kumbuka 1: Nambari ya programu iliyowekwa katika sehemu zilizoorodheshwa inatekelezwa mara moja. Nambari ya sehemu za uanzishaji ni kabla ya kuanza kwa utekelezaji wa nambari kuu ya programu, msimbo wa sehemu za kukamilisha ni baada. Kumbuka 2: Ikiwa moduli ina mojawapo ya sehemu hizi mbili, uwepo wa mwili wa moduli hauruhusiwi tena.

3. Kuandaa moduli.

Kila programu-jalizi imeundwa tofauti, na matokeo ya ujumuishaji inategemea mkusanyaji aliyetumiwa.

3.1. Mkusanyiko katika Turbo Pascal.

Matokeo ya kuandaa programu-jalizi kwenye Turbo Pascal ni faili ya *.tpu (Turbo Pascal Compiled Unit), ambayo ni uwakilishi wa mashine ya data na msimbo ulio ndani yake.

3.2. Kukusanya katika Pascal Bure.

Matokeo ya kuandaa moduli ya programu-jalizi katika Free Pascal ni faili mbili: *.ppu - faili iliyo na sehemu ya kiolesura cha moduli, na faili ya *.o - faili ya kitu iliyo na sehemu ya utekelezaji. Aidha, mwisho ni muhimu kwa ajili ya kutunga maombi.

3.3. Mkusanyiko katika Pascal ABC.Net.

Tofauti na mazingira yaliyoorodheshwa hapo juu, Pascal ABC.Net haitoi msimbo wa lugha ya mashine wakati wa utungaji wa moduli. Mkusanyaji wa mazingira haya anakamilisha kazi yake baada ya kufanya uchambuzi wa semantic, kuokoa mti wa semantic wa moduli katika muundo wa kati - *.pcu - faili ambayo, kwa makadirio ya kwanza, inaweza kuchukuliwa kuwa matokeo ya mkusanyiko na mapungufu yaliyoonyeshwa. .

3.4. Kuongeza kasi ya utayarishaji wa programu.

Katika hatua ya kuunganisha programu, kiunganishi hukusanya moduli inayoweza kutekelezwa, ikichukua moduli za kitu kama pembejeo. Kwa hivyo, baada ya kuandaa programu-jalizi, kuandaa programu kwa kuzitumia ni haraka, kwani tayari zimechakatwa. Hii ni kweli kwa Turbo na Free Pascal. Walakini, katika Pascal ABC.Net, kasi ya ujumuishaji hupatikana tu kwa sababu hakuna haja ya kufanya uchambuzi wa kisintaksia na kisemantiki. Hitimisho: matoleo yaliyokusanywa ya moduli zinazoweza kutekelezwa hazioani kati ya wakusanyaji tofauti.

Nambari ya kazi: "Programu-jalizi"

Maandishi

Orodha ya programu

kitengo u1; utaratibu wa interface PrintFirst; utaratibu PrintFirstSecond; utekelezaji hutumia u2; (<--- Раньше было в Interface } procedure PrintFirst; begin writeln("Print first"); end; procedure PrintFirstSecond; begin writeln("Print first"); PrintSecond; end; end.