Turbo Pascal - Programowanie

Turbo Pascal - Programowanie

Autor: Tomasz M. Sadowski

ISBN: 83-86718-40-4

Format: B5, 136 strony

Data wydania: 08/1996

Jak wiesz, sam komputer jest jedynie zbiorem doœæ skomplikowanych uk³adów

elektronicznych, które same z siebie nie s¹ w stanie wykonaæ jakiejkolwiek

znacz¹cej operacji. Jego "inteligencja" bierze siê w ca³oœci z wiedzy, któr¹

przekazali mu programiœci w postaci odpowiedniego oprogramowania.

Niniejsza ksi¹¿ka wprowadzi Ciê w fascynuj¹cy œwiat programowania

w Turbo Pascalu.

- Co to jest Problem, Metoda, Algorytm, Implementacja, Zdrowy rozs¹dek...?

- Jak korzystaæ z edytora Turbo Pascala?

- Od czego zacz¹æ, czyli jak obliczyæ pole ko³a za pomoc¹ komputera?

- Czym siê ró¿ni ³añcuch od liczby rzeczywistej?

- Do czego s³u¿y instrukcja warunkowa?

- Jak rozwi¹zaæ dowolne równanie?

- Co siê kryje pod tajemniczymi nazwami: funkcje i procedury?

- Do czego s³u¿¹ tablice, a do czego pêtle?

- Jak zapisywaæ dane w pliku na dysku?

- Jak tworzyæ i korzystaæ z modu³ów bibliotecznych?

- Jak uruchamiaæ "oporne" programy?

Odpowiedzi na te i inne pytania znajdziesz w tej ksi¹¿ce! Wszystko opisane

¿ywym i barwnym jêzykiem, zilustrowane krótkimi, przejrzystymi i praktycznymi

programami.

Szkoda czasu, ¿eby przegryzaæ siê przez opas³e tomiska, aby nauczyæ siê

podstaw programowania. Rozpocznij od tej krótkiej, ale niezwykle treœciwej

ksi¹¿ki, dziêki której programowanie stanie siê szybkie, ³atwe i przyjemne...

WWW.PROGRAMOWANIE.TK

Jak wiesz, komputer jest jedynie zbiorem skompli

NRZDQ\FKXNáDGyZHOHNWURnicznych, które same

]VLHELHQLHVZVWDQLHZ\NRQDüMDNLHjNROZLHN]QDF]FHMRSHUDFML-HJRÄLQWHOLJHQFMD´ELHU]HVL
z

ZLHG]\NWyUSU]HND]DOLPXSURJUDPLFLZSRVWDFLRGSRZLHGQLHJRRSURJramowania. Niniejsza

NVL*NDZSURZDG]L&LZIDVF\QXMF\ZLDWSURJUDPRZDQLDZ7XUER3DVFDOX

•

&RWRMHVW3UREOHP0HWRGD$OJRU\WP,PSOHPHQWDFMD=GURZ\UR]VGHN"

•

-DNNRU]\VWDü]HG\WRUD7XUER3DVFDOD"

•

2GF]HJR]DF]üF]\OLMDNREOLF]\üSROHNRáD]DSRPRFNRPSXWHUD"

•

&]\PUy*QLVLáDFXFKRGOLF]E\U]HF]\ZLVWHM"

•

'RF]HJRVáX*\LQVWUXNFMDZDUXQNRZD"

•

-DNUR]ZL]DüGRZROQHUyZQDQLH"

•

&RNU\MHVLSRGWDMHPQLF]\PLQD]ZDPLÄIXQNFMHi procedury?

•

'RF]HJRVáX*WDEOLFHDGRF]HJRSWOH"

•

-DN]DSLV\ZDüGDQHZSOLNXQDG\VNX"

•

-DNWZRU]\üLNRU]\VWDü]PRGXáyZELEOLWHF]Q\FK"

•

-DNXUXFKDPLDüÄRSRUQH´SURJUDP\"

2GSRZLHG]LQDWHLLQQHS\WDQLD]QDMG]LHV]ZWHMNVL*FH:V]\VWNRRSLVDQH*\Z\PLEDUZQ\P

M]\NLHP]LOXVWURZDQHNUyWNLPLSU]HMU]\VW\PLLSUDNW\F]Q\PLSURJUDPDPL
6]NRGDF]DVX*HE\SU]HJU\]DüVLSU]H]RSDVáHWRPLVNDDE\QDXF]\üVLSRGVWDZSURJUDPRZDQLD

5R]SRF]QLMRGWHMNUyWNLHMDOHQLH]Z\NOHWUHFLZHMNVL*NLG]LNLNWyUHMSURJUDPRZDQLHVWDQLHVL

V]\ENLHáDWZHLSU]\MHPQH

3URMHNWRNáDGNL0DFLHM3DVHN„ARTGRAF”

HELION, 1996

ISBN: 83-86718-40-4

:V]HONLHSUDZD]DVWU]H*RQH
1LHDXWRU\]RZDQHUR]SRZV]HFKQLDQLHFDáRFLOXEIUDJPHQWXQLQLHMszej publikacji w jakiejkolwiek

SRVWDFLMHVW]DEURQLRQH:\NRQ\ZDQLHNRSLLPHWRGNVHURJUDILF]QIRWRJUDILF]QDWDN*HNRSLR-

ZDQLHNVL*NLQDQRQLNXILOPRZ\PPDJQHW\F]Q\POXELQQ\PSRZRGXMHQDUXV]HQLHSUDZDXtor-
skich niniejszej publikacji.

:\VWSXMFHZWHNFLH]QDNLV]DVWU]H*RQ\PL]QDNDPLILUPRZ\PLEG(WRZDURZ\PLLFKSRVLD-
daczy.

$XWRURUD]:\GDZQLFWZR+HOLRQGRáR*\OLZV]HONLFKVWDUDE\]DZDUWHZWHMNVL*FHLQIRUPDFMH

E\á\NRPSOHWQHLU]HWHOQH1LHELRUMHGQDN*DGQHMRGSRZLHG]LDOQRFLDQL]DLFKZ\korzystanie,

DQL]D]ZL]DQH]W\PHZHQWXDOQHQDUXV]HQLHSUDZSDWHQWRZ\FKOXEDXWRUVNLFK

Printed in Poland

6SLVWUHFL

Spis tre

Po co mi programowanie? ....................................................................... 5

Co to jest programowanie?...................................................................... 8

-DNWRVLURELQDSUDZG"

...................................................................... 10

Problem........................................................................................................................ 10
Metoda ......................................................................................................................... 11
Algorytm....................................................................................................................... 11
Projekt.......................................................................................................................... 14
Implementacja.............................................................................................................. 15
Uruchomienie............................................................................................................... 15

=GURZ\UR]VGHN

......................................................................................................... 16

1DU]G]LH

................................................................................................. 17

Zaawansowane funkcje edytora .................................................................................. 22

=DSDPLWDM

................................................................................................................... 25

Pierwszy program ................................................................................... 26

=DSDPLWDM

................................................................................................................... 31

1LFQLHMHVWGRVNRQDáH

......................................................................... 32

=DSDPLWDM

................................................................................................................... 36

Ulepszamy dalej ...................................................................................... 37

=DSDPLWDM

................................................................................................................... 40

:\UD*HQLD

................................................................................................ 41

=DSDPLWDM

................................................................................................................... 47

Instrukcja warunkowa ............................................................................ 48

=DSDPLWDM

................................................................................................................... 51

5R]ZL]XMHP\GRZROQHUyZQDQLH

......................................................... 52

=DSDPLWDM

................................................................................................................... 57

Funkcje i procedury ................................................................................ 59

Po co mi programowanie?

Po co mi
programowanie?

=DQLP ]DJáELP\ VL Z G\VNXVM R WDMQLNDFK SURJUDPRZDQLD Z\SDGDáRE\ RGSRZLH-

G]LHüQDSRGVWDZRZHS\WDQLHczy w ogóle jest Ci ono potrzebne?

W zasadzie —

QLH %UDN XPLHMWQRFL SURJUDPRZDQLD QLH SU]HV]NRG]L &L Z ]GDQLX

PDWXU\QDSLVDQLXOLVWX]URELHQLX]DNXSyZF]\SURZDG]HQLXVDPRFKRGX1RPR*HRG

F]DVXGRF]DVXEG]LHV]PXVLDá]DSURJUDPRZDüPDJQHWRZLGDOHF]\QQRüWD] „praw-

G]LZ\P´ SURJUDPRZDQLHP PD UDF]HM PDáR ZVSyOQHJR 7\P QLHPQLHM — skoro

VLJQáHSRWNVL*N—PR*QD]DáR*\ü*HPDV]]DPLDU]DZU]HüEOL*V]]QDMRPRü
z

NRPSXWHUDPL$WRMX*]XSHáQLHLQQDVSUDZD

-DNZLHV]VDPNRPSXWHUMHVWMHG\QLH]ELRUHPGRüVNRPSOiNRZDQ\FKXNáDGyZHOHNWUR-

QLF]Q\FKNWyUHVDPH]VLHELHQLHVZVWDQLHZ\NRQDüMDNLHjNROZLHN]QDF]FHMRSHUDFML

-HJR ÄLQWHOLJHQFMD´ ELHU]H VL Z FDáRFL ] ZLHG]\ NWyU SU]HND]DOL PX SURJUDPLFL
w postaci odpowiedniego oprogramowania. Nawet tak trywialna operacja, jak wprowa-

G]HQLH SRMHG\QF]HJR ]QDNX ] NODZLDWXU\ ]ZL]DQD MHVW ] Z\Nonaniem sporej liczby
operacji zakodowanych w oprogramowaniu systemowym. A co dopiero wyliczenie
bilansu firmy czy wycieniowanie skomplikowanego rysunku...

$]DWHPQLHPDPRZ\RIXQNFMRQRZDQLXNRPSXWHUDEH]RSURJUDPRZDQLD2F]\ZLFLH

QLH R]QDF]D WR *H DE\ ZSURZDG]Lü ] NODZLDWXU\ VZRMH QD]ZLVNR PXVLV] FRNROZLHN
progra

PRZDüRGSRZLHGQLHIXQNFMH]RVWDá\MX*GDZQRXWZRU]RQHLSU]HND]DQHGRG\V-

SR]\FMLX*\WNRZQLNyZSRGSRVWDFLV\VWHPXRSHUDF\MQHJRLRSURJUDPRZDQLDX*\WNR-

ZHJR 2 LOH QLH PDV] ]DPLDUX ]DMü VLWZRU]HQLHPSRGREQHJRRSURJUDPRZDQLDQLH

PXVLV] QDZHW ZLHG]LHü MDN WDNLH IXQNFMH G]LDáDM FKRFLD* F]DVHP SU]\GDMH VL WR Z

Uy*nych kryzysoZ\FK V\WXDFMDFK 7DN ZLF ]QDMRPRü SURJUDPRZDQLD QLH MHVW

NRQLHF]QDGRREVáXJLNRPSXWHUD

0R*HZWDNLPUD]LHSURJUDPRZDQLHMHVWSRWU]HEQHGRNRU]\VWDQLD]SURJUDPyZX*\W-
ko

Z\FK" 2ND]XMH VL *H WH* QLH 1RZRF]HVQH HG\WRU\ WHNVWyZ DUNXV]H NDONXODF\MQH

LQQH SRZV]HFKQLH X*\ZDQH DSOLNDFMH ELXURZH SR]ZDODM QD Z\NRQ\ZDQLH Z\P\O-

Q\FK RSHUDFML SU]H] QDFLQLFLH NLONX NODZLV]\ OXE NOLNQLFLH P\V]N 7\SRZD

6 Turbo

Pascal

—

programowanie

NVLJRZD X*\ZDMFD ([FHOD SLVDU] SLV]F\ Z :RUG]LH F]\ JUDILN NRU]\VWDMF\ ]

&RUHOD QLH PDM ]Z\NOH SRMFLD R SURJUDPRZDQLX — bo do niczego nie jest im ono
potrzebne.

No to o czym my w ogóle mówimy? —

PyJáE\]DS\WDü2Wy*VSUDZDZFDOHQLHMHVW

przes

G]RQD 3U]HGH ZV]\VWNLP LVWQLHMH VSRUD JUXSD F]\WHOQLNyZ NWyU]\ ]DPLHU]DM

SR]QDüVSoVRE\SU]\PXV]HQLDNRPSXWHUDGRZ\NRQ\ZDQLDGRNáDGQLHWHJRF]HJRVRELH

]D*\F] — F]\OL ZáDQLH PHWRG\ SURJUDPRZDQLD &]ü ] QLFK ]DSHZQH ]RVWDQLH
w

SU]\V]áRFL SURJUDPLVWDPL L ]DMPLH VL WZRU]HQLHP RSURJUDPRZDQLD V\VWHPRZHJR

i u

*\WNRZHJRG]LDáDOQRüWRZFDOHLQWUDWQD,QQLSRGFKRG]F\GR]DJDGQLHQLDEDUG]LHM

SR DPDWRUVNX ]DGRZRO VL VDW\sIDNFM LQWHOHNWXDOQ Sá\QF ]H ]UR]XPLHQLD ]DVDG

G]LDáDQLD SURJUDPyZ L XPLHMWQRFL ]DSDQRZDQLD QDG VNRPSOLNRZDQ\P QDU]G]LHP

MDNLPMHVWQRZRF]HVQ\NRPSXWHU-HV]F]HLQQLW\FKEG]LH]DSHZQHQDMZLFHMEGSR

SURVWX Z\NRU]\VW\ZDü ]GRE\WH XPLHMWQRFL GR UR]ZL]\ZDQLD SUREOHPyZ VSRW\ND-

Q\FKZFRG]LHQQHMSUDF\QLHSUHWHQGXMFE\QDMmQLHMGRPLDQDSURJUDPLVWyZFKRüE\
nawet amatorów.

Ale prz

HFLH*UyZQLHGREU]HPRJVNRU]\VWDü]MDNLHJRSURJUDPXX*\WNRZHJR. Zgoda,

SHZQ\PGUREQ\P]DVWU]H*HQLHP1RZRF]HVQHRSURJUDPRZDQLHMHVWZVWDQLH]URELü

pra

ZLHZV]\VWNR]DMHGQ\PQDFLQLFLHPNODZLV]DF]\NOLNQLFLHPP\V]N1LH]QDF]\

WRMHGQDN*HVSHáQLRQRZV]\VWNLHQDV]H*GDQLDDQLWH**HVSHáQLMHGRNáDGQLHWDNMDN

E\P\ FKFLHOL 3R]D W\P GX*H ZV]\VWNR-ZLHG]FH-i-PRJFH SDNLHW\ X*\WNRZH V QD

RJyá WDN VNRPSOLNRZDQH *H REP\OHQLH PHWRG\ UHDOL]DFML ]DGDQLD F]VWR ]DMPXMH

ZLFHM F]DVX QL* ]DSURJUDPRZDQLH JR RG SRGVWDZ :UHV]FLH PR*H VL SR SURVWX

]GDU]\ü L QDMF]FLHM VL ]GDU]D *H RGSRZLHGQLHJR RSURJUDPRZDQLD QLH EG]LH SRG

UNDOERWH**HFRSUDwGDEG]LHDOH]HZ]JOGXQDZ\VRNLHZ\PDJDQLDVSU]WRZH

GRW\F]\ WR ]ZáDV]F]D QRZHM JHQHUDFML SURJUDPyZ GOD :LQGRZV MHJR XUXFKRPLHQLH

EG]LHPQLHMOXEEDUG]LHMNáRSotliwe.

&]\GREDQDOQHJRREOLF]HQLDUHGQLHMRFHQSRWU]HEQ\&LEG]LHRGUD]X]DDZDQVRZDQ\
pakiet matematyczny, jak Statgraphics, czy arkusz kalkulacyjny, jak Excel? Czy Twój
ulubiony ed

\WRU SRWUDIL ]OLF]\ü ZV]\VWNLH ]QDNL Z WHNFLH NWyU\ ZáDQLH QDSLVDáH"

MHOLWDNWRF]\MHVWZVWDQLHRNUHOLüUHGQLGáXJRü]GDQLD":V]\VWNLHWHRSHUDFMH

PR*QD ]UHDOL]RZDü ]D SRPRF SURVW\FK SURJUDPLNyZ Z 3DVFDOX OXE %DVLFX NWyU\FK

QDSLVDQLH L XUXFKRPLHQLH QDZHW QLH]E\W ZSUDZQHPX X*\WNRZQLNRZL ]DMPXMH NLOND-

QDFLHPLQXW

1DZHWMHOLMHVWHZ\áF]QLHX*\WNRZQLNLHPMDNLHJRNRQNUHWQHJRSURJUDPXQSHG\-

WRUD WHNVWyZ L QLH PDV] ]DPLDUX ]DZLHUDü ]QDMRPRFL ] 3DVFDOHP F]\ %DVLFHP

]DSR]QDQLH VL ] SRGVWDZDPL V]WXNL SURJUDPRZDQLD EG]LH QLH RG U]HF]\ 'ODF]HJR"

:\REUD( VRELH *H Z GRNXPHQFLH QDG NWyU\P SUDFXMHV] ]QDMGXMH VL NLONDQDFLH

WDEHOHN D Z ND*GHM ] QLFK PXVLV] ]DPLHQLü PLHMVFDPL SLHUZV]\ ZLHUV] ] GUXJLP

3UDNW\F]QLH *DGHQ HG\WRU QLH uPR*OLZLD ]DPLDQ\ GZyFK ZLHUV]\ WDEHOL Z MHGQ\P
kroku, a tym bardziej zrobienia tego dla wszystkich tabelek w dokumencie. Tak jednak

VL VNáDGD *H ZLNV]Rü QRZRF]HVQ\FK HG\WRUyZ :RUG3HUIHFW :RUG GOD :LQGRZV

XPR*OLZLD X*\WNRZQLNRZL WZRU]HQLH WDN ]ZDQ\FK makrodefinicji EGF\FK QLF]\P
innym, jak tylko programami

QDSLVDQ\PLZVSHFMDOQ\PM]\NX=DPLDVWZLF*PXGQLH

Z\V]XNLZDüNROHMQHWDEHOHL]DPLHQLDüZLHUV]HPLHMVFDPLPR*HV]QDSLVDüRGSRZLHGQL

8 Turbo

Pascal

—

programowanie

Co to jest
programowanie?

3RZLHP\ REHFQLH NLOND VáyZ QD WHPDW VDPHJR SURFHVX SURJUDPRZDQLD $E\ &L ]D

EDUG]R QLH ]QXG]Lü RJUDQLF]\P\ VL WXWDM GR NUyWNLHJR RPyZLHQLD MHJR QDMZD*niej-

V]\FKHOHPHQWyZUH]\JQXMF]IRUPDOL]PyZL]EGQHMWHRULL-HOLFKFHV]GRZLHG]LHü

VL QD WHQ WHPDW F]HJR ZLFHM PR*HV] DOH QLH PXVLV] SU]HF]\WDü NROHMQ\ UR]G]LDá

]DW\WXáRZDQ\-DNWRVLURELQDSUDZG"-HOLQLHPDV]RFKRW\PR*HV]ZUyFLüGRQLHJR

Sy(QLHM

1D UR]ZL]DQLH GRZROQHJR ]DGDQLD SRSU]H] SURJUDPRZDQLH VNáDGD VL NLOND HWDSyZ

3U]HGHZV]\VWNLPPXVLV]ZLHG]LHüFRZáDFLZLHFKFHV]]URELüF]\OLPLHüNRQNUHWQ\
problem

GRUR]ZL]DQLD5]HF]MDVQDSUREOHPPXVLQDGDZDüVLGRUR]ZLD]DQLD]DSR-

PRFNRPSXWHUDVNGPDV]RW\PZLHG]LHü"1DREHFQ\PHWDSLHQDMOHSLHM]DVWRVRZDü

]GURZ\UR]VGHN$QDOL]XMFSUREOHPPXVLV]VSUHF\]RZDüMDNLHLQIRUPDFMHPasz do

G\VSR]\FMLLFRFKFHV]X]\VNDüZZ\QLNXMHJRUR]ZL]DQLD1DVWSQLHPXVLV]]GHF\GR-

ZDüVLMDNUR]ZL]Dü]DGDQLHF]\OLZ\EUDüRGSRZLHGQLPHWRG. Kolejnym krokiem

MHVWSU]\MFLHRNUHORQHJRVSRVREXSRVWSRZDQLDF]\OLVFKHPDWXF]\QQRFLNURNyZ

SURZDG]F\FKGRUR]ZL]DQLD6FKHPDWWDNLRNUHODQ\MHVWPLDQHPalgorytmu. Dodat-

NRZF]\QQRFLNWyUQDOH*\Z\NRQDüQDW\PHWDSLHMHVWGobór struktur danych, czyli

VSRVREyZZMDNLHSU]HWZDU]DQDSU]H]QDV]SURJUDPLQIRUPDFMDEG]LHUHSUH]HQWRZDQD

ZHZQWU] NRPSXWHUD &]\QQRü WD MHVW QD RJyá Z\NRQ\ZDQD PHFKaQLF]QLH LVWQLHM

MHGQDNSUREOHP\GODNWyU\FKPR*OLZHMHVWSU]\MFLHNLONu wariantów reprezentowania

LQIRUPDFML]Uy*QLFRZDQ\FKZ]DOH*QRFLRGNRQNUHWQHMV\WXDFML

5]HF]\ZLVWH SUREOHP\ V Z ZLNV]RFL ]E\W VNRPSOLNRZDQH E\ GDá\ VL VNXWHF]QLH
roz

ZL]Dü ]D SRPRF SRMHG\QF]HJR DOJRU\WPX 6NXWHF]QH ]UHDOL]RZDQLH DOJRU\WPX

Z\PDJDSRQDGWRZ\NRQDQLDSHZQ\FKF]\QQRFLSRPRFQLF]\FKMDNFKRüE\ZSURZD-

G]HQLD F]\ Z\SURZDG]HQLD GDQ\FK 7DN ZLF ]Z\NOH PXVLV] SRG]LHOLü ]DGDQLH QD

SHZQHIUDJPHQW\GDMFHVLUR]ZL]Dü]DSRPRFRGSRZLHGQLFKDOJRU\WPyZDFDáRü

REXGRZDü RGSowiednim zestawem operacji „administracyjnych”. W ten sposób two-
rzysz projekt programu.

Co to jest programowanie?

'RSLHURWHUD]ZFKRG]LGRDNFMLNRPSXWHU:\NRU]\VWXMFRGSRZLHGQLSURJUDPX*\Wko-
wy zapisujemy nasz projekt w postaci wykonywalnej przez komputer. Operacja ta nosi
miano kodowania lub implementacji

DMHMZ\QLNLHPSRZLQLHQE\üG]LDáDMF\SURJUDP

3RQLHZD* MHGQDN QLH MHVW SRZLeG]LDQH *H SURJUDP PXVL E\ü RG UD]X EH]EáGQ\ RV-
tatnim etapem naszej pracy jest jego testowanie, czyli inaczej uruchamianie

1DGREU

VSUDZ L WR QLH MHVW NRQLHF ÄSRZD*QH´ SURJUDP\ PXV] E\ü SU]H] FDá\ RNUHV VZRMHM
eksploatacji konserwowane

2NUHOHQLHWRR]QDF]DVSUDZRZDQLHSU]H]DXWRUDQDG]RUX

QDG G]LDáDQLHP SURJUDPX L NRUHNW HZHQWXDlQ\FKEáGyZ=NRQVHUZDFMSURJUDPyZ

ZL*HVLZUHV]FLH]DJDGQLHQLHRSUDFRZDQLDLFKGRNXPHQWDFML'ZLHRVWDWQLHF]\QQRFL

]ZL]DQHVJáyZQLH]SURJUDPRZDQLHPSURIHVMoQDOQ\PWRWH*QLHEG]LHP\VLQLPL

V]F]HJyáRZR]DMPRZDü

7DNPQLHMZLFHMZ\JOGDFDáDSURFHGXUDSURJUDPRZDQLDL—MDNQLHWUXGQR]DXZD*\ü
— samo pisanie i uruchami

DQLHSURJUDPXZFDOHQLHMHVWZQLHMQDMZD*QLHMV]H3RQLH-

ZD*MHGQDNQDV]\PFHOHPMHVWSRND]DQLH&LSRGVWDZU]HPLRVáDQLH]DG\VNXVMDRDOJR-

U\WPDFK L WHRULL LQIRUPDW\NL QD WHQ WHPDW QDSLVDQR ZLHOH PGU]HMV]\FK NVL*HN
w

NROHMQ\FK UR]G]LDáDFK VNXSLP\ VL JáyZQLH QD Z\NáDG]LH M]\ND SURJUDPRZDQLD

RPyZLHQLX MHJR NRQVWUXNFML RG VWURQ\ SUDNW\F]QHM -HOL FKFHV] UR]V]HU]\ü VZRMH

ZLDGRPRFL GRW\F]FH ÄSRGáR*D´ SURJUDPRZDQLD ]DFKFDP &L GR SU]HF]\WDQLD

QDVWSQHJR UR]G]LDáX -HOL QLH PDV] RFKRW\ SU]HMG( GR UR]G]LDáX ]DW\WXáRZDQHJR

1DU]G]LHZNWyU\PSR]QDV]JáyZQHJRERKDWHUDWHMNVL*NL

10 Turbo

Pascal

—

programowanie

-DNWRVLUREL

QDSUDZG"

5R]G]LDáWHQVWDQRZLUR]V]HU]HQLHSRSU]HGQLHJRLZFDOHQLHPXVLV]JRF]\WDüFKRFLD*

PR*H&LVLWRSU]\GDü'RZLHV]VL]QLHJRMDNZ\JOGDMSRV]F]HJyOQHNURNLSURFHVX

SURJUDPRZDQLDLFRR]QDF]DMWDNLHSRMFLDMDNDOJRU\WPVFKHPDWEORNRZ\F]\SURMHNW

3R]QDV] UyZQLH* NLOND PHWRG L ZVND]yZHN SR]ZDODMF\FK QD XV\VWHPDW\]RZDQLH
i uproszczenie pracy.

Problem

Programowanie nie istnieje samo dla s

LHELHDE\ZRJyOHPLDáRRQRVHQVPXVLVáX*\ü

NRQNUHWQHPX FHORZL 3U]\F]\Q XWZRU]HQLD SURJUDPX PXVL E\ü SUREOHP NWyU\ PDV]

UR]ZL]Dü2F]\ZLFLHQLHND*G\SUREOHPGDVLUR]ZL]DüZWHQVSRVyEQLHND*G\WH*

Z\PDJD]DVWRVRZDQLDNRPSXWHUD&RZLFNZDOLILNXMHSUREOHPGR]DSURJramowania?

•

=DVWRVRZDQLH NRPSXWHUD GR UR]ZL]DQLD SUREOHPX SRZLQQR E\ü X]DVDGQLRQH
i

RSáaFDOQH3LVDQLHQDX*\WHNGRPRZ\SURJUDPXSR]ZDODMFHJRQD]DSDPLW\-

wanie adre

VyZ ]QDMRP\FK MHVW VWUDW F]DVX — SURFLHM WR ]URELü ]D SRPRF

QRWHVX,QDF]HMZ\JOGDVSUDZDZEDQNXZNWyU\PREVáXJXMHVLVHWNLNOLHQWyZ

D RG F]DVX GR F]DVX WU]HED Z\VáDü GR ZV]\VWNLFK QS ]DZLDGRPLHQLH R VWDQLH
rachunku.

•

6]F]HJyOQLHSRGDWQHQD]DSURJUDPRZDQLHV]DGDQLDZ\NRQ\ZDQHZLHORNURWQLH

OXE ]áR*RQH ] FLJX SRZWDU]DMF\FK VL F]\QQRFL 3LVDQLH ÄGR MHGQRUD]RZHJR

X*\WNX´ SURJUDPX Z\NRQXMFHJR ]HVWDZ VNRPSOLNRZDQ\FK REOLF]H QD RJyá

PLMDVL]FHOHPJG\*PR*QDMHZ\NRQDüQDNDONXODWRU]H&RLQQHJRJG\SU]H-

ZLGXMHV]PR*OLZRüZLHORNURWQego wykorzystania takiego programu.

•

3UREOHP SRZLQLHQ E\ü GREU]H RNUHORQ\ 2]QDF]D WR *H PXVLV] GRNáDGQLH

ZLHG]LHü MDNLH LQIRUPDFMH PDV] GR G\VSR]\FML L FR FKFHV] X]\VNDü D WDN*H

SRWUDILü ]DSLVDü WR Z IRUPLH GDMFHM VL ÄZ\WáXPDF]\ü´ NRPSXWHURZL 3U]\N-

áDGHPSUREOHPX(OHRNUHORQHJRPR*HE\üÄUR]ZL]DQLH]DGDQLD]IL]\NL´JG\*

QLH ZLDGRPR DQL MDNLPL LQIRUPDFMDPL G\VSRQXMHP\ DQL FR FKFHP\ ZáDFLZLH

Jak to sie robi naprawde?

REOLF]\ü3UDZLGáRZHRNUHOHQLH]DGDQLDPLDáRE\SRVWDüQSÄZ\]QDF]HQLHGURJL

SU]HE\WHMSU]H]FLDáRZVSDGNXVZRERGQ\PZSLHUZV]\FKVHNXQGDFKUXFKX´

3U]\ RND]ML PDP\ WX QDZL]DQLH GR SRSU]HGQLHJR SXQNWX WH VDPH REOLF]HQLD

WU]HEDZ\NRQDüG]LHVLFLRNURWQLHGODVHNXQG

3UREOHPSU]H]QDF]RQ\GRUR]ZL]DQLDSRZLQLHQE\üMDVQR]GHILQLRZDQ\
i

Z\VWDUF]DMFR]áR*RQ\E\WUXGZáR*RQ\ZSURJUDPRZDQLHPyJáVLRSáDFLü

Metoda

3RXVWDOHQLXFRFKFHV]RVLJQüLMDNLPLLQIRUPDFMDPLG\VSRQXMHV]PXVLV]XVWDOLüVSR-

VyE UR]ZL]DQLDSUREOHPX1LHNLHG\MDNZSU]\SDGNXVSDGNX swobodnego) sytuacja

MHVW RF]\ZLVWD QDOH*\ ]DVWRVRZDü Z]yU NWyU\ NWR NLHG\ Z\P\OLá .LHG\ LQG]LHM

WU]HED Z\P\OLü UR]ZL]DQLH VDPHPX :DUWR UyZQLH* ]DVWDQRZLü VL QDG SU]\MFLHP

]DáR*HXSUDV]F]DMF\FKNWyUHPRJ]PQLHMV]\üQDNáDGSUDF\SRWU]HEQ\QDstworzenie

SURJUDPX]QLHZLHONLPXV]F]HUENLHPQDGRNáDGQRFL

3U]\NáDGHP QLHFK EG]LH ZVSRPQLDQD Z SRSU]HGQLP UR]G]LDOH NZHVWLD Z\]QDF]HQLD

UHGQLHMGáXJRFL]GDQLDZWHNFLH3UREOHPQLHMHVWZFDOHZ]LW\Ä]VXILWX´]DUyZQR

]E\WNUyWNLHMDNL]E\WGáXJLH]GDQLD]PQLHMV]DMF]\WHOQRüWHNVWXDE\ZLFQLH]QX-

G]LüF]\WHOQLNDPXVLV]WU]\PDüVLSHZQHJRRSWLPXPZ\QRV]FHJRQS]QDNyZ

2WRNLONDNRQNXUHQF\MQ\FKUR]ZL]DWHJRSUREOHPX

•

XVWDODP\OLF]E]QDNyZ]DZDUW\FKZND*G\P]GDQLXZWHNFLHSRF]\Puzys-

NDQHZDUWRFLXUHGQLDP\0HWRGDWDMHVWGRüRF]\ZLVWDMHGQDNZ\PDJDRNUH-

OHQLDFLVáHMGHILQLFML]GDQLDFRPR*HE\üNáRSRWOLZH

•

SU]\MPXMHP\ XSUDV]F]DMFH ]DáR*HQLH *H ND*GH ]GDQLH NRF]\ VL NURSN
W

W\P PRPHQFLH OLF]ED ]GD Z WHNFLH UyZQD EGzie liczbie kropek (co dla

WHNVWyZOLWHUDFNLFKMHVWZ]DVDG]LHSUDZG]LZH=DWHPZ\VWDUF]\]OLF]\üZV]\-

VWNLH]QDNLZWHNFLHXVWDOLüLOHMHVWZUyGQLFKNURSHNSRG]LHOLüSLHUZV]ZDU-

WRüSU]H]GUXJLZ\QLNJRWRZ\

1DMOHSV]PHWRGQD]QDOH]LHQLHPHWRG\MHVWVSUDZG]HQLHF]\NWRMHMMX*QLH

Z\P\OLá3RXVWDOHQLXPHWRG\ZDUWRWH*]DVWDQRZLüVLQDGMHMXSURV]F]HQLHP

Algorytm

6NRURMX*PDP\PHWRGPXVLP\]DSLVDüMZVSRVyEIRUPDOQ\LV]F]HJyáRZ\3RFR"
Komputer nie jest niestety na tyle intelige

QWQ\E\]UR]XPLHüSROHFHQLHÄ]OLF]ZV]\VWNLH

]QDNLZWHNFLH´

WRWH*PXVLP\QDV]H]DGDQLHSU]HGVWDZLüZVSRVyEEDUG]LHMHOHPHQ-

WDUQ\-DN":áDQLH]DSRPRFDOJRU\WPX

Co prawda niektóre

SURJUDP\ MDN QS :RUG GOD :LQGRZV XGRVWSQLDM SROHFHQLH

]OLF]DQLD]QDNyZZWHNFLHMHGQDNMHVWRQRZáDFLZRFLSURJUDPXQLH]DNRPSXWHUD
i

PXVLDáR]RVWDüZF]HQLHM]DSURJUDPRZDQHSU]H]WZyUFyZHG\WRUD

12 Turbo

Pascal

—

programowanie

=JRGQLH]GHILQLFMDOJRU\WPWRÄ]ELyURNUHORQ\FKUHJXáSRVWSRZDQLDNWyUHUHDlizo-
wa

QH]JRGQLH]XVWDORQ\PSRU]GNLHPXPR*OLZLDMUR]ZL]DQLHRNUHORQHJR]DGDQLD´

3U]HNáDGDMFWRQDEDUG]LHMOXG]NLM]\NPR*HP\SRZLHG]LHü*HDOJRU\WPMHVW]DSLVHP

F]\QQRFLNWyUHQDOH*\NURNSRNURNXZ\NRQDüZFHOXX]\VNDQLDZ\QLNX=DSiVXMF

DOJRU\WPPXVLV]ZLFXVWDOLüMDNLHHOHPHQWDUQHRSHUDFMHEG]LHWU]HEDZ\NRQDüZWUDN-

FLHUHDOL]DFML]DGDQLDLMDNDSRZLQQDE\üLFKNROHMQRü'RGDWNRZRPXVLV]RNUHOLüWDN
zwane kryterium stopu

F]\OLZDUXQHNNWyUHJRVSHáQLHQLHSRZRGXMH]DNRF]HQLHZyko-

Q\ZDQLDRSHUDFMLQLHFKFHV]FK\EDF]HNDüQDZ\QLNZQLHVNRF]RQRü

-DN]DSLVDüDOJRU\WP"1DMSURVWV]\PVSRVREHPMHVWVáRZQHZ\UD*HQLHSRV]F]HJyOQ\FK
operacji w postaci punktów, np. tak:

1. otwórz plik z tekstem do odczytu

2. wyzeruj licznik znaków

3. wyzeruj licznik kropek

MHOLNRQLHFSOLNXWRLG(GRSXQNWX

5. wczytaj kolejny znak z pliku

MHOL]QDNMHVWNURSN]ZLNV]OLF]QLNNURSHNR

]ZLNV]OLF]QLN]QDNyZ

LG(GRSXQNWX

MHOLOLF]QLNNURSHNZ\QRVL]HURLG(GRSXQNWX

10. wypisz (licznik znaków/(licznik kropek))

11. STOP

7R VDPR PR*QD SU]HGVWDZLü Z SRVWDFL JUDILF]QHM ]ZDQHM VFKHPDWHP EORNRZ\P OXE
z angielska flowchart.

6FKHPDW SRVWSRZDQLD PR*QD ZUHV]FLH ]DSLVDü Z SRVWDFL WDN ]ZDQHJR pseudokodu,

F]\OLLPLWDFMLÄSUDZG]LZHJR´M]\NDSURJUDPRZDQLD

start
otwórz(plik);
znaki := 0;
kropki := 0;
dopóki nie koniec_pliku(plik)
start
czytaj (plik,znak)

MH*HOL]QDN µ¶
kropki := kropki+1;
znaki := znaki+1;
stop;
wypisz(znaki/kropki);
stop.

-DNWRVLURELQDSUDZG"

Start

Otwórz plik do odczytu

Licznik znaków := 0

Licznik kropek := 0

Czy koniec pliku?

Czytaj znak

Nie

Czy znak

jest kropk¹?

Nie

Zwiêksz licznik znaków

Czy licznik

kropek = 0?

Nie

Wypisz (licznik znaków / licznik kropek)

Stop

Tak

Zwiêksz licznik kropek

Tak

Rysunek 1.

6FKHPDWEORNRZ\REOLF]DQLDUHGQLHMOLF]E\]QDNyZZ]GDQLX

.D*GD ] SRZ\*V]\FK PHWRG PD VZRMH ZDG\ L ]DOHW\ =DSLV SRV]F]HJyOQ\FK NURNyZ
w po

VWDFL SXQNWyZ MHVW SURVW\ DOH SU]\ EDUG]LHM ]áR*RQ\FK ]DGDQLDFK VWDMH VL PDáR

F]\WHOQ\=DSLVZSRVWDFLVFKHPDWXEORNRZHJRMHVWEDUG]RF]\WHOQ\DOHSUDFRFKáRQQ\
w wyko

QDQLX:UHV]FLH]DSLVZSVHXGRNRG]LHPDW]DOHW*HSRSU]HWáXPDF]HQLXQD

M]\NDQJLHOVNLVWDMHVLSUDNW\F]QLHJRWRZ\PWHNVWHPSURJUDPX

: P\O WHJR FR SRZLHG]LHOLP\ QD ]DNRF]HQLH SRSU]HGQLHJR SXQNWX QLH PXVLV] D
na

ZHW QLH SRZLQLHQH Z\P\ODü DOJRU\WPX VDPRG]LHOQLH -HVW WR FR SUDZGD ]DMFLH

14 Turbo

Pascal

—

programowanie

EDUG]RNV]WDáFFHLSU]\QRV]FHGX*RVDW\VIDNFMLLQWHOHNWXDOQHMMHGQDNF]VWRRND]XMH

VL*HNRU]\VWDMF]JRWRZ\FKUR]ZL]DPR*QD]URELüWRVDPR]QDF]QLHHIHNW\ZQLHM
i

V]\EFLHM 1LHNWyUH SUREOHP\ V QDWRPLDVW QD W\OH QLHW\SRZH L* PHWRG LFK

UR]ZL]DQLDWU]HEDZ\P\OLüRGSRGVWDZ

2PDZLDMFDOJRU\WP\QLHVSRVyESRPLQüNZHVWLLVWUXNWXUGDQ\FK-HVWRF]\ZLVWHL*

UR]ZL]DQLH MDNLHJRNROZLHN SUREOHPX ZL*H VL ] SU]HWZDU]DQLHP LQIRUPDFML 7 ]

NROHL WU]HED MDNR SU]HFKRZDü QLH PyZLF MX* R ZSURZDG]HQLX MHM GR NRPSXWHUD L

Sy(QLHMV]\P Z\SURZDG]HQLX .RPSXWHURZH VSRVRE\ UHSUH]HQWRZDQLD LQIRUPDFML V

]QDF]QLH FLOHM RNUHORQH D MHGQRF]HQLH ]QDF]QLH PQLHM Uy*QRURGQH QL* WH NWyU\FK

X*\ZDP\QDFRG]LH:ZLNV]RFLSU]\SDGNyZGREyURGSRZLHGQLHMVWUXNWXU\GDQ\FK
jest automa

W\F]Q\JG\*DOERQDU]XFDVLVDPQSUR]ZL]XMF]DGDQLHPDWHPDW\F]QH

QLH EG]LHV] SU]HdVWDZLDá OLF]E Z SRVWDFL ]QDNRZHM DOER MHVW Z\PXV]RQ\ SU]H]

DOJRU\WP &]DVHP MHGQDN VSUDZD QLH MHVW WDN RF]\ZLVWD 3U]\NáDGRZR NRQVWUXXMF

SURJUDP ]DMPXMF\ VL SU]HWZaU]DQLHP GDQ\FK RVRERZ\FK SUDFRZQLNyZ PR*HV]

]GHF\GRZDüVLQDSU]HFKRZ\ZDQLHW\FK*HGDQ\FKZWDN]ZDQ\FKWDEOLFDFKOXEOLVWDFK

2E\GZDUR]ZL]DQLDPDMVZRMH]DOeW\LZDG\MDNUyZQLH*ZL*VL]]DVWRVRZDQLHP

RGSRZLHGQLFKPHWRGSU]HWZDU]DQLDGDQ\FKF]\OLZáDQLHDOJRU\WPyZ

Projekt

-DNMX*SRZLHG]LHOLP\DOJRU\WPSU]H]QDF]RQ\MHVWGRUR]ZL]DQLD]DVDGQLF]HMF]FL

]DGDQLD L ÄQLH SU]HMPXMH VL´ WDNLPL GHWDODPL MDN ZSURZDG]HQLH L Z\SURZDG]HQLH

GDQ\FKF]\XWZRU]HQLHVWUXNWXUGDQ\FK1DGRGDWHNZLNV]RüSUREOHPyZMHVWQDW\OH
skompliko

ZDQD L* QLH GDMH VL UR]ZL]Dü ]D MHGQ\P ]DPDFKHP : WDNLHM V\WXDFML

PXVLV] UR]ELü VZRMH ]DGDQLH QD PQLHMV]H IUDJPHQW\ GDMFH VL Z\UD]Lü ]D SRPRF
pro

VW\FKDOJRU\WPyZLX]XSHáQLüWHQ]HVWDZSU]H]RSLVRSHUDFMLSRPRFQLF]\FK:V]\-

VWNRWRQDOH*\SRZL]DüZVSyMQFDáRü]ZDQprojektem programu.

3URMHNW\PRJE\üWZRU]RQHGZLHPDSU]HFLZVWDZQ\PLPHWRGDPL]QDQ\PLMDNRSUR-
jekto

ZDQLH ZVWSXMFH DQJ bottom-up design RUD] SURMHNWRZDQLH ]VWSXMFH DQJ

top-down design

3LHUZV]D]QLFKMHVWUHDOL]DFM]DVDG\ÄRGV]F]HJyáXGRRJyáX´QD

samym po

F]WNX RNUHODP\ ]HVWDZ HOHPHQWDUQ\FK ]DGD NWyU\FK Z\NRQDQLH EG]LH

NRQLHF]QH GR UHDOL]DFML JáyZQHJR SUREOHPX np. wprowadzanie danych,
wyprowadzanie wyników, obli

F]DQLH ZDUWRFL SRUHGQLFK 3R VNRQVWUXRZDQLX WDNLFK

FHJLHáHN EXGXMHP\ ] QLFK ZLNV]H VWUXNWXU\ ]DMPXMFH VL SU]HWZDU]DQLHP

RGSRZLHGQLR ZLNV]\FK IUDJPHQWyZ ]DGDQLD ] W\FK — struktury jeszcze bardziej

RJyOQH D* Z NRFX GRFKRG]LP\ GR JáyZQHJR VFKHPDWX G]LDáDQLD NWyU\ ]DU]G]D

SRV]F]HJyOQ\PLPRGXáDPL

3URMHNWRZDQLH]VWSXMFHMDNQLHWUXGQRVLGRP\ODüZ\JOGDRGZURWQLH3RF]WNLHP

SURFHVXMHVWRJyOQHVIRUPXáRZDQLH]DGDQLDNWyUHQDVWSQLHSRGGDMHVLDQDOL]LHLUR]bi-

FLXQDZVSyáG]LDáDMFH]HVREF]FLWH]DG]LHOLVLGDOHMD*GRX]\VNDQLDHOHPHQ-

WDUQ\FK IUDJPHQWyZ NWyU\FK ]DSURJUDPRZDQLH MHVW MX* áDWZH D QDZHW W\SRZH

-HGQRF]HQLH QD ND*G\P HWDSLH SRG]LDáX XOHJDM XFLOHQLX NRPSHWHQFMH SRV]F]H-

JyOQ\FKIUDJPHQWyZSURJUDPXDUDF]HMSURMHNWXF]\OL]DNUHVSU]HWZDU]DQ\FKSU]H]H

GDQ\FKLSRVWDü]ZUacanych wyników.

Jak to sie robi naprawde?

1LH]DOH*QLH RG WHJR MDN PHWRG ]DVWRVXMHV] HIHNWHP SURMHNWRZDQLD SRZLQQR E\ü

XFLOHQLH Z\EUDQHM PHWRG\ UR]ZL]DQLD ]DGDQLD L GRVWRVRZDQLH MHM GR NRQNUHWQ\FK

RNROLF]QRFL L PR*OLZRFL 2VLJD VL WR UR]ELMDMF ]DGDQLHQDHOHPHQWDUQHVNáDGQLNL

NWyU\FKUR]ZL]DQLH]RVWDáRMX*RSLVDQHOXEMHVWáDWZHGRVDPRG]LHOQHJRRSUDFRZDQLD
Gotowy projekt

PR*HSU]\MüSRVWDüSRGREQGRRPDZLDQ\FKSU]\RND]MLDOJRU\WPyZ

]DSLVX VáRZQHJR OXE JUDILF]QHM UHSUH]HQWDFML FLJX F]\QQRFL 2GSRwiednie zapisanie

SRV]F]HJyOQ\FKHOHPHQWyZSURMHNWX]QDF]QLHXáDWZL&LMHJRLPSOHPHQWDFMRUD]SU]\-

V]áHZSURZDG]DQLH]PLDQLXOHSV]H

Implementacja

8II 3U]\QDMPQLHM Z WHRULL ZV]\VWNR SRZLQQR MX* G]LDáDü '\VSRQXMF RGSRZLHGQLR

UR]SLVDQ\PSURMHNWHPPR*QDSU]\VWSLüGRPHFKDQLF]QHMZ]DVDG]LHF]\QQRFLSURJ-
ramowania.

7DNWRQLHSRP\áNDSUDNW\F]QLHFDáRüSUDF\XP\VáRZHMSRZLFDQHMQD

UR]ZL]DQLH GDQHJR ]DGDQLD SRSU]H] SURJUDPRZDQLH VNXSLD VL Z HWDSDFK RSLVDQ\FK

SRSU]HGQLR 6DPR SURJUDPRZDQLHNRGRZDQLHMHVWMHG\QLHF]\QQRFLSROHJDMFQD

SU]HWáXPDF]HQLX ]DSLVX SURMHNWX QD RGSRZLHGQL ]DSLV V\PEROLF]Q\ F]\OL WDN ]ZDQy

M]\NSURJUDPRZDQLDQDMF]FLHMZ\VRNLHJRSR]LRPX

=DQLPGRWHJRGRMG]LHPR*HV]MHV]F]HVWDQüSU]HGNRQLHF]QRFLZ\ERUXRGSRwied-

QLHJRM]\NDF]\OLQDU]G]LDSUDF\]DNáDGDMF*HPDV]]F]HJRZ\ELHUDüWMSRWUDILV]

VLSRVáXJLZDüNLONRPDM]\NDPi).

Uruchomienie

8UXFKDPLDQLH ZLH*R QDSLVDQ\FK SURJUDPyZ QDOH*\ GR EDUG]LHM HNVF\WXMF\FK
momen

WyZZ*\FLXSURJUDPLVW\3HáQ\SURFHVXUXFKDPLDQLDVNáDGDVL]NLONXHWDSyZ

NWyUHNUyWNRRSLV]HP\SRQL*HM

1DSLVDQ\ SURJUDP QDOH*\ SR SLHUZV]H SU]HWáXPDF]\ü QD SRVWDü Z\NRQ\ZDOQ SU]H]

NRPSXWHUF]\OLQDRJyáVNRPSLORZDüJR:LNV]RüQDU]G]LSURJUDPLVW\F]Q\FKVNX-

WHF]QLH Z\áDSLH SU]\ WHM RND]ML ZV]HONLH EáG\ OLWHURZH L VNáDGQLRZH NWyUH PLDáH

RND]MSRSHáQLüSRGF]DVZSLV\ZDQLDSURJUDPXEáG\WDNLH]ZDQHVRJyOQLHEáGDPL
kompilacji).

3RZ\HOLPLQRZDQLXZV]\VWNLFKEáGyZNRPSLODFMLPR*HV]VSUyERZDüZ\NRQDüSURJ-
ram. Przedtem jednak

EH]Z]JOGQLH]DSLV]JRQDG\VNX. W przypadku bardziej skom-

SOLNRZDQ\FKSURJUDPyZHIHNW\SLHUZV]HJRXUXFKRPLHQLDPRJE\üGRü]DVNDNXMFH

] ]DZLHV]HQLHP NRPSXWHUD ZáF]QLH OHSLHM ]DSDPLWDü SURJUDP QL* QDUD*Dü VL QD

NRQLHF]QRü RGWZDU]DQLD F]FL OXE FDáRFL Z\QLNyZ SUDF\ :V]HONLH EáG\ NWyUH

SRMDZLDMVLZWUDNFLHSUDF\MX*XUXFKRPLRQHJRSURJUDPXQRV]QD]ZEáGyZZyko-
nania

%áG\WHPRJSRZRGRZDüSU]HUZDQLHG]LDáDQLDSURJUDPXDQDZHW]DZLHV]HQLH

lub restart komputera) lub jego zachowanie niezgodne z oczekiwaniami (np. brak

UHDNFML QD G]LDáDQLD X*\WNRZQLND ]ZUDFDQLH EáGQ\FK Z\QLNyZ -HOL SURJUDP SR
uruchomieni

X]DFKRZXMHVLZPLDUSRSUDZQLHWMQLH]DZLHVLáVLUHDJXMHQDSUyE\

16 Turbo

Pascal

—

programowanie

komu

QLNRZDQLD VL ] QLP ]ZUDFD Z PLDU SRSUDZQH Z\QLNL L GDMH VL ]DNRF]\ü

PR*HV]SU]HMüGRMHJRWHVWRZDQLD

7HVWRZDQLH SURJUDPX SROHJD ] JUXEV]D QD EDGDQLX MHJR UHDNFML QD Uy*ne zachowania

X*\WNRZQLND 3U]HGH ZV]\VWNLP QDOH*\ VSUDZG]Lü F]\ Z\QLN SUDF\ SURJUDPX MHVW
zgod

Q\ ] QDV]\PL RF]HNLZDQLDPL -HOL WDN ZDUWR VSUyERZDü SRGU]XFLü PX GR

przetwo

U]HQLD LQQH GDQH GOD NWyU\FK Z\QLN ]QDP\ OXE SRWUDILP\ REOLF]\ü 'REyU

danych d

R WHVWRZDQLD QLH SRZLQLHQ E\ü SU]\SDGNRZ\ OHF] ZLQLHQ RSLHUDü VL QD

SU]HZLG\ZDQLX PR*OLZ\FK VáDE\FK SXQNWyZ SURJUDPX 3U]\NáDGRZR MHOL SURJUDP

]DMPXMH VL REVáXJ NDUWRWHNL SUDFRZQLNyZ ZDUWR VSUDZG]Lü MHJR ]DFKRZDQLH Z

SU]\SDGNX QLHSRGDQLD *DGQHJR QD]ZLVND SRGDQLD QD]ZLVND GáX*V]HJR QL* SU]\MWH

PDNVLPXPLWS'REUPHWRGMHVWUyZQLH*WHVWRZDQLHSURJUDPyZSU]H]X*\WNRZQLNyZ

NWyU]\]Z\NOHQLHPDMSRMFLDR]DVDGDFKIDLUSOD\RERZL]XMF\FKZSURJUDPRZDQLX

L SRWUDIL EDUG]R VNXWHF]QLH ÄUR]áR*\ü´ SURJUDP\ XZD*DQH SU]H] LFK WZyUFyZ ]D

FDáNRZLFLH EH]EáGQH : SU]\SDGNX XUXFKDPLDQLD EDUG]R RSRUQ\FK SURJUDPyZ

QLHRFHQLRQHXVáXJLRGGDMZUHV]FLHW]ZQDU]G]LDXUXFKRPLHQLRZH*DUJRQRZR]ZDQH
debuggerami

3R]ZDODMRQHQDOHG]HQLHLDQDOL]]DFKRZDQLDSURJUDPów instrukcja

SRLQVWUXNFMLFRXPR*OLZLDORNDOL]DFMQDZHWEDUG]RZ\UDILQRZDQ\FKEáGyZ

Zdrowy rozsadek

-HVW RQ QDMZD*QLHMV]\P HOHPHQWHP SURFHVX SURJUDPRZDQLD D GRNáDGQLHM

MDNLHMNROZLHN G]LDáDOQRFL SUDNW\F]QHM SRGHMPRZDQHM Z *\FLX =DVWRVRZDQLH
zdro

ZHJRUR]VGNXZ SURJUDPRZDQLXVSURZDG]DVLSU]HGHZV]\VWNLPGR]DFKRZDQLD

odpowiedniej pro

SRUFMLSRPLG]\WUHFLLIRUPRUD]GRERUXPHWRGRGSRZLHGQLFKGR

UHDOL]RZDQ\FK]DGD$E\UR]ZL]DüUyZQDQLHNZDGUDWRZHPR*HV]RF]\ZLFLHQDSLVDü
w Borland C++ 5.0

RGSRZLHGQLSURJUDPGOD:LQGRZVZ\NRQXMFXSU]HGQLRVROLGQH

przygotowanie w postaci schematu blokowego, listy zmiennych i spisu literatury.

0R*HV] UyZQLH* QLF QLH SLVDü D MHG\QLH VLJQü SR NDONXODWRU : ZLNV]RFL

SU]\SDGNyZ QDMOHSV]H MHVW UR]ZL]DQLH kompromisowe, tj. napisanie krótkiego
programiku w Turbo Pascalu.

6DPRSU]\JRWRZDQLHWHRUHW\F]QHUyZQLH*SRZLQQRE\üWUDNWRZDQH]XPLDUHP'REyU

DOJRU\WPXF]\RSUDFRZDQLHSURMHNWXEDUG]RF]VWRZ\NRQ\ZDQHVDXWRPDW\F]QLH]D
ich rozpisywanie ma na celu

MHG\QLH XáDWZLHQLH LFK ]UR]XPLHQLD L QLH SRZLQQR E\ü

FHOHPVDP\PZVRELH3U]HZD*DMFDF]ü]DGDNWyUHEG]LHV]UR]ZL]\ZDáMHVWQD

W\OHSURVWDL*QLHZ\PDJDVSHFMDOQ\FKSU]\JRWRZD3RZ\*V]HXZDJLSRZLQLHQHZLF

WUDNWRZDü UDF]HM MDNR VSRVRE\ XáDWZLHQLD VRELH UR]ZL]\ZDQLD EDUG]LHM ]áR*RQ\FK
prob

OHPyZ HZHQWXDOQLH RUJDQL]RZDQLD SUDF\ ]HVSRáRZHM R LOH PDV] ]DPLDU ]RVWDü

zawo

GRZ\PSURJUDPLVW

'\VSRQXMFW\PLZLDGRPRFLDPLPR*HV]MX*VSRNRMQLHSU]HMüGRG]LHáD:NROHMQ\P

UR]G]LDOH]DSR]QDV]VL]QDU]G]LHP]DSRPRFNWyUHJREG]LHV]WZRU]\áSURJUDP\

Narzedzie

1DU]

dzie

6NRUR SRZLHG]LHOLP\ MX* NLOND VáyZ QD WHPDW WHRULL F]DV RPyZLü SRGVWDZ G]LDáDO-

QRFLSUDNW\F]QHM—M]\NSURJUDPRZDQLDF]\OLQDU]G]LH]DSRPRFNWyUHJRWZRU]\

VLSURJUDP\-]\NSURJUDPRZDQLDXPR*OLZLD]DSLVDQLHZ]UR]XPLDáHMGODF]áRZLHND

SRVWDFL F]\QQRFL NWyUH PDM ]RVWDü ]UHDOL]RZDQH SU]H] NRPSXWHU 2GSRZLHGQLH

QDU]G]LH ]ZDQH translatorem F]\OL WáXPDF]HP SU]HNáDGD WDNL ]DSLV QD LQVWUXNFMH

]UR]XPLDáH GOD NRPSXWHUD 1RZRF]HVQH QDU]G]LD GR WZRU]HQLD SURJUDPyZ ]Z\NOH

]DZLHUDM RSUyF] WUDQVODWRUD UyZQLH* edytor SR]ZDODMF\ QD ZSURZDG]DQLD L SRSUD-
wianie tekstu programu, konsolidator

XPR*OLZLDMF\ HIHNW\ZQH WZRU]HQLH ZLNV]\FK

programów, program uruchomieniowy (ang. debugger)

XáDWZLDMF\ORNDOL]DFMLXVX-

ZDQLHEáGyZZSURJUDPDFKRUD]Uy*QHQDU]G]LDSRPRFQLF]H

/LF]ED M]\NyZ SURJUDPRZDQLD X*\ZDQ\FK REHFQLH QD ZLHFLH VLJD VHWHN MHGQDN

W\ONRNLOND]\VNDáRVRELHSRSXODUQRüQDW\OHGX*E\]DVWDQDZLDüVLQDGLFKZ\Era-
nie

P 6 WR EH] ZWSLHQLD M]\NL %DVLF & L 3DVFDO .WyU\ ] QLFK Z\EUDü" %DVLF MHVW

M]\NLHPSURVW\PLSRSXODUQ\PMHGQDNQLHSURPXMHQDZ\NyZHOHJDQFNLHJRSURJramo-

ZDQLD-]\N&]\VNDáVRELHRVWDWQLRRJURPQSRSXODUQRüL]GRPLQRZDáURGRwisko
zawodowych p

URJUDPLVWyZ -HGQDN L RQ QLH QDGDMH VL ]E\WQLR GR QDXNL SRGVWDZ

SURJUDPRZDQLD ]H Z]JOGX QD Z\VRNL SR]LRP NRPSOLNDFML L PDáR F]\WHOQ VNáDGQL

7U]HFL ] NDQG\GDWyZ 3DVFDO XVWSXMH QLHFR SRSXODUQRFL M]\NRZL & MHVW MHGQDN
znacznie czytelniejszy i prze

]WRQDMF]FLHMX*\ZDQ\GRFHOyZG\GDNW\F]Q\FK

: GDOV]\P FLJX QDV]HJR Z\NáDGX EG]LHP\ ZLF X*\ZDOL M]\ND 3DVFDO -HGQ ]

ZFL*QDMSRpularniejszych wersji Pascala przeznaczonych dla komputerów PC jest bez

ZWSLHQLD7XUER3DVFDOVWDQRZLF\ZUF]LGHDOQHQDU]G]LHGRQDXNLLWZRU]HQLD

PQLHMVNRPSOLNRZDQ\FKSURJUDPyZ-HJRWH*Z\ELHU]HP\MDNRQDU]G]LHQDV]HMSUDF\

SRGVWDZRP SRVáXJLZDQLD VL URGRZLVNLHP 7XUER 3DVFDOD SRZLFLP\ UHV]W WHJR

UR]G]LDáX

=DF]QLMP\ RG XUXFKRPLHQLD QDV]HJR QDU]G]LD 1D SRF]WHN U]HF] MDVQD PXVLV]

ZáF]\üNRPSXWHUDSRZ\ZLHWOHQLX]QDNXJRWRZRFLV\VWHPXRSHUDF\MQHJR]Z\NOH

C:\>

QDSLVDü

turbo

↵

18 Turbo

Pascal

—

programowanie

-HOLX*\ZDV]V\VWHPX:LQGRZVPXVLV]ZF]HQLHMSU]HMüGR'26-u (w tym celu

]QDMG(LNOLNQLMGZXNURWQLHLNRQ06-'263URPSW-HOL7XUER3DVFDOMHVW

GRVWSQ\SRGSRVWDFLLNRQ\PR*HV]JRXUXFKRPLüNOLNDMFQDQLHMGZXNURWQLH

0R*H VL MHGQDN RND]Dü *H SR Z\GDQLX SRZ\*V]HJR SROHFHQLD XMU]\V] QD HNUDQLH
komunikat

Bad command or file name

R]QDF]DMF\*HZ\ZRá\ZDQ\SURJUDPQLHMHVWGRVWSQ\]SR]LRPXELH*FHJRNDWDORJX

OXEZRJyOHQLH]RVWDá]DLQVWDORZDQ\:WDNLHMV\WXDFMLPXVLV]RGV]XNDüNDWDORJ]DZLH-

UDMF\ NRPSLODWRU 7XUER 3DVFDOD R QD]ZLH

TURBO

EXE

(zwykle jest to katalog

BIN

lub

BIN

L GRáF]\ü MHJR QD]Z GR W]Z V\VWHPRZHM FLH*NL GRVWSX,

XPR*OLZLDMFHM Z\ZRá\ZDQLH SURJUDPyZ ]QDMGXMF\FK VL Z NDWDORJDFK LQQ\FK QL*

ELH*F\ : W\P FHOX GR ]QDMGXMFHJR VL Z SOLNX

AUTOEXEC

BAT

polecenia PATH

GRSLV]QDNRFXUHGQLNDSRQLPQD]ZNDWDORJX]DZLHUDMFHJR7XUER3DVFDODQS

path=c:\dos;c:\windows;c:\norton;c:\tp7

-H*HOLQLHXGD&LVLRGV]XNDü7XUER3DVFDODEG]LHV]PXVLDáJR]DLQVWDORZDü:W\P

FHOXZH(SLHUZV]]G\VNLHWHNLQVWDODF\MQ\FKSURJUDPXRSLVDQÄ,QVWDOO´Záy*MGR

QDSGX

(lub

) i napisz

install

↵

Uruchomiony w ten sposób program instalacyjny dostarczy Ci dalszych wskazówek

RGQRQLHLQVWDODFML:LFHMLQIRUPDFMLQDWHPDWLQVWDODFMLLZ\ZRá\ZDQLD7XUER3DVFDOD

]QDMG]LHV]ZOLWHUDWXU]H>@PR*HV]UyZQLH*]DVLJQüSRPRF\ORNDOQHJRVSHFMDOLVW\RG
komputerów.

-HOL XGDáR &L VL EH]NROL]\MQLH Z\ZRáDü 7XUER 3DVFDOD QD HNUDQLH PRQLWRUD SRZL-

QLHQH]REDF]\üZLGRNSU]HGVWDZLRQ\QDVVLHGQLPU\VXQNX

URGNRZF]üHNUDQX]DMPXMHREV]HUQHRNQRZNWyU\P]QDMGXMHVLPLJDMF\NXUVRU
Okno to, zwane okienkiem edytora

EG]LHVáX*\áRQDPGRZSLV\ZDQLDLpoprawiania

SURJUDPyZ1DVDPHMJyU]HHNUDQX]QDMGXMHVLPHQXJáyZQH]DZLHUDMFHJUXS\SROH-

FH VáX*F\FK GR ]DU]G]DQLD SURJUDPHP :UHV]FLH QDMQL*V]\ ZLHUV] HNUDQX — tak
zwany wiersz statusowy —

]DZLHUDLQIRUPDFMHQDWHPDWQDMF]FLHMZ\NRU]\VW\ZDQ\FK

NRPELQDFMLNODZLV]\OXEDNWXDOQHJRVWDQXSURJUDPX:V]\VWNLHHOHPHQW\GRVWSQHSR-

SU]H] RNQR HG\WRUD PHQX JáyZQH RUD] NRPELQDFMH NODZLV]\ WZRU] UD]HP zintegro-

ZDQH URGRZLVNR URERF]H 7XUER 3DVFDOD RNUHODQH UyZQLH* DQJLHOVNLP VNUyWHP ,'(
(Integrated Development Environment).

-HOLSRZ\ZRáDQLX7XUER3DVFDOD]REDF]\V]QDHNUDQLHMHG\QLHMDVQHWáR

EG]LHV]PXVLDáRWZRU]\üRNLHQNRHG\WRUDSROHFHQLHPNew (Nowy) z menu File

3OLN6SRVyESRVáXJLZDQLDVLPHQXSR]QDV]]DFKZLO

1DU]G]LH

PHQXJáyZQH

wiersz statusowy

Rysunek 2.

=LQWHJURZDQHURGRZLVNRURERF]H,'(7XUER3DVFDOD

Omawianie poszczególnych elementów IDE zaczniemy od góry ekranu, czyli od menu

JáyZQHJR0HQX7XUER3DVFDOD]DZLHUDG]LHVLüSR]\FML

File

(Plik) —

]DZLHUDSROHFHQLDXPR*OLZLDMFHRGF]\Wywanie, zapisywanie

GUXNRZDQLHWHNVWyZSURJUDPyZDWDN*H]DNRF]HQLHSUDF\

Edit

(Edycja) —

]DZLHUD SROHFHQLD SR]ZDODMFH QD PRG\ILNDFM WHNVWX

progra

PXLSU]HQRV]HQLHIUDJPHQWyZWHNVWXSRPLG]\SURJramami;

Search

(Wyszukiwanie) —

]DZLHUDSROHFHQLDVáX*FHGRZ\V]XNLZDQLDL]D-

mia

Q\IUDJPHQWyZWHNVWXSURJUDPXRUD]ORNDOL]DFMLEáGyZ

Run

(Uruchomienie) —

]DZLHUD SROHFHQLD VWHUXMFH Z\NRQDQLHP JRWR-

wego programu;

Compile (Kompilacja) —

]DZLHUD SROHFHQLD XPR*OLZLDMFH NRPSLODFM F]\OL

prze

WáXPDF]HQLHWHNVWX(UyGáRZHJRSURJUDPXQDSRVWDüZ\QLNRZ—

Z\NRQ\ZDOQSU]H]NRPSXWHU

Debug

(

8VXZDQLH EáGyZ) — ]DZLHUD SROHFHQLD XáDWZLDMFH XVXZDQLH Eá-

dów z

SURJUDPyZLZVSRPDJDMFHLFKXUXFKDPLDQLH

Tools

(

1DU]G]LD) —]DZLHUDSROHFHQLDXPR*OLZLDMFHZ\ZRáDQLHSRPRFQL-

F]\FKSURJUDPyZ]HZQWU]Q\FK

Options (Opcje) —

]DZLHUDSROHFHQLDSR]ZDODMFHQDNRQILJXURZDQLHHOHmen-

tów IDE (kompilatora, edytora, programu uruchomieniowego), czyli
dos

WRVRZDQLHLFKGRZ\PRJyZLSRWU]HEX*\WNRZQLND

Window (Okno) — zawiera p

ROHFHQLDVWHUXMFHXNáDGHPRNLHQHNQDHNUDQLH

Help

(Pomoc) —

]DZLHUD SROHFHQLD XPR*OLZLDMFH GRVWS GR REV]HUQHJR

systemu pomocy (suflera) Turbo Pascala.

20 Turbo

Pascal

—

programowanie

-DNGRVWDüVLGRSROHFH]DZDUW\FKZPHQX"0HWRGMHVWNLOND0R*HV]QSQDFLVQü
klawisz

F10

D QDVWSQLH Z\EUDü *GDQ SR]\FM RSFM PHQX JáyZQHJR X*\ZDMF

NODZLV]\ NXUVRUD VWU]DáHN

←

oraz

→

L ÄUR]ZLQü´ M QDFLVNDMF

NTER

. Znacznie

SURFLHM MHVW MHGQDN Z\NRU]\VWDü NRPELQDFM NODZLV]D

] Z\Uy*QLRQ Z QD]ZLH

RSFMLOLWHUQDSU]\NáDGGODPHQXFileEG]LHPXVLV]MHGQRF]HQLHQDFLVQüNODZLV]H

7U]HFL PR*OLZRFL MHVW X*\FLH P\V]NL — Z W\P FHOX PXVLV] NOLNQü MHM

OHZ\PSU]\FLVNLHPSRZVND]DQLXZ\EUDQHMSR]\FMLPHQXJáyZQHJR

1LH]DOH*QLHRGWHJRNWyUHMPHWRG\X*\MHV]Z\EUDQLHGRZROQHMSR]\FML]PHQXJáyZ-

QHJRVSRZRGXMHSRMDZLHQLHVLNROHMQHJRPHQXW]Zmenu rozwijanego lub z angiel-
ska pull-down menu

]DZLHUDMFHJREDUG]LHMV]F]HJyáRZ\Z\ND]SROHFH]ZL]DQ\FK

GDQ\PWHPDWHP$E\Z\EUDü*GDQHSROHFHQLHPXVLV]W\PUD]HPX*\üNODZLV]\

↑

lub

↓

L RF]\ZLFLH

NTER

QDFLVQü NODZLV] RGSRZLDGDMF\ Z\Uy*QLRQHM OLWHU]H

(uwaga: tym razem bez klawisza

HZHQWXDOQLHNOLNQüZRGSRZLHGQLPPLHMVFX

P\V]N=DXZD*SU]\WHMRND]ML*HQLHNWyU\PSROHFHQLRPWRZDU]\V]QD]Z\NODZLV]\

IXQNF\MQ\FKVSHFMDOQ\FKOXELFKNRPELQDFMLZ\ZLHWORQHZPHQX]SUDZHMVWURQ\6
to tak zwane klawisze skrótu (shortcut keys

XPR*OLZLDMFHZ\ZRáDQLHGDQHJRSROHce-

QLDEH]UR]ZLMDQLDPHQX8*\FLHNODZLV]\VNUyWX]QDF]QLHXSUDV]F]DNRU]\VWDQLH],'(

WRWH*ZDUWR]DSDPLWDüNLOND]QLFKQS

— zapisanie programu na dysku,

TRL

-F9

— uruchomienie programu itd.).

2WRSU]\NáDGDE\RWZRU]\üQRZHRNLHQNRHG\WRUDPXVLV]Z\GDüSROHFHQLHFile-New,

F]\OLZ\EUDü]PHQXJáyZQHJR

F10

SR]\FMFile (

D]UR]ZLQLWHJRPHQXSROHce-

nie New (Nowy). Menu File

PR*HV] UyZQLH* UR]ZLQü ]D SRPRF P\V]NL OXE QDFLV-

NDMFMHGQRF]HQLHNODZLV]H

(

-F

$E\ZUHV]FLH]DNRF]\üSUDFZ,'(

Z\VWDUF]\ QDFLVQü NODZLV] VNUyWX

-X

PR*QD ]URELü WR VDPR ]D SRPRF PHQX

FKRFLD*MHVWWRQLHFREDUG]LHMF]DVRFKáRQQH

wybrana opcja

Rysunek 3.

5R]ZLQLWHPHQXFile

1DU]G]LH

=DXZD*SU]\RND]ML*HUR]ZLQLFLHPHQXZL*HVL]H]PLDQ]DZDUWRFLZLHUV]DVWD-

WXVRZHJRZNWyU\PEG]LHVLREHFQLH]QDMGRZDáNUyWNLRSLVZ\EUDQHJRSROHFHQLDOXE
opcji.

6NRURSRWUDILP\MX*RWZRU]\üRNLHQNRHG\WRUDPR*HP\Z\SUyERZDüMHJRPR*OLZRFL

7UHüZSLV\ZDQHJRWHNVWXQLHPDQDUD]LH]QDF]HQLDDOHMHOLFKFHV]PR*HV]RGUD]X

]DMU]HüGRQDVWSQHJRUR]G]LDáXLZSLVDü]QDMGXMF\VLWDPSURJUDPSU]\Náadowy. Jak

MX* SUDZGRSRGREQLH ZLHV] GR ZSURZDG]DQLD WHNVWX VáX* W]Z klawisze alfanu-
meryczne

F]\OLJáyZQ\EORNNODZLV]\]DZLHUDMF\OLWHU\4:(57<LF\IU\%ORNWHQ

]DZLHUDUyZQLH*NLONDGRGDWNRZ\FKNODZLV]\]DZLHUDMF\FKV\PEROHQSF]\!RUD]

NODZLV]HVSHFMDOQHNWyU\PL]DMPLHP\VLQL*HM=DXZD**HSRGF]DVZSLV\ZDQLDNXUVRU

PLJDMF\]QDNSRGNUHOHQLDSU]HVXZDVLWDNE\]DZV]HZVND]\ZDüQDSR]\FMNROHM-

QHJR ZSURZDG]DQHJR ]QDNX ]D SR SU]HNURF]HQLX SUDZHJR EU]HJX RNLHQND WHNVW QLH
jest aut

RPDW\F]QLHáDPDQ\MDNZZLNV]RFLHG\WRUyZWHNVWX-HOLU]XFLV]RNLHPQD

UDPN RWDF]DMF RNLHQNR HG\WRUD WR Z RNROLF\ OHZHJR GROQHJR URJX ]DXZD*\V]
gwiaz

GNLGZLHOLF]E\UR]G]LHORQHGZXNURSNLHP*ZLD]GNDV\JQDOL]XMH*H]DZDUWRü

okien

ND HG\WRUD ]RVWDáD ]PRG\ILNRZDQD SU]H] GRSLVDQLD OXE XVXQLFLH WHNVWX ]D

OLF]E\ R]QDF]DM QXPHU ZLHUV]D L NROXPQ\ Z NWyU\FK ]QDMGXMH VL NXUVRU 2NLHQNR

HG\WRUD PD V]HURNRü FR QDMZ\*HM ]QDNyZ PR*QD MH SRPQLHMV]\ü L GREU\P
zwyczajem jest nieprzekraczanie te

MZáDQLHGáXJRFLZLHUV]D

=QDMGXMFHVLQDNODZLDWXU]HNODZLV]HVSHFMDOQHLIXQNF\MQHQLHVáX*GREH]SRUHG-

QLHJR ZSURZDG]DQLD WHNVWX XPR*OLZLDM MHGQDN MHJR SRSUDZLDQLH L VWHURZDQLH G]LD-

áDQLHP,'(']LDáDQLHPNODZLV]\VWHUXMF\FKQLHEG]LHP\VLQDUD]LH]DMPRZDüQD

REHFQ\PHWDSLH]QDMRPRFL7XUER3DVFDODZ\VWDUF]\&L]QDMRPRüNRPELQDFML

-X

]DNRF]HQLH SUDF\ L NODZLV]D

Z\ZRáDQLH SRPRF\ 3RQL*HM RPyZLP\ NUyWNR

G]LDáDQLHNODZLV]\HG\F\MQ\FK

Klawisz

NTER

MDN MX* ]DSHZQH ZLHV] VáX*\ GR SU]HMFLD GR QRZHJR ZLHUV]D -HJR

QDFLQLFLH SRZRGXMH SU]HPLHV]F]HQLH NXUVRUD GR SRF]WNX NROHMQHJR ZLHUV]D ]QDM-

GXMF\VLSRGVSRGHPWHNVWMHVWSU]HVXZDQ\ZGyá]DMHOLZáF]RQ\MHVWW]ZWU\E
automatycznego wcinania (ang. autoindent mode

NXUVRU ORNXMH VL QLH Z SLHUZV]HM

NROXPQLHOHF]QDZ\VRNRFLSRF]WNXSRSU]HGQLHJRZLHUV]D

Klawisze

ACKSPACE

SRáR*RQ\QDG

NTER

) i

ELETE

]QDMGXMF\VL]SUDZHMVWURQ\

NODZLDWXU\ZEORNXNODZLV]\QXPHU\F]Q\FKLVWHURZDQLDNXUVRUHPSR]ZDODMQDXVX-
wanie t

HNVWX1DFLQLFLHNODZLV]D

ACKSPACE

XVXZD]QDNSRáR*RQ\QDOHZRRGNXU-

VRUDLSU]HVXZDNXUVRUZOHZR]DNODZLV]

ELETE

XVXZD]QDN]QDMGXMF\VLÄSRG´

NXUVRUHP QLH SU]HVXZDMF WHJR RVWDWQLHJR $E\ XVXQü ZLHUV] ZVND]DQ\ NXUVRUHP

Z\VWDUF]\QDFLVQüNODZLV]H

TRL

-Y

:DUWRUyZQLH*ZLHG]LHü*HRP\áNRZRXVXQLW\

WHNVW PR*QD RGWZRU]\ü QDFLVNDMF NODZLV]H

-B

ACKSPACE

RGSRZLDGDM RQH SROH-

ceniu Undo z menu Edit

0R*OLZRüWDSU]\GDMHVL]ZáDV]F]DRVRERPUR]WDUJQLRQ\P

Klawisz

(tabulator) powoduje

SU]HVXQLFLHNXUVRUDRNLONDNROXPQGRSU]RGXFR

XPR*OLZLD wcinanie tekstu 8*\ZDQLH ZFLü SRGF]DV SLVDQLD SURJUDPyZ MHVW VSUDZ

EDUG]R ZD*Q SR]ZDOD ERZLHP QD ]DFKRZDQLH SU]HMU]\VWRFL L F]\WHOQHJR XNáDGX

WHNVWX'RVSUDZ\ZFLQDQLDZUyFLP\MHV]F]HZNROHMQ\FKUR]G]LDáDFK

22 Turbo

Pascal

—

programowanie

.ROHMQD JUXSD NODZLV]\ Z ZLNV]RFL NODZLDWXU XORNRZDQD SRPLG]\ EORNLHP DOID-

QXPHU\F]Q\P D QXPHU\F]Q\P VáX*\ GR SRUXV]DQLD VL SR WHNFLH 6 WR NODZLV]H

VWU]DáHNSU]HVXZDMFHNXUVRURMHGQSR]\FMOXEZLHUV]RUD]NODZLV]H

OME

AGE

OWN

XPR*OLZLDMFHSU]HPLHV]F]HQLHNXUVRUDGRSRF]WNXOXENRFD

ZLHUV]DRUD]Z\ZLHWOHQLHSRSU]HGQLHJROXEQDVWSQHJRHNUDQXVWURQ\WHNVWX

1DFLQLFLH NODZLV]D

SR]ZDOD QD Z\EyU SRPLG]\ W]Z trybem wstawiania (ang.

insert mode —

ZSLV\ZDQH]QDNLVZVWDZLDQHZMX*LVWQLHMF\WHNVWLÄUR]S\FKDM´JR

WU\EHP]DVWSRZDQLD (ang. overwrite mode —QRZRZSLV\ZDQH]QDNL]DVWSXMMX*

LVWQLHMFH']LDáDQLHREXWU\EyZPR*HV]VSUDZG]LüXVWDZLDMFNXUVRUÄZHZQWU]´MX*
napisanego wiersza

WHNVWXLZSLVXMFQRZ\WHNVW]NODZLDWXU\=ZUyüUyZQLH*XZDJQD

NV]WDáWNXUVRUDRUD]G]LDáDQLHNODZLV]\

NTER

2VWDWQLPZD*Q\PNODZLV]HPMHVW

SCAPE

(

6áX*\RQMDNVDPDQD]ZDVXJHUXMH

GRZ\FRI\ZDQLDVL]SRF]\QLRQ\FKG]LDáD]DP\NDQLDSyOGLDORJRZ\FKÄ]ZLjania”

PHQX LWS -HOL SU]H] SU]\SDGHN WUDILV] Z MDNLH QLH]QDQH &L RNROLFH PR*HV] VSUy-

ERZDüSU]\ZUyFLüSRSU]HGQLVWDQ,'(ZáDQLHQDFLVNDMF

. Funkcji tego klawisza

QLHSRZLQLHQHMHGQDNP\OLü]SROHFHQLHP8QGR

-B

ACKSPACE

NWyUHXPR*OLZLD

DQXORZDQLH]PLDQGRNRQDQ\FKZWUHFLZSLV\ZDQHJRSURJUDPX

3U]HGVWDZLRQHZ\*HMZLDGRPRFLSRZLQQ\Z\VWDUF]\ü&LGRUR]SRF]FLDSUDF\] pros-

W\PLSURJUDPDPL-HOLFKFHV]PR*HV]SRPLQüNROHMQ\SRGUR]G]LDáLRGUD]XSU]HMü

GR QDVWSQHJR UR]G]LDáX ] NWyUHJR GRZLHV] VL MDN QDSLVDü L XUXFKRPLü QDMSURVWV]\

SURJUDP Z 3DVFDOX -H*HOL LQWHUHVXM &L GRGDWNRZH IXQNFMH L PR*OLZRFL HG\WRUD
zapraszam do dalszej lektury.

Zaawansowane funkcje edytora

2PyZLP\REHFQLHQDMF]FLHMX*\ZDQH]GRGDWNRZ\ch funkcji edytora Turbo Pascala,

DPLDQRZLFLHRSHUDFMHEORNRZHRUD]Z\V]XNLZDQLHL]DVWSRZDQLHIUDJPHQWyZWHNVWX

3RGF]DVSLVDQLDZLNV]\FKSURJUDPyZF]VWR]DFKRG]LNRQLHF]QRüSRZLHOHQLDSU]H-

QLHVLHQLD OXE XVXQLFLD ZLNV]\FK IUDJPHQWyZ WHNVWX — ]DUyZQR ZHZQWU] SRMHG\Q-

F]HJRRNLHQNDHG\WRUDZREUELHMHGQHJRSOLNXMDNLSRPLG]\RNLHQNDPLSOLNDPL

=DPLDVW SU]HSLV\ZDü WHNVW UF]QLH PR*QD Z\NRU]\VWDü WDN ]ZDQH operacje blokowe,

XPR*OLZLDMFHPDQLSXORZDQLHFDá\PLMHJRIUDJPHQWDPL

3LHUZV]F]\QQRFLMHVW]D]QDF]HQLHIUDJPHQWXWHNVWXFRQDMáDWZLHM]URELüQDFLVNDMF

NODZLV]HVWHUXMFHNXUVRUHPUyZQLH*

OME

AGE

OWN

SU]\ZFL-

QLW\P NODZLV]X

HIFT

=D]QDF]DQ\ IUDJPHQW ]RVWDMH QD RJyá Z\ZLHWORQ\ Z QHJD-

W\ZLH%ORNPR*QDUyZQLH*]D]QDF]\ü]DSRPRFP\V]NLSU]HVXZDMFMHMNXUVRUSU]\

ZFLQLW\POHZ\PSU]\FLVNXMHVWWRW]ZFLJQLFLH — ang. dragging)

7U]HFL PR*OLZRFL MHVW X*\FLH NODZLV]\ VNUyWX

TRL

-K, B

TRL

-K, H

EGF\FK

]DV]áRFL]SRSU]HGQLFKZHUVML7XUER3DVFDODLHG\WRUD:RUG6WDU'RNáDGQLHMV]HLQIRU-
macje na ten temat znajdziesz w literaturze i systemie pomocy.

Narzedzie

3R]D]QDF]HQLXRGSRZLHGQLHJRIUDJPHQWXPR*HP\JRSU]HQRVLüLSRZLHODüZ\NRU]\V-

WXMFW]Zschowek (ang. clipboard). W celu skopiowania zaznaczonego fragmentu do

VFKRZND PXVLV] QDFLVQü NODZLV]H

TRL

-I

(kombinacja

HIFT

-D

przeniesie

IUDJPHQWGRVFKRZNDXVXZDMFJR]WHNVWX$E\ZVWDZLüWHNVW]HVFKRZNDZZ\EUDQH

PLHMVFHZVND*MHNXUVRUHPLQDFLQLMNODZLV]H

HIFT

-I

2SLVDQHRSHUDFMHXPR*OLZL

&L QLH W\ONR SRZLHODQLH L SU]HQRV]HQLH IUDJPHQWyZ ]DZDUWRFL DNW\ZQHJR RNLHQND

HG\WRUDOHF]UyZQLH*SU]HQRV]HQLHWHNVWXGRLQQ\FKRNLHQHN0R*HV]UyZQLH*]DSLVDü
zaznaczony blok na dysku (

TRL

-K, W

L RGF]\WDü JR ] G\VNX

TRL

-K, R

). Aby

XVXQüZ\Uy*QLHQLHX*\MNRPELQDFML

TRL

-K, H

$NWXDOQ]DZDUWRüVFKRZNDPR*HV]

ZUHV]FLH SRGHMU]Hü SROHFHQLHP Show clipboard z menu Edit (powoduje ono

Z\ZLHWOHQLHRNLHQND]DW\WXáRZDQHJRClipboardNWyUHPR*HV]]DPNQüQDFLQLFLHP
klawiszy

-F3

'UXJF]VWRZ\NRU]\VW\ZDQZáDVQRFLHG\WRUDMHVWZ\V]XNLZDQLHL]DPLDQDWHNVWX

3R]ZDODWRQDV]\ENLH]QDOH]LHQLHZSURJUDPLH*GDQHJRIUDJPHQWXWHNVWXOXE]DVWpie-

QLHJRLQQ\PWHNVWHP)XQNFMHWHZ\ZRá\ZDQHVRGSRZLHGQLRNRPELQDFMDPLNODZLV]\

TRL

-Q, F

TRL

-Q, A

QDFLQLFLHNODZLV]\

TRL

-L

powoduje wyszukanie lub za-

mia

Q NROHMQHJR Z\VWSLHQLD GDQHJR IUDJPHQWX 3RQLHZD* RSHUDFMD Z\V]XNDQLD OXE

]DPLDQ\Z\PDJDXVWDOHQLDNLONXSDUDPHWUyZMDNFKRüE\SRV]XNLZDQ\WHNVWZ\ZR-

áDQLH MHGQHM ] RPDZLDQ\FK IXQNFML SRZRGXMH Z\ZLHWOHQLH W]ZRkna dialogowego.

3RQL*HMSRND]DQRRNQRGLDORJRZHZ\ZLHWODQHGODRSHUDFML]DPLDQ\WHNVWX

Rysunek 4. O

NQRGLDORJRZHZ\ZLHWODQHGODRSHUDFML]DPLDQ\WHNVWX

=QDMGXMFHVLXJyU\RNLHQNDGZDpola tekstoweVáX*GRZSURZDG]HQLDWHNVWXNWyU\

PDE\ü]DVWSLRQ\Text to findLWHNVWX]DVWSXMFHJRNew text3RQL*HMSRáR*RQHV
cztery grupy

]DZLHUDMFHVSRNUHZQLRQH]HVRERSFMH*UXSDOptionsXPR*OLZLDXVWD-

OHQLH SDUDPHWUyZ SU]HV]XNLZDQLD UR]Uy*QLDQLH PDá\FK L GX*\FK OLWHU Z\V]XNLZDQLH

W\ONR FDá\FK VáyZ L W]Z Z\UD*H UHJXODUQ\FK ]DPLDQD ] SRWZLHUG]HQLHP *UXSD
Direction

SR]ZDODQDRNUHOHQLHNLHUXQNXZ\V]XNLZDQLDZSU]yGOXEZVWHF]*UXSD

Scope

SR]ZDODQD]DZ*HQLH]DNUHVXG]LDáDQLDIXQNFML do zaznaczonego bloku tekstu,

]DJUXSDOriginXPR*OLZLDUR]SRF]FLHZ\V]XNLZDQLDRGELH*FHMSR]\FMLNXUVRUDOXE

RG SRF]WNX WHNVWX 1D VDP\P GROH RNLHQND ]QDMGXM VL F]WHU\ przyciski VáX*FH GR

EH]SRUHGQLHJRXUXFKRPLHQLDZ\ZRáDQLDOXEDQXORZDQLDZ\EUDQHMF]\QQRFL3U]\-
cisk OK

SRZRGXMHUR]SRF]FLHRSHUDFML]XVWDORQ\PLZF]HQLHMSDUDPHWUDPLChange

24 Turbo

Pascal

—

programowanie

all

SR]ZDOD QD ]DPLDQ ZV]\VWNLFK Z\VWSLH SRV]XNLZDQHJR WHNVWX Cancel

XPR*OLZLDUH]\JQDFM]Z\NRQ\ZDQLDRSHUDFML]DHelpZ\ZRáXMHV\VWHPSRPRF\

HOLMX*Z\SUyERZDáHG]LDáDQLHIXQNFMLReplace (funkcja wyszukiwania, FindG]LDáD

podobnie, nie powoduje jednak zamiany znalezionego tekstu, a jedynie wskazuje go

NXUVRUHPVSUyEXMHP\REHFQLHRPyZLüNRQVWUXNFMLG]LDáDQLHSRODGLDORJRZHJR3ROD

GLDORJRZH V SRZV]HFKQLH Z\NRU]\VW\ZDQH SU]H] ,'( GR NRPXQLNDFML ] X*\WNRZ-

QLNLHPWRWH*ZDUWRRGUD]X]D]QDMRPLüVL]LFKHOHPHQWDPL

:\ERUXHOHPHQWXSRODGLDORJRZHJRGRNRQXMHV]NOLNQLFLHPP\V]NOXEQDFLQLFLHP
klawisza

(albo

HIFT

-T

— wybór elementu p

RSU]HGQLHJR =ZUyü XZDJ *H

SU]\SDGNXJUXS\QDFLQLFLH

XGRVWSQLDMHMSLHUZV]\HOHPHQW—DE\GRVWDüVL

GRSR]RVWDá\FKPXVLV]X*\üNODZLV]\NXUVRUD:\EUDQLHHOHPHQWXV\JQDlizowane jest

SU]H]MHJRZ\Uy*QLHQLHQDRJyáNRORUHPLXPR*OLZLD]PLDQMHJRVWDQX:SU]\SDGNX

SRODWHNVWRZHJR]PLDQVWDQXMHVWSRSURVWXZSURZDG]HQLHWHNVWX']LDáDQLHHOHPHQWyZ

JUXS Z\PDJD QLHFR V]HUV]HJR RPyZLHQLD -DN ]DSHZQH ]DXZD*\áH JUXS\ ]DZDUWH
w polu Replace

]DZLHUDMGZDURG]DMHÄHOHPHQWyZPDQLSXODF\MQ\FK´WDk zwane pola

wyboru (ang. check box), oznaczone nawiasami kwadratowymi, oraz przyciski opcji
(ang. radio button

R]QDF]RQHQDZLDVDPLRNUJá\PL3RODZ\ERUXXPR*OLZLDMQLH]D-

OH*QHZáF]HQLHOXEZ\áF]HQLHGDQHMIXQNFMLMDNáDWZRVSUDZG]LüRSFMHXPLHV]F]RQH
w grupie Options

QLHZ\NOXF]DMVLZ]DMHPQLHLPRJE\üZáF]DQHQLH]DOH*QLHRG

VLHELH=NROHLSU]\FLVNLRSFMLSR]ZDODMQDZ\EyUMHGQHM]NLONXZ]DMHPQLHZ\NOXF]D-

MF\FK VL PR*OLZRFL QS SU]HV]XNLZDQLH WHNVWX PR*H RGE\ZDü VL DOER GR SU]RGX
a

OER GR W\áX WRWH* ZáF]HQLH MHGQHJR ] QLFK SRZRGXMH DXWRPDW\F]QH Z\áczenie

SR]RVWDá\FK6WDQZáF]HQLDV\JQDOL]RZDQ\MHVWGODSRODZ\ERUXV\PEROHP>;@]DGOD
przycisku opcji — symbolem (

•

2VWDWQL JUXS HOHPHQWyZ SROD GLDORJRZHJR VWDQRZL przyciski (ang. button).

Ä1DFLQLFLH´ SU]\FLVNX WM Z\Uy*QLHQLH JR ]D SRPRF NODZLV]D

L QDFLQLFLH

spacji lub klawisza

NTER

HZHQWXDOQLHNOLNQLFLHP\V]NSRZRGXMHQDW\FKPLDVWRZH

Z\NRQDQLH RGSRZLDGDMFHM PX F]\QQRFL L QD RJyá ]DPNQLFLH SROD GLDORJRZHJR.

7U]\VSRUyG]QDMGXMF\FKVLZSROXReplace przycisków — OK, Cancel i Help —

]QDMG]LHV] SUDNW\F]QLH Z ND*G\P LQQ\P SROX GLDORJRZ\P -DN áDWZR VL GRP\OLü

ÄQDFLQLFLH´ SU]\FLVNX OK powoduje zaakceptowanie informacji wprowadzonej do

SRODGLDORJRZHJRMHJR]DPNQLFLHLZ\NRQDQLHGDQHMRSHUDFMLQS]DPLDQ\]QDNyZ
Przycisk Cancel

SR]ZDOD QD UH]\JQDFM ] Z\NRQ\ZDQLD RSHUDFML ZSURZDG]RQH GR

SROD LQIRUPDFMH V WUDFRQH ]D SU]\FLVN Help Z\ZRáXMH RNLHQNR V\VWHPX SRPRF\

]DZLHUDMFH RGSRZLHGQL GR NRQWHNVWX LQIRUPDFM :DUWR ]DSDPLWDü *H RPyZLRQH

Z\*HM SU]\FLVNL PDM VZRMH RGSRZLHGQLNL QD NODZLDWXU]H V WR PLDQRZLFLH

NTER

RGSRZLDGDMF\SU]\FLVNRZLOKRLOHWHQ]RVWDáZ\Uy*QLRQ\W]QMHVWW]ZSU]\FLVNLHP

GRP\OQ\P

SCAPE

RGSRZLDGDMF\ SU]\FLVNRZ Cancel) oraz

RGSRZLDGDMF\

przyciskowi Help).

:DUWRMHV]F]HSRZLHG]LHüNLONDVáyZQDWHPDWV\VWHPXSRPRF\F]\OLZáDQLHIXQNFML
Help

Ä3RGUF]QDFLJDZND´GRVWSQDZ,'(RIHUXMHRSUyF]EDUG]RV]HURNLHJR]HV-

tawu informacji, kilka nader przydatnych funkcji. Przede wszystkim system pomocy
Turbo Pascala jest tzw. systemem kontekstowym

2]QDF]DWR*HSRQDFLQLFLXNODZLV]D

X]\VNDV] LQIRUPDFM FLOH ]ZL]DQ ] V\WXDFM Z MDNLHM VL ]QDMGXMHV] QS SR

Narzedzie

otwarciu okna dialogowego Replace

V\VWHPSRPRF\Z\ZLHWOLRSLVWHJR*SRODLMHJR

HOHPHQWyZ.RQWHNVWRZRüR]QDF]DUyZQLH*PR*OLZRüáDWZHJRX]\VNDQLDLQIRUPDFML

QDWHPDWEáGyZV\JQDOL]RZDQ\FKSU]H]NRPSLODWRU

'UXJFLHNDZFHFKV\VWHPXSRPRF\MHVWPR*OLZRüX]\VNDQLDLQIRUPDFMLRZ\Era-
nym elemencie p

URJUDPX R LOH MHJR QD]ZD ]RVWDáD ]GHILQLRZDQD Z UDPDFK 7XUER

3DVFDOD)XQNFMDWDZ\ZRá\ZDQDMHVWQDFLQLFLHPNODZLV]\

TRL

-F1

, po uprzednim

wska

]DQLXLQWHUHVXMFHJRQDVVáRZDNXUVRUHP7DNZLFDE\GRZLHG]LHüVLF]HJRQD

temat procedury

write

EG]LHV] ] QLHM NRU]\VWDá Z QDVWSQ\P UR]G]LDOH PXVLV]

QDSLVDü

write

L QDFLVQü

TRL

-F1

SDPLWDMF E\ NXUVRU ]QDMGRZDá VL Z REUELH

QDSLVDQHJR VáRZD : SRGREQ\ VSRVyE PR*HV] X]\VNDü LQIRUPDFM QD WHPDW LQQ\FK
obiektów.

'RVWSGRVNRURZLG]DKDVHáRSLVDQ\FKZV\VWHPLHSRPRF\PR*HV]X]\VNDüQDFLVNDMF
klawisze

HIFT

-F1

$E\Z\EUDüKDVáR]HVNRURZLG]DZ\VWDUF]\ZVND]DüMHNXUVRUHP

QDFLVQü

NTER

HZHQWXDOQLH NOLNQü P\V]N 3RGF]DV NRU]\VWDQLD ] V\VWHPX SR-

PRF\LVWQLHMHUyZQLH*PR*OLZRüSRZURWXGRSRSU]HGQLRZ\ZLHWODQ\FKRSLVyZSU]H]

QDFLQLFLH NODZLV]\

-F1

3R]RVWDáH U]DG]LHM X*\ZDQH SROHFHQLD ]JUXSRZDQH V

w menu Help.

:WHQVSRVyE]DNRF]\OLP\SU]HJOGSRGVWDZRZ\FKLQIRUPDFMLQDWHPDWURGRZLVND

7XUER3DVFDOD0R*HV]WHUD]SRüZLF]\üSRVáXJLZDQLHVLHG\WRUHPLSR]QDQ\PLIXQ-

NFMDPL]DNRF]\üSUDFQDFLVNDMFNODZLV]H

-X

OXERGUD]XSU]HMüGRQDVWSQHJR

UR]G]LDáXZNWyU\P]DGHPRQVWUXMHP\SLHUZV]\SURJUDPZ3DVFDOX

Zapamietaj

•

$E\XUXFKRPLü7XUER3DVFDODZ\GDMSROHFHQLH

turbo

•

&KFF]DNRF]\üSUDF]7XUER3DVFDOHPQDFLQLMNODZLV]H

-X

•

:V]\VWNLH SROHFHQLD ,'( 7XUER 3DVFDOD GRVWSQH V SRSU]H] PHQX JáyZQH

Z\ZRá\ZDQH NODZLV]HP

F10

OXE ]D SRPRF P\V]NL &]ü SROHFH PR*QD

UyZQLH*Z\ZRáDüQDFLVNDMFNODZLV]HVNUyWX

•

Do wprowadzania i poprawi

DQLDWHNVWyZSURJUDPyZVáX*\RNLHQNRHG\WRUD

•

.RQZHUVDFMD],'(SURZDG]RQDMHVW]DSRPRFSyOGLDORJRZ\FK

•

Klawisz

SCAPE

XPR*OLZLD&LUH]\JQDFM]Z\NRQ\ZDQLDUR]SRF]WHMRSHUDFML

•

-HOLSRWU]HEXMHV]SRPRF\QDFLQLMNODZLV]

26 Turbo

Pascal

—

programowanie

Pierwszy program

1DMZ\*V]DSRUDQDQDSLVDQLHMDNLHJRSURJUDPX%\QLHE\áRQFDáNRZLFLHQLHSUDNtycz-

Q\VSUyEXMP\]DSRPRFNRPSXWHUDREOLF]\üSROHNRáDRSURPLHQLXFHQW\PHWUyZ

-DNZLDGRPRSROHNRáDZ\UD*DVLZ]RUHP

S =

gdzie r

R]QDF]DSURPLH]D

MHVW]QDQRGGRüGDZQDVWDáZ\QRV]FRNRáR

6DPSURJUDPSRZLQLHQMHG\QLHZ\SLV\ZDüREOLF]RQZDUWRüQDHNUDQLHF]\OLG]LDáDü
z grubsza tak:

SRF]WHN
wypisz pi razy r do kwadratu
koniec

2. 3RPLMDMF QLHMDVQH QD UD]LH NZHVWLH PQR*HQLD SRGQRV]HQLD OLF]E\ GR NZDGUDWX
i

ZDUWRFL

PR*HV]ZáF]\üNRPSXWHULXUXFKRPLü7XUER3DVFDODSLV]F

turbo

3RSRMDZLHQLXVLQDHNUDQLHRNLHQNDHG\WRUDMHOLWDNRZHVLQLHSRMDZL]PHQXFile
wybierz polecenie New, czyli Nowy

VSUyEXMSU]HWáXPDF]\üQDV]VFKHPDFLNQDM]\N

DQJLHOVNLLZSURZDG]LüJRGRNRPSXWHUD3RZLQQRWRZ\JOGDüPQLHMZLFHMWDN

begin
write(Pi*5*5);
end.

=DXZD**HSRZ\*V]\SURJUDPMHVWSUDZLHGRVáRZQ\PWáXPDF]HQLHPWHJRFRQDSLVD-

OLP\ SRSU]HGQLR 7D ZáDQLH ÄGRVáRZQRü´ VWDQRZL MHGQ ] QDMSRZD*QLHMV]\FK ]DOHW

7XUER 3DVFDOD WZRU]HQLH SURVW\FK SURJUDPyZ PR*QD Z GX*HM F]FL VSURZDG]Lü GR

WáXPDF]HQLDRGSRZLHGQLHJRDOJRU\WPXQDM]\NDQJLHOVNLZDUWRMHV]F]H]QDüSRGVWDZ\

DQJLHOVNLHJRDOHQDSUDZGZ\VWDUF]SRGVWDZ\

6DP SURJUDP FK\ED QLH PR*H E\ü SURVWV]\ 6NáDGD VL RQ ] MHGQHM MHG\QHM LQVWUXNFML

Z\SLVXMFHMZDUWRüZ\UD*HQLD „pi razy r do kwadratu”, przy czym podnoszenie liczby

GRNZDGUDWX]RVWDáR]DVWSLRQHZ\PQR*HQLHPMHMSU]H]VLHELH6DPRPQR*HQLHV\PER-
lizowane jest operatorem

JZLD]GND ]D VWDáD

to po prostu

2 Z\UD*HQLDFK

Pierwszy

program

RSHUDWRUDFKLVWDá\FKSRZLHP\QLHFRZLFHMMX*ZNUyWFHQDUD]LH]DZ\MDQLMP\URO

SR]RVWDá\FKVNáDGQLNyZSURJUDPX

.D*G\ SURJUDP Z 3DVFDOX UR]SRF]\QD VL VáRZHP NOXF]RZ\P

begin

(

SRF]WHN)

NRF]\ VáRZHP NOXF]RZ\P

end.

(koniec —

] NURSN 6áRZD NOXF]RZH VWDQRZL

SRGVWDZRZ\ÄDOIDEHW´M]\NDVáX*F\GRWZRU]HQLDEDUG]LHM]áR*RQ\FKVWUXNWXU7XUER

3DVFDODXWRPDW\F]QLHZ\Uy*QLDVáRZDNOXF]RZHZWUHFLSURJUDPXSU]H]Z\ZLHWODQLH

LFKZLQQ\PNRORU]HQDWRPLDVWZNVL*FHEG]LHP\]D]QDF]DOLMH

F]FLRQNSRJUX

ELRQ

3RPLG]\ VáRZDPL NOXF]RZ\PL R]QDF]DMF\PL SRF]WHN L NRQLHF SURJUDPX ]QDMGXMH

VL MHJR ]DVDGQLF]D WUHü F]\OL WDN ]ZDQD F]ü RSHUDF\MQD 6NáDGDM VL QD QL
instrukcje

RSLVXMFH NROHMQH F]\QQRFL Z\NRQ\ZDQH przez komputer. W naszym

przypadku prog

UDP ]DZLHUD W\ONR MHGQ LQVWUXNFM D PLDQRZLFLH Z\ZRáDQLH W]Z

procedury bibliotecznej

write

(wypisz

Z\SLVXMFHM QD HNUDQLH XSU]HGQLR REOLF]RQ

ZDUWRüZ\UD*HQLD-DNVLZNUyWFHSU]HNRQDV]LQVWUXNFMHPRJUyZLH*]DZLHUDü]DSLV

G]LDáD DU\WPHW\F]Q\FK Z\ZRáDQLD IXQNFML V\VWHPRZ\FK L ZLHOH LQQ\FK RSHUDFML

.D*GD LQVWUXNFMD ] wyMWNLHP LQVWUXNFML ]QDMGXMFHM VL EH]SRUHGQLR SU]HG VáRZHP

end

PXVL E\ü ]DNRF]RQD UHGQLNLHP

;

), który w Pascalu jest tzw. separatorem

instrukcji.

Aby procedura

write

ZLHG]LDáDFRZáDFLZLHPDZ\SLVDüPXVLV]SU]HND]DüMHMRGSR-

wiednie informacje w postaci tzw. argumentów. W naszym przypadku argumentem
procedury

writeln

MHVWZ\UD*HQLH

Pi*5*5

NWyUH]NROHLVNáDGDVL]LGHQW\ILNDWRUyZ

VWDá\FK L RSHUDWRUyZ R W\P ]D FKZLO -HOL SURFHGXUD Z\PDJD NLONX DUJXPHQWyZ

QDOH*\ UR]G]LHOLü MH SU]HFLQNDPL ]D FDáD OLVWD DUJXPHQWyZ PXVL E\ü ]DZV]H XMWD
w

QDZLDV\RNUJáH7DNZLFVNáDGQLDF]\OLV\PEROLF]Q\RSLVVSRVREXZ\NRU]\VWDQLD

naszej procedury

write

MHVWQDVWSXMFD

write[(argument, argument...)]

: SRZ\*V]\P ]DSLVLH QDZLDV\ NZDGUDWRZH R]QDF]DM HOHPHQW\ QLHRERZL]NRZH

PR*OLZHMHVWX*\FLHSURFHGXU\

write

EH]DUJXPHQWyZ]DZLHORNURSHNV\JQDOL]XMH

PR*OLZRüX*\FLDGDOV]\FKDUJXPHQWyZZEOL*HMQLHRNUHORQHMOLF]ELH3RSUDZQHEG

ZLFQDVWSXMFHZ\ZRáDQLDSURFHGXU\

write

•

write(5);

Z\SLV]HOLF]E

•

write(1, 2, 3, 4);

wypisze liczby 1, 2, 3 i 4 (jako „1234”)

•

write;

nic nie wypisze

3R]RVWDáRQDPMHV]F]HZ\WáXPDF]\üSRMFLDVWDáHMRSHUatora i identyfikatora. 6WDáD to

SRSURVWXVWDáDF]\OLSHZQDVWDáDZDUWRü]DSLVDQDMDZQLHQDSU]\NáDGOLF]EDF]\
nazwa 'Warszawa'). O tak zwanych

VWDá\FK V\PEROLF]Q\FK SRZLHP\ QLHFR Sy(QLHM

Operatorem

QD]\ZDP\V\PEROUHSUH]HQWXMF\SHZQHG]LDáDQLHQSGRGDZDQLHF]\

SRUyZQDQLH 2SHUDWRU\EGFHVáRZDPL]DVWU]H*RQ\PLVWDQRZLMHGHQ]SRGVWDwo-
wych elementów

Z\UD*HRNWyU\FKSRZLHP\ZLFHMZQDVWSQ\PUR]G]LDOH:UHV]FLH

identyfikator

MHVW SR SURVWX QD]Z RELHNWX QS VWDáHM

) lub opera

FML QD SU]\NáDG

28 Turbo

Pascal

—

programowanie

Z\SLV\ZDQLDZDUWRFL—

write

0R*HRQ]DZLHUDüOLWHU\GX*HOLWHU\QLHVRGUy*-

QLDQH RG PDá\FK ]DWHP

Write

write

to ten sam identyfikator), cyfry i znaki

SRGNUHOHQLDOHF]QLHPR*H]DF]\QDüVLRGF\IU\0XVLV]UyZQLH*SDPLWDü*HWZR-

U]HQLHLGHQW\ILNDWRUyZEU]PLF\FKWDNVDPRMDNVáRZDNOXF]RZHLRSHUDWRU\EGFH

VáRZDPL ]DVWU]H*RQ\PL MHVW QLHGR]ZRORQH WDN ZLF QLH PR*HV] XWZRU]\ü RELHNWX
o nazwie

End

czy

7\OHWHRULL)HE\SU]HNRQDüVL*HSURJUDPQDSUDZGG]LDáDVSUyEXMJRVNRPSLORZDü

QDFLVNDMFNODZLV]

— Make

2LOHQLFQLHSRSVXáHSU]\SU]HSLV\ZDQLXZ\QLNLHP

NRPSLODFMLSRZLQQRE\üSU]HGVWDZLRQHQL*HMRNLHQNR

Rysunek 5.

2NLHQNRZ\ZLHWODQHSRSUDZLGáRZHMNRPSLODFMLSURJUDPX

1D]ZDSOLNXUR]PLDUZROQHMSDPLFLLLQQHV]F]HJyá\PRJE\üX&LHELHQLHFRLQQH—

QDMZD*QLHMV]\MHVWNRPXQLNDW

Compile successful: Press any key

Z\ZLHWODQ\

XGRáXRNLHQND

-HOLXGDáR&LVLSRSHáQLüMDNLEáGNRPSLODWRU]DV\JQDOL]XMHWRRGSRZLHGQLPNRPX-
nikatem, w

VND]XMFMHGQRF]HQLHNXUVRUHPSRGHMU]DQHPLHMVFHZSURJUDPLH

Rysunek 6.

.RPSLODWRUV\JQDOL]XMHEáGNRPSLODFML

3RZ\*HM]LOXVWURZDQRUHDNFMNRPSLODWRUDQDEUDNNURSNLSRNRF]F\PSURJUDPVáR-
wie

end

-DNZLGDüNXUVRU]QDOD]áVLZZLHUV]X]DZLHUDMF\PEáG]DZ\ZLHWORQ\

QDHNUDQLHNRPXQLNDWR]QDF]D*HWUHüSURJUDPXQLH]RVWDáDSUDZLGáRZR]DNRF]RQD

'RGDWNRZHZ\MDQLHQLDGRW\F]FHEáGXPR*HV]X]\VNDüQDFLVNDMFNODZLV]

(Help).

Pierwszy

program

-HOLZSURJUDPLH]QDMGXMHVLNLONDEáGyZNRPSLODWRUZ\NU\MHW\lko pierwszy z nich
(po jego poprawieniu —

QDVWSQ\LWDNGDOHM:FKDUDNWHU]HüZLF]HQLDPR*HV]ZSUR-

ZDG]LüNLONDEáGyZGRSURJUDPXQSSU]HVWDZLüOLWHU\ZVáRZLH

write

LSU]HNRQDü

VLMDNUHDJXMHQDQLHNRPSLODWRU

0XVLV]]GDZDüVRELHVSUDZ*HEH]EáGQDNRPSLODFMDQLH]DZV]HJZDUDQWXMH

SRSUDZQHZ\NRQDQLHSURJUDPX%áG\RNWyU\FKSRZLHG]LDQRSU]HGFKZLO

QD]\ZDQHVEáGDPLNRPSLODFML (ang. compile-WLPHHUURULZ\QLNDMJáyZQLH
z

SRP\áHNSRGF]DVZSLV\ZDQLDSURJUDPXQSEáGQLHZSLVDQ\FKVáyZ

NOXF]RZ\FK'UXJ]QDF]QLHPQLHMSU]\MHPQNDWHJRULWZRU]EáG\
wykonania

DQJUXQWLPHHUURUZ\QLNDMFH]QLHZáDFLZHMNRQVWUXNFML

SURJUDPXOXEX*\FLDQLHSUDZLGáRZ\FKGDQ\FK%áG\WHQLHVZ\NU\ZDQHSU]H]

NRPSLODWRULXMDZQLDMVLGRSLHURZWUDNFLHSUDF\SURJUDPXSURZDG]F

QDMF]FLHMGRMHMSU]HUZDQLD7\SRZ\PSU]\NáDGHPMHVWSUyEDG]LHOHQLDOLF]E\

SU]H]]HUROXERGF]\WDQLDGDQ\FK]QLHLVWQLHMFHJRSOLNXNRPSLODWRUQLHPR*H

ZLHG]LHüF]\SOLNRGDQHMQD]ZLHEG]LHLVWQLDáZFKZLOLZ\NRQDQLDSURgramu).

1DV]F]FLHSURJUDP\NWyU\PLEG]LHP\VL]DMPRZDüZQDMEOL*V]\PF]DVLH

V QDW\OHSURVWH*HWUXGQRZQLFKREáG\Z\NRQDQLD

7\OHQDWHPDWEáGyZNWyU\FKRF]\ZLFLH*\F]&LMDNQDMPQLHM-HOLMX*VNRPSLOR-

ZDáHSURJUDPPR*HV]JRZ\NRQDüQDFLVNDMFNODZLV]H

TRL

-F9

-X*",MDNLMHVWZ\QLN"+PDZáDFLZLHgdzie on jest?

1LHPDVLF]HJRREDZLDü2EOLF]RQHZSURJUDPLHSROHNRáD]RVWDáRZ\SLVDQHQDHNUD-

QLH OHF] MHVW SU]HVáRQLWH SU]H] RNLHQNR HG\WRUD $E\ VL R W\P SU]HNRQDü QDFLQLM
klawisze

-F5

SRZLQLHQH]REDF]\ü]QDMGXMF\VLÄSRGVSRGHP´HNUDQ'26-owy,

]DZLHUDMF\RSUyF]LQQ\FKU]HF]\OLF]E

7.8539816340E+01

F]\OL ] JUXEV]D FHQW\PHWUyZ NZDGUDWRZ\FK $E\ ZUyFLü GR RNLHQND HG\WRUD

Z\VWDUF]\QDFLVQü

NTER

8II 1D SLHUZV]\ UD] WR FK\ED Z\VWDUF]\ $E\ QLH XWUDFLüVZRMHJRSLHUZV]HJRSURJ-

UDPXPXVLV]JRMHV]FH]DSDPLWDüF]\OL]DSLVDüQDG\VNX:W\PFHOXZ\ELHU]SROH-
cenie Save (

=DSDPLWDM) z menu FileOXESRSURVWXQDFLQLMNODZLV]

-HOLZF]HQLHM

QLH QDGDáH SURJUDPRZL QD]Z\ QD]ZD Z\ZLHWODQD MHVW QD JyUQHM NUDZG]L UDPNL

RNLHQND HG\WRUD MHOL ]QDMGXMH VL WDP QDSLV

NONAME00.PAS

SURJUDP QLH ]RVWDá

MHV]F]HQD]ZDQ\QDHNUDQLHSRMDZLVLSROHGLDORJRZHSave File As.

$E\]DSLVDüSURJUDPSRGSU]\NáDGRZQD]Z

PROGRAM

PAS

Z\VWDUF]\ZSLVDüMZSR-

le Save file as

LQDFLVQü

NTER

3RQLHZD*UR]V]HU]HQLH

PAS

jest dla programów pasca-

ORZ\FKSU]\MPRZDQHGRP\OQLHQLHPXVLV]JRSRGDZDü

=DXZD**HSRZ\NRQDQLXWHMRSHUDFMLQD]ZDSURJUDPXZ\ZLHWODQDZUDPFHRNLHQND
edy

WRUD]PLHQLáDVL]

NONAME

00.

PAS

PROGRAM

PAS

-HOLWHUD]SRQRZQLHQDFLQLHV]

SURJUDP ]RVWDQLH ]DFKRZDQ\ SRG W VDP QD]Z EH] Z\ZLHWODQLD SROD GLDlogo-

wego.

30 Turbo

Pascal

—

programowanie

Rysunek 7. Okno dialogowe Save File As

Tworzenie nowego programu poleceniem File-New

L Sy(QLHMV]D zmiana nazwy pole-

ceniem File-Save/Save as

QLHV]E\WZ\JRGQH2WRGZLHPHWRG\XWZRU]HQLDSURJUDPX

QLHZ\PDJDMFHSy(QLHMV]HM]PLDQ\QD]Z\

Zamiast polecenia New

PR*HV] Z\NRU]\VWDü SROHFHQLH Open (Otwórz) z menu File.

Pozwala ono na odczytanie z dysku za

SLVDQHJR ZF]HQLHM WHNVWX SURJUDPX Z\ZLHW-

ODMFRNQRGLDORJRZHOpen a FileSRND]DQHSRQL*HM

Rysunek 8. Okno dialogowe Open a File

1D]Z *GDQHJR SURJUDPX PR*HV] ZSLVDü Z SROH Name OXE Z\EUDü ] OLVW\ Files,

]DZLHUDMFHM]DZDUWRüNDWDORJXURERF]HJRQDVWSQLHQDOH*\QDFLVQü

NTER

-HOLSOLN

RSRGDQHMQD]ZLHQLHLVWQLHMH7XUER3DVFDOXWZRU]\QRZHRGSRZLHGQLR]DW\WXáRZDQH

RNLHQNRHG\WRUDNWyUHJR]DZDUWRüEG]LHPR*QDZGRZROQ\PPRPHQFLH]DSLVDüEH]

NRQLHF]QRFLSRGDZDQLDQD]Z\

Druga

PHWRGD SROHJD QD RGSRZLHGQLP Z\ZRáDQLX 7XUER 3DVFDOD ] SR]LRPX '26-u.

$E\RWZRU]\üLVWQLHMF\SOLN]SURJUDPHPOXEXWZRU]\üQRZ\SOLNZ\VWDUF]\QDSLVDü

turbo

nazwa

↵

Po uruchomieniu system automatycznie odczyta plik o zadanej

nazwie

(i rozszerzeniu

PAS

; p

RGREQLHMDNSRSU]HGQLRUR]V]HU]HQLDQLHWU]HEDSRGDZDüOXEMHOLWDNLSOLNQLH

istnieje, otworzy puste okienko edytora o odpowiednim tytule.

Pierwszy

program

: WHQ VSRVyE SR]QDáH DEVROXWQH SRGVWDZ\ SRVáXJLZDQLD VL URGRZLVNLHP 7XUER
Pascala i uruc

KRPLáHVZyMSLHUZV]\SURJUDP$RWRNLONDüZLF]HNWyUHSRPRJ&L

QDEUDüZSUDZ\L]GRE\üGRGDWNRZHZLDGRPRFL

•

Z\NRU]\VWDMV\VWHPSRPRF\GRZ\ZLHWOHQLDLQIRUPDFMLRSRV]F]HJyOQ\FKHOH-

PHQWDFKSURJUDPXVáRZDFKNOXF]RZ\FKLGHQW\ILNDWRUDFKRSHUDWRUDFK

•

VSUyEXMZSURZDG]LüGRSURJUDPXNLONDEáGyZ-DNDMHVWUHDNFMDNRPSLODWRUD"

•

SRSUDZSURJUDPWDNE\GDáRVL]DMHJRSRPRFREOLF]\üSROHNRáDRSURPLHQLX

FP FP LWG 6SUyEXM QDSLVDü SURJUDP REOLF]DMF\ SROH WUyMNWD R ]QDQHM

GáXJRFLSRGVWDZ\LZ\VRNRFL

•

]DVWDQyZVLFRQDOH*DáRE\]PLHQLüZSU]HGVWDZLRQ\PSURJUDPLHE\XF]\QLü

JR OHSV]\P EDUG]LHM F]\WHOQ\P XQLZHUVDOQ\P SUDNW\F]Q\P áDWZLHMV]\P Z
ob

VáXG]H

=DSDPLWDM

•

3URJUDPSDVFDORZ\VNáDGDVL]FLJXUR]G]LHORQ\FKUHGQLNDPLLQVWUXNFMLSRáR-

*RQ\FKSRPLG]\VáRZDPLNOXF]RZ\PL

begin

end

•

,QVWUXNFMHVWDQRZLV\PEROLF]Q\]DSLVRSHUDFMLNWyUHPDZ\NRQDüNRPSXWHU

•

,QVWUXNFMHPRJ]DZLHUDüZ\UD*HQLDRUD]Z\ZRáDQLDIXQNFMLLSURFHGXU

•

:\UD*HQLDVNáDGDMVL]HVWDá\FKRSHUDWRUyZLLGHQW\ILNDWRUyZ

•

,GHQW\ILNDWRU\ V QD]ZDPL RELHNWyZ VNáDGDMF\FK VL QD SURJUDP 0RJ RQH

]DZLHUDü OLWHU\ F\IU\ L ]QDNL SRGNUHOHQLD QLH PRJ MHGQDN ]DF]\QDü VL RG
cyfr.

•

$E\VNRPSLORZDüSURJUDPPXVLV]X*\üSROHFHQLDMake (

). Ewentualne

EáG\NRPSLODFMLVRGSRZLHGQLRV\JQDOL]RZDQH

•

&KFFXUXFKRPLüSURJUDPPXVLV]Z\GDüSROHFHQLHRun (

TRL

-F9

). Do obej-

U]HQLDZ\QLNyZG]LDáDQLDSURJUDPXPR*HRND]DüVLQLH]EGQHSROHFHQLHUser
Screen (

-F5

•

$E\]DSLVDüSURJUDPX*\MSROHFHQLDSave (

). Do odczytania zapisanego prog-

UDPX]G\VNXVáX*\SROHFHQLHOpen (

32 Turbo

Pascal

—

programowanie

Nic nie jest

GRVNRQDáH

D]ZáDV]F]DSLHUZV]\Z*\FLXSURJUDPZ3DVFDOX-H*HOLSUyERZDáH]DVWDQRZLüVL

QDGS\WDQLHP]DP\NDMF\PSRSU]HGQLUR]G]LDáQDMSUDZGRSRGREQLHMZLG]LV]MX*PR*li-

ZRFL XOHSV]HQLD VZHJR G]LHáD 1D SRF]WHN VSUyEXMHP\ ]DMü VL F]\WHOQRFL SURJ-

UDPXDQDVWSQLH]DVWDQRZLP\VLMDNXF]\QLüJREDUG]LHMSUDNW\F]Q\P

&RZáDFLZLHURELQDV]SURJUDP"Ä2EOLF]DSROHNRáD´—RGSRZLHV]6NGWRZLDGRPR"

Ä7DNE\áRQDSLVDQHZNVL*FH´$MHOLNWRQLHF]\WDáNVL*NL"Ä0R*HVLGRP\OLüSR
przeczytaniu programu”.

$OH SR FR PD F]\WDü SURJUDP" &R SUDZGD ]UR]XPLHQLH MHGQHM LQVWUXNFML WR *DGHQ

SUREOHPDOHMHOLLQVWUXNFMLEG]LHVWR"=QDF]QLHOHSLHME\áRE\XPLHFLüZSURJUDPLH

LQIRUPDFM RSLVXMF MHJR SU]H]QDF]HQLH L HZHQWXDOQLH PHWRG UHDOL]DFML ]DGDQLD

0R*QD WR ]URELü QD NLOND VSRVREyZ XPLHV]F]DMF RGSRZLHGQLH ]DSLV\ Z SURJUDPLH

RUD]X*\ZDMFVWRVRZQHMQD]Z\SOLNX=UyEP\WRRGUD]X

program Pole_kola;

^3URJUDPREOLF]DSROHNRáDRSURPL

eniu 5 }

begin

ZULWH3LREOLF]LZ\SLV]SROHNRáD

end.

:SRUyZQDQLXGRSRSU]HGQLHMZHUVMLSURJUDPXSRMDZLá\VLZQLPWU]\QRZHHOHPHQW\

QDJáyZHN, komentarze oraz ZFLFLD.

1DJáyZHN

program Pole_kola

SHáQL Z\áF]QLH IXQNFM LQIRUPDF\MQ L QLH PD

ZSá\ZXQDG]LDáDQLHSURJUDPXFRQLH]PLHQLDIDNWX*HX*\ZDQLHJR—FKRFLD*QLH-

RERZL]NRZH—QDOH*\GRGREUHMSUDNW\NLXáDWZLDERZLHPF]\WDQLHRVRERPWU]HFLP

6NáDGQLDQDJáyZNDWR

program nazwa;

1LFQLHMHVWGRVNRQDáH

=DXZD* SU]\ RND]ML *H Ä3ROH NRáD´ WR GZD RGG]LHOQH Z\UD]\ SRQLHZD*

nazwa

jako

LGHQW\ILNDWRUQLHPR*H]DZLHUDü]QDNXVSDFML]DVWSXMHVLJRSRGNUHOHQLHP

=QDF]QLHZD*QLHMV]HGODF]\WHOQRFLSURJUDPXVNRPHQWDU]H.RPHQWDU]HPZ3DVFDOX

MHVWGRZROQ\FLJ]QDNyZXMW\ZQDZLDV\NODPURZH

{

}

=RF]\ZLVW\FKZ]JOGyZ

FLJWDNLQLHPR*H]DZLHUDüQDZLDVyZNODPURZ\FKQDWRPLDVWZV]\VWNLHLQQH]QDNLV

GR]ZRORQH -H*HOL NRQLHF]QLH FKFHV] XPLHFLü QDZLDV\ NODPURZH Z NRPHQWDU]X

PXVLV] X*\ü MDNR RJUDQLF]QLNL GZX]QDNRZ\FK V\PEROL

FR ZLGDü Z GUugim

komen

WDU]X3RGREQLHMDNZSU]\SDGNXQDJáyZNDNRPHQWRZDQLHSURJUDPyZQLHMHVW

obo

ZL]NRZH QDOH*\ MHGQDN GR GREUHM SUDNW\NL SURJUDPRZDQLD 2F]\ZLFLH

NRPHQWDU]H SRZLQQ\ E\ü X*\ZDQH UR]VGQLH QLH PD VHQVX LFK QDGX*\ZDQLH F]\

NRPHQWRZDQLHU]HF]\RF]\ZLVW\FKMDNQSVáRZD

begin

:DUWRMHGQDN]GDZDüVRELH

VSUDZ *H NRPHQWDU]H QLF QLH NRV]WXM WM QLH PDM ZSá\ZX QD ZLHONRü
skompilowanego prog

UDPXDMHGQRF]HQLHZ]QDF]F\VSRVyESRSUDZLDMF]\WHOQRü

programu.

.RPHQWDU]HE\ZDMUyZQLH*F]VWRVWRVRZDQHGRFKZLORZHJRZ\áF]HQLD

IUDJPHQWXSURJUDPX]NRPSLODFML3R]ZDODWRXQLNQüXVXZDQLDLSRZWyUQHJR

ZSLV\ZDQLDWHNVWX]DPLDVWWHJRZ\VWDUF]\XMüÄQLHFKFLDQ\´IUDJPHQW

SURJUDPXZ]QDNLNRPHQWDU]DNWyUHSRWHPPR*QDáDWZRXVXQü

2VWDWQLPÄNRVPHW\F]Q\P´HOHPHQWHPQDV]HJRSURJUDPXVZFLFLD. Nasz program jest

FR SUDZGD WDN PDá\ *H X*\ZDQLH ZFLü MHVW QLHFR G\VNXV\MQH MHGQDN Z ZLNV]\FK

SURJUDPDFK NWyU\PL ]DMPLHP\ VL MX* ZNUyWFH ZFLFLD SR]ZDODM QD V]\ENLH ]ORND-

OL]RZDQLH IUDJPHQWyZ WZRU]F\FK ORJLF]Q FDáRü L ]QDMGXMF\FK VL QD W\P VDP\P

SR]LRPLHZVWUXNWXU]HSURJUDPX:FLQDQLHSRGREQLHMDNLQQHUHJXá\SLVDQLDáDGQ\FK
i

F]\WHOQ\FKSURJUDPyZMHVWZGX*HMPLHU]HNZHVWLVW\OX]Z\NOHSRMHG\QF]HZFLFLH

PDJáERNRü÷]QDNyZZDUWRMHGQDNSU]\MU]HüVLVSUDZG]RQ\PZ]RUFRPQS

SURJUDPRPSU]\NáDGRZ\PILUP\%RUODQGDQDVWSQLHZ\SUDFRZDüZáDVQ\VW\OLVWR-
so

ZDüJRNRQVHNZHQWQLH

7\OH VSUDZ ÄIRUPDOQ\FK´ QLH EG]LHP\ VL QDG QLPL ZLFHM UR]ZRG]Lü ]RVWDZLDMF

UHV]W SUDNW\FH 3U]HMG]LHP\ REHFQLH GR ]QDF]QLH EDUG]LHM LQWHUHVXMFHM F]FL WHJR

UR]G]LDáXFR]URELü*HE\QDV]SURJUDPVWDáVLEDUG]LHMSUDNW\F]Q\"

0R*HLQDF]HMFRSURJUDPURELREHFQLH"2EOLF]DLZ\ZLHWODSROHNRáDRSURPLHQX

FP%DDOHVNGZLDGRPR*HWRSROHNRáDDQLHQSUHGQLDRSDGyZ]XELHJáHJRSyá-

URF]D" )HE\ VL R W\P SU]HNRQDü PXVLV] ]DMU]Hü GR NVL*NL JG]LH MHVW WR QDSLVDQH

ZSURVWOXEGRSURJUDPXQDGNWyU\PPXVLV]WURFKSRP\OHüRLOHQLHZSLVDáHMHV]-
cze odpo

ZLHGQLFKNRPHQWDU]\1DGRGDWHNZ\ZLHWOana liczba ma cokolwiek niestraw-

Q\IRUPDWLQLH]E\WFKWQLHQDPVLSRND]XMH

&KZLOHF]N QLH ZV]\VWNR QDUD] 1D SRF]WHN VSUyEXMP\ VIRUPXáRZDü OLVW *\F]H

F]\OL ]DSLVDü Z XSRU]GNRZDQ\ VSRVyE WR FR QDP VL Z SURJUDPLH QLH SRGRED L FR

FKFLHOLE\P\]PLHQLü$]DWHP

•

SURJUDPSRZLQLHQLQIRUPRZDüX*\WNRZQLNDRW\PFRUREL

34 Turbo

Pascal

—

programowanie

•

Z\QLNG]LDáDQLDSURJUDPXQLHSRZLQLHQ]QLNDüOHF]]RVWDZDüQDHNUDQLHWDN

GáXJRMDN*\F]\VRELHX*\WNRZQLN

•

Z\ZLHWODQDOLF]EDSRZLQQDáDGQLHMZ\JOGDü

3LHUZV]\ SUREOHP PR*QD UR]ZL]Dü Z\SURZDG]DMF QD HNUDQ GRGDWNRZ LQIRUPDFM
w

SRVWDFLWHNVWX6áX*\GRWHJR]QDQD&LMX*SURFHGXUD

write

NWyUDW\PUD]HPEG]LH

Z\SLV\ZDáD QD HNUDQLH QLH Z\UD*HQLH OLF]ERZH OHF] áDFXFK D FLOHM U]HF] ELRUF

W]ZVWDááDFXFKRZF]\OLFLJ]QDNyZ6WDááDFXFKRZMHVWZ3DVFDOXGRZROQ\

FLJ]QDNyZXMHW\ZDSRVWURI\

, nie

&LJWDNLPR*H]DZLHUDüGRZROQH]QDNL]QDN

DSRVWURIX QRUPDOQLH NRF]F\ áDFXFK ]DSLVXMH VL MDNR GZD DSRVWURI\ WM GZD
oddzielne znaki

DQLH]QDNFXG]\VáRZX

). C

DáRüEG]LHZ\JOGDáDQDVWSXMFR

write('Program oblicza pole kola o promieniu 5 cm.')

6SUyEXMWHUD]SU]\MU]HüVLRSLVRZLSURFHGXU\

write

]SRSU]HGQLHJRUR]G]LDáXL]DVWD-

QRZLüVLMDNSRZLQQDZ\JOGDüLQVWUXNFMDZ\SLVXMFDQDHNUDQLHWHNVW

Pole kola = .....

ZPLHMVFXNURSHNSRZLQQD]QDOH(üVLREOLF]RQDSU]H]QDV]SURJUDPOLF]ED-HOLQLH

ZLHV]MDNWR]URELüU]XüRNLHPQDWHNVWQDVWSQHJRSURJUDPX=DXZD*SU]\RND]ML*H

SRMDZLáDVLZQLPGUREQDQRZLQNDPLDQRZLFLHSURFHGXUD

writeln

Uy*QLFDVL od

write

W\ONRW\P*HSRMHMZ\NRQDQLXNXUVRUSU]HFKRG]LGRQRZHJRZLHUV]DLWDPWH*

Z\SLV\ZDQHVNROHMQHLQIRUPDFMH$E\SU]HNRQDüVLRUy*QLF\ZG]LDáDQLXREXSUR-

FHGXU]DPLHSLHUZV]LQVWUXNFM

writeln

write

i wykonaj program.

6SUDZDGUXJDF]\OL]DWU]\PDQLHZ\QLNXQDHNUDQLHPRQLWRUDUyZQLH*GDMHVLSURVWR

UR]ZL]Dü:\VWDUF]\PLDQRZLFLHQDNRFXSURJUDPXGRSLVDüLQVWUXNFM

readln;

i gotowe. Co to takiego

readln

—

WRMX*LQQDVSUDZDSURFHGXU

readln

LSRNUHZQ

jej

read

]DMPLHP\ VL ZNUyWFH QD UD]LH ]D Z\VWDUF]\ &L ZLHG]LHü W\OH *H

readln

RGF]\WXMH ] NODZLDWXU\ GRZROQ\ FLJ ]QDNyZ ]DNRF]RQ\ ]QDNLHP QRZHJR ZLHUV]D
(kodem klawisza

NTER

WRWH* MHM Z\ZRáDQLH SRZRGXMH ]DWU]\PDQLH G]LDáDQLD

SURJUDPXGRPRPHQWXQDFLQLFLDWHJR*NODZLV]D
3R]RVWDáDVSUDZDRVWDWQLDWM]URELHQLHSRU]GNX]PDáRF]\WHOQUHSUH]HQWDFMZ\SUR-

ZDG]DQHJRSROD1DSRF]WHNUR]V]\IUXMP\]DSLV

7.8539816340E+01

Jest to nic innego, jak 7.8539816340· 10

F]\OLRNRáR=DSLV

x.xxxxEnn

oznacza

ZLFOLF]E

x.xxxx

pomno

*RQSU]H]GRSRWJL

i zwany jest zapisem naukowym.

=DXZD*SU]\RND]ML*HF]üXáDPNRZDOLF]E\RGG]LHORQDMHVWRGF]FLU]HF]\ZLVWHM

QLHSU]HFLQNLHPOHF]NURSNEDUG]RZD*QH:\NáDGQLN

jest zawsze dobierany tak,

E\]QDMGXMFDVLÄSU]HGQLP´OLF]EDPLDáDW\ONRMHGQF\IUSU]HGNURSNWM]DZLHUDáD

VLZSU]HG]LDOHRGGR:LHONRüOLWHU\(V\PEROL]XMFHMZ\NáDGQLNQLHPD]QD-

F]HQLD]D]QDNPR*QDSRPLQü2WRNLONDSU]\NáDGyZ

3.14E+00 = 3.14

1.2345e4 = 12345

2.78E–3 = 0.00278

1,35E12 =

EáG (jaki?)

1LFQLHMHVWGRVNRQDáH

=DSLVQDXNRZ\SR]ZDODQDáDWZHLMHGQROLWHUHSUH]HQWRZDQLHEDUG]RPDá\FKLEDUG]R

GX*\FKOLF]EMHVWMHGQDNQLH]E\WF]\WHOQ\$E\XF]\QLüJREDUG]LHMVWUDZQ\PPR*QD

X*\ü W]Z formatowania SROHJDMFHJR QD SU]HND]DQLX SURFHGXU]H

write

(

writeln

)

GRGDWNRZ\FKLQIRUPDFMLRSLVXMF\FKVSRVyEZ\SURZDG]HQLDOLF]E\:SU]\SDGNXOLF]E

U]HF]\ZLVW\FK LQIRUPDFMH WH RNUHODM FDáNRZLW V]HURNRü SROD ]DZLHUDMFHJR OLF]E

RUD]LORüSR]\FMLSRNURSFHG]LHVLWQHMLPRJE\üV\PEROLF]QLH]DSLVDQHMDNR

ZDUWRüV]HURNRü

-pola:liczba-cyfr-po-kropce

/LF]ED]DZLHUDMFDPQLHMF\IUQL*RNUHORQRZV]HURNRFLSRODMHVWÄGRVXZDQD´GRSUD-

ZHM VWURQ\ L X]XSHáQLDQD ] OHZHM ]QDNDPL VSDFML 8VWDODMF V]HURNRü SROD PXVLV]

UyZQLH*XZ]JOGQLüPLHMVFHQDNURSNG]LHVLWQLHZHQWXDOQ\]QDNOLF]E\

:WHQVSRVyEGRWDUOLP\GRNROHMQHMZHUVMLSURJUDPXREOLF]DMFHJRSROHNRáD

program Pole_kola;

^3URJUDPREOLF]DSROHNRáDRSURPLHQLX`

begin
writeln('Program oblicza pole kola');
write('Pole = '; Pi*5*5:8:3); (* oblicz i wypisz *)
(* pole kola *)
readln;
end.

6NRUR MX* PyZLP\ R IRUPDWRZDQLX ZDUWR MHV]F]H ZVSRPQLHü *H GOD OLF]E

FDáNRZLW\FK QLH SRVLDGDMF\FK F]FL XáDPNRZHM Z\VWDUF]\ RNUHOHQLH V]HURNRFL
pola, czyli zapis

ZDUWRüV]HURNRü

-pola

:LGHQW\F]Q\VSRVyEPR*QDUyZQLH*IRUPDWRZDüQSáDFXFK\FRMHGQDNVWRVRZDQH

MHVWU]DGNR=DSU]\NáDGQLHFKSRVáX*\NROHMQ\SURJUDP

program Formatowanie;

^'HPRQVWUDFMDPR*OLZRFLIRUPDWRZDQLDZ\GUXNyZ`

begin
writeln(1.23

^]DPDáRPLHMVFDSRNURSFH`

ZULWHOQ^]DPDáRPLHMVFDZRJyOH`

ZULWHOQ^RNUHODP\W\ONRV]HURNRüSROD`

ZULWHOQ^IRUPDWRZDQLHOLF]E\FDáNRZLWHM`

ZULWHOQ^IRUPDWRZDQLHáDFXFKD`

end.

:WHQVSRVyERPyZLOLP\SRGVWDZRZH]DELHJLNRVPHW\F]QHNWyU\PPR*HP\SRGGDü

QDV]SURJUDP3UH]HQWXMHVLRQMX*QLHFRáDGQLHMMHGQDN]PLDQ\NWyU\FKGRNRQDOLP\

PDM FKDUDNWHU SRZLHU]FKRZQ\ &R ERZLHP ]URELV] *HE\ REOLF]\ü SROH NRáD o pro-

PLHQLXFP"3RSUDZLV]SURJUDPLVNRPSLOXMHV]JRMHV]F]HUD]"&K\EDMHGQDNSURFLHM

Z]LüNDONXODWRUDPR*HQLH

36 Turbo

Pascal

—

programowanie

=DSDPLWDM

•

3URJUDP\QDOH*\SLVDüF]\WHOQLHJG\*XáDWZLDWRLFK]UR]XPLHQLHLHZHQWXDOQH

ZSURZDG]DQLHSy(QLHMV]\FK]PLDQ

•

3URJUDP PR*QD RSLVDü QDJáyZNLHP ]DF]\QDMF\P VL RG VáRZD NOXF]RZHJR

program

•

%DUG]R ZD*QH GOD F]\WHOQRFL SURJUDPX V NRPHQWDU]H ]DSLV\ZDQH Z
nawiasach klamrowych, oraz odpowiednie wcinanie poszczególnych instrukcji.

•

$E\ Z\SURZDG]Dü LQIRUPDFMH Z NROHMQR QDVWSXMF\FK SR VRELH ZLHUV]DFK

SRZLQLHQHX*\üSURFHGXU\

writeln

•

&KFFZVWU]\PDüG]LDáDQLHSURJUDPXPR*HV]X*\üSURFHGXU\

readln

•

$E\XF]\QLüZ\GUXNEDUG]LHMF]\WHOQ\P]DVWRVXMIRUPDWRZDQLHZ\MFLD

Ulepszamy dalej

1LHWU]HEDFK\EDQLNRJRSU]HNRQ\ZDü*HSRU]GQ\SURJUDPSRZLQLHQXPLHüVDP]D-

S\WDüX*\WNRZQLNDRZDUWRüSURPLHQLDLREOLF]\üSROHEH]NRQLHF]QRFLXFL*OLZHJR

SRSUDZLDQLDLNRPSLORZDQLDWHNVWX:W\PFHOXQDOH*DáRE\Z\SLVDüQDHNUDQLHRGSR-

ZLHGQLHS\WDQLHFRMX*SRWUDILV]]URELüDQDVWSQLHZSURZDG]Lü]NODZLDWXU\ZDUWRü

SURPLHQLD L Z\NRU]\VWDü M GR REOLF]HQLD SROD NRáD ]H Z]RUX 6

%D áDWZR

SRZLHG]LHüDOHMDNZSURZDG]LüMDNZDUWRüGRSURJUDPXLJG]LHMSU]HFKRZDü"

5R]ZL]DQLHPWHJRSUREOHPXMHVWX*\FLHzmiennej. Podobnie jak w matematyce, zmien-

QDV\PEROL]XMHSHZQZDUWRüF]\OLPR*HE\üWUDNWRZDQDMDNRVZHJRURG]DMXSRMHP-

QLNGRNWyUHJRZNáDGDP\QSOLF]EZDUWRüSURPLHQLDÄ)L]\F]QLH´ZDUWRü]PLHQ-

QHMXPLHV]F]DQDMHVWJG]LHZSDPLFLNRPSXWHUDLPR*HE\ü]ORNDlizowana poprzez
adres

F]\OL QXPHU RGSRZLHGQLHM NRPyUNL SDPLFL 3RQLHZD* SRVáXJLZDQLH VL

DGUHVDPL MHVW QLH]E\W Z\JRGQH 3DVFDO XPR*OLZLD RGZRá\ZDQLH VL GR ]PLHQnej za

SRPRFnazwyEGFHM]Z\Ná\PLGHQW\ILNDWRUHPLQIRUPDFMHQDWHPDWLGHQtyfikatorów
znaj

G]LHV] QD VWURQLH 'RGDWNRZ LQIRUPDFM QLH]EGQ GR XVWDlenia sposobu

SRVáXJLZDQLDVL]PLHQQLMHMUHSUH]HQWDFMLZSDPLFLMHVWtyp — w naszym przypadku

EG]LHWRW\S]PLHQQRSU]HFLQNRZ\RGSRZLDGDMF\ZDUWRFLU]HF]\ZLVWHM

real

3RQLHZD* NRPSLODWRU WáXPDF]\ WHNVW (UyGáRZ\ SURJUDPX QD EH]SRUHGQLR

Z\NRQ\ZDOQSU]H]NRPSXWHUSRVWDüZ\QLNRZPXVLZLHG]LHüMDNUHSUH]HQWRZDüGDQ

]PLHQQ Z SDPLFL L MDN VL ] QL REFKRG]Lü 1LH]EGQH MHVW ]DWHP zadeklarowanie

ND*GHMX*\ZDQHMZSURJUDPLH]PLHQQHMF]\OLSU]HND]DQLHNRPSLODWRURZLLQIRUPDFMLR

MHM QD]ZLH L W\SLH 'R GHNODURZDQLD ]PLHQQ\FK VáX*\ VSHFMDOQH VáRZR NOXF]RZH

var

(ang. variable —

]PLHQQD]DVNáDGQLDGHNODUDFMLPDSRVWDü

var
lista-nazw : typ-1;
lista-nazw : typ-2 ...

przy czym lista-nazw

WRFLJQD]Z]PLHQQ\FKWHJRVDPHJRW\SXUR]G]LHORQ\FKSU]HFLQ-

NDPL$E\]DGHNODURZDüNROHMQJUXS]PLHQQ\FKLQQHJRW\SXQLHPXVLV]SRQRZQLH

X*\ZDüVáRZD

var

Z\VWDUF]\GRSLVDüSRGVSRGHPQRZOLVWLSRGDüQD]ZW\SX

38 Turbo

Pascal

—

programowanie

2VWDWQLPZ\PDJDQLHPRNWyU\PPXVLV]SDPLWDüMHVWXPLHV]F]DQLHZV]\VWNLFKGHNOD-

UDFML SU]HG F]FL RSHUDF\MQ SURJUDPX SRQLHZD* EH]SRUHGQLR Z\NRU]\VWXMH RQD

]DGHNODURZDQHRELHNW\PXV]RQH]RVWDüRSLVDQHSU]HGMHMUR]SRF]FLHP

3R ]DGHNODURZDQLX PR*QD MX* ÄQRUPDOQLH´ NRU]\VWDü ]H ]PLHQQHM F]\OL QDGDZDü MHM

ZDUWRüZ\NRU]\VW\ZDüZZ\UD*HQLDFKOXEZ\SURZDG]DüQDHNUDQPRQLWRUD0XVLV]

MHGQDNSDPLWDü*HVDPDGHNODUDFMDQLHQDGDMH]PLHQQHMVHQVRZQHMZDUWRFLDMHG\QLH

LQIRUPXMHNRPSLODWRURMHMLVWQLHQLXLZáDFLZRFLDFK3U]HGX*\FLHP]PLHQQHMPXVLV]
koniecznie

QDGDü MHM ZDUWRü ]DLQLFMDOL]RZDü M SU]H] ZSURZDG]HQLH MHM ZDUWRFL

NODZLDWXU\OXE]DSRPRFW]Zinstrukcji przypisania.

)HE\GáX*HMQLHWHRUHW\]RZDü]DGHPRQVWUXMP\QRZZHUVMQDV]HJRSURJUDPX

program Pole_kola;
{ Pr

RJUDPREOLF]DSROHNRáDRSURPLHQLX`

^3URPLHZSURZDG]DQ\MHVW]NODZLDWXU\`

var { deklaracja zmiennych }

UUHDO^SURPLHNRáD

– zmienna rzeczywista }

begin
writeln('Program oblicza pole kola');
write('Podaj promien kola: ');

UHDGOQU^RGF]\WDM]PLHQQ`

{ z klawiatury }
write('Pole = '; Pi*r*r:8:3); { oblicz i wypisz }

^SROHNRáD`

readln;
end.

=DSHZQH ]DXZD*\áH MX* Z SURJUDPLH ]QDQ &L ] SRSU]HGQLHJR UR]G]LDáX SURFHGXU

readln

7XWDMSHáQLRQDLQQZáDFLZLHVZRM]DVDGQLF]IXQNFMDPLDQRZLFLHRG-

czy

WXMHZDUWRü]PLHQQHMr]NODZLDWXU\6NáDGQLDSURFHGXU\

readln

MHVWQDVWSXMFD

readln[(zmienna, zmienna...)];

LZ\JOGDSRGREQLHMDNGODÄRGZURWQHM´SURFHGXU\

writeln

]WGUREQUy*QLF*H

argumentami

readln

PRJE\üMHG\QLH]PLHQQH'ODF]HJR"3URFHGXUD

readln

pobie-

UD]NODZLDWXU\DFLOHMU]HF]ELRUF]W]ZZHMFLDSURJUDPXSHZQZDUWRüLPXVL

MJG]LHXPLHFLü:DUWRüPR*H]RVWDüXPLHV]F]RQDZ]PLHQQHMF]\OLJG]LHZSD-

PLFLQLHPR*HMHGQDN]RVWDü]DSLVDQDZZ\UD*HQLXNWyUHMHVWMHG\QLH]DSLVHPSHZQHM

RSHUDFML L QLH SRVLDGD ORNDOL]DFML Z SDPLFL NRPSXWHUD 3RGREQLH QLHGRSXV]F]DOQH

EG]LHX*\FLHMDNRDUJXPHQWXVWDáHMOXER]JUR]RRSHUDWRUD

Pokrewna procedura

read

VWRVRZDQD MHVW ]QDF]QLH U]DG]LHM Uy*QLFD PLG]\ QL

readln

VSURZDG]DVLSRGREQLHMDNGOD

write

writeln

GRWHJRL*SRRGF]\-

taniu swoich argumentów

readln

SU]HFKRG]LGRQDVWSQHJRZLHUV]DGDQ\FKZHMFLR-

wych, a

read

nie. Procedura

read

X*\ZDQDMHVWJáyZQLHGRF]\WDQLDGDQ\FK]SOLNyZ

R NWyU\FK Sy(QLHM ]D MHM X*\FLH GR ZSURZDG]DQLD GDQ\FK ] NODZLDWXU\ PR*H

GRSURZDG]LüGRQLHVSRG]LHZDQ\FKHIHNWyZGODWHJRWH*QDUD]LHOHSLHMMHMXQLNDü

Ulepszamy dalej

3RUD SRZLHG]LHü FR ZLFHM QD WHPDW W\SyZ 7\S ]PLHQQHM RNUHOD MHM ZHZQWU]Q

UHSUH]HQWDFMZSDPLFLNRPSXWHUDOLF]EEDMWyZ]DMPRZDQ\FKSU]H]]PLHQQ]DNUHV

GRSXV]F]DOQ\FKZDUWRFLLGRNáDGQRüUHSUH]HQWDFMLRUD]]HVWDZRSHUDFMLNWyUHPR*QD

QD QLHM Z\NRQ\ZDü .LONDQDFLH VWDQGDUGRZ\FK W\SyZ GRVWSQ\FK Z 7XUER 3DVFDOX

RSLV]HP\ZSRQL*V]HMWDEHOL=Z\MWNLHPW\SX

string

ZV]\VWNLHRQHQDOH*GRW]Z

typów prostych

QLHGDMF\FKVLUR]ELüQDSURVWV]HW\S\

Tablica 1.

1DMZD*QLHMV]HW\S\GRVWSQHZ7XUER3DVFDOX

Nazwa Znaczenie

=DNUHVZDUWRFL

3U]\NáDG

integer

OLF]EDFDáNRZLWD]H]QDNLHP –32768..+32767

–14574

real

liczba rzeczywista

2.9· 10

–39

..1.7· 10

1.23245e17

char

znak

znaki o kodach 0..255

'a'

string

QDSLVáDFXFKFLJ]QDNyZ

FLJGR]QDNyZ 'Napis'

boolean

ZDUWRüORJLF]QD

prawda (true

OXEIDáV]false) false

word

s³owo 0..65535

56412

byte

bajt 0..255

127

shortint

NUyWNDOLF]EDFDáNRZLWD]H]QDNLHP –128..+127 –13

longint

GáXJDOLF]EDFDáNRZLWD]H]QDNLHP –2147483648..+2147483647

–1986734234

single

krótka liczba rzeczywista

1.5· 10

–45

..3.4· 10

3.14e01

double

GáXJDOLF]EDU]HF]\ZLVWD 5.0· 10

–324

..1.7· 10

308

–1.8e+234

extended

EDUG]RGáXJDOLF]EDU]HF]\ZLVWD 3.4· 10

–4932

..1.1· 10

4932

4.5e2345

comp

EDUG]RGáXJDOLF]EDFDáNRZLWD –9.2· 10

..9.2· 10

6e12

pointer

ZVND(QLN 0000h:0000h..FFFFh:FFFFh

$1234:ABCD

&]WHU\ SLHUZV]H W\S\ Z\PLHQLRQH Z WDEHOL VWDQRZL SRGVWDZRZ\ ]HVWDZ NWyU\P

EG]LHV]SRVáXJLZDáVLSRGF]DVSLVDQLDSURJUDPyZ7\S\FDáNRZLWH

integer

word

shortint

byte

longint

), typ znakowy (

char

) oraz logiczny (

boolean

WZRU]

NROHLJUXSW]ZW\SyZSRU]GNRZ\FK (ang. ordinal typesZUDPDFKNWyU\FKRNUH-

ORQDMHVWUHODFMDSRU]GNXF]\OLNWRSU]HGNLPDNWRSRNLP

7\S\FDáNRZLWHX*\ZDQHVZSURJUDPDFKGRUHSUH]HQWDFMLOLF]QLNyZDGresów i inde-

NVyZWDEOLFRUD]]DZDUWRFLNRPyUHNSDPLFL

byte

word

3DPLWDM*H]HZ]JOGX

QD VSHF\ILF]Q UHSUH]HQWDFM ZHZQWU]Q OLF]E FDáNRZLW\FK SU]HNURF]HQLH ]DNUHVX
dopuszczalnego dla danego typu powoduje „przeskoczenie” na drugi koniec zakresu
(np. dodanie 1 do 32767 da w wyniku –32768). Efekt ten zwykle nie jest

V\JQDOL]RZDQ\ SU]H] NRPSLODWRU L PR*H SURZDG]Lü GR GRü G]LZDF]QHJR ]DFKRZDQLD

SURJUDPyZ$E\JRXQLNQüPR*HV]]DVWRVRZDüSRMHPQLHMV]\W\SQS

longint

'UXJ REV]HUQ JUXS WZRU] W\S\ Uzeczywiste, przeznaczone do przechowywania

ZDUWRFL QLHFDáNRZLW\FK L UHDOL]DFML ZLNV]RFL EDUG]LHM ]áR*RQ\FK REOLF]H PDWHPD-

W\F]Q\FK : ZLNV]RFL SU]\SDGNyZ ]DGRZDODMFH UH]XOWDW\ RVLJD VL SU]\ X*\FLX
liczb typu

real

MHGQDN GOD SRSUDZ\ GRNáDGQRFL SRZLNV]HQLD ]DNUHVX ZDUWRFL

SU]\VSLHV]HQLD REOLF]H ZDUWR RGZRáDü VL GR MHGQHJR ] SR]RVWDá\FK W\SyZ ,FK

Z\NRU]\VWDQLH Z\PDJD ]DGHNODURZDQLD X*\FLD Z SURJUDPLH W]Z koprocesora aryt-
metycznego

VSHFMDOQHJR XNáDGX SU]H]QDF]RQHJR GR RSHURZDQLD QD OLF]EDch rzeczy-

40 Turbo

Pascal

—

programowanie

ZLVW\FK GRVWSQHJR MDNR RGG]LHOQ\ XNáDG OXE ZEXGRZDQHJR Z SURFHVRU\ ';
i „lepsze”) albo tzw. emulatora

F]\OL VSHFMDOQHJR SRGSURJUDPX ÄXGDMFHJR´ NRSUR-

FHVRU$E\E\áRPR*OLZHRGZRáDQLHVLGRNRSURFHVRUDQDOH*\ZáF]\üRSFMNumeric
Processing — 8087/80287 w polu dialogowym Options-Compiler

]D ZáF]HQLH

HPXODFML UHDOL]XMH ]QDMGXMFD VL SRQL*HM RSFMD Emulation $OWHUQDW\Z MHVW XPLHV]-
czenie w programie tzw. dyrektyw kompilatora

PDMF\FKRGSRZLHGQLRSRVWDü

{$N+}

{$E+}

7\S\]QDNRZ\LáDFXFKRZ\Z\NRU]\VW\ZDQHVGRUHSUH]HQWRZDQLDQDSLVyZLZV]HO-

NLHMLQIRUPDFMLÄVáRZQHM´7\S

boolean

SR]ZDODQDSU]HFKRZ\ZDQLHZDUWRFLORJLF]-

Q\FK Z\NRU]\VW\ZDQ\FK GR VWHURZDQLD G]LDáDQLHP SURJUDPX ]D W\S ZVND(QLNRZ\
(

pointer

X*\ZDQ\MHVWZRSHUDFMDFKQD]DZDUWRFLSDPLFLNRPSXWHUDQLHFRG]LZQ\

]DSLV $%&' R]QDF]D DGUHV NRPyUNL SDPLFL Z SRVWDFL V]HVQDVWNRZHM V\JQD-
lizowanej znakiem $).

1D W\P ]DNRF]\P\ WHQ NUyWNL UR]G]LDá 1D NROHMQ\FK NLONX VWURQDFK ]DMPLHP\ VL

Z\UD*HQLDPLLLFKHOHPHQWDPLVNáDGRZ\PL]DZFKDUDNWHU]HüZLF]HQLDSURSRQXM&L

]PRG\ILNRZDQLH QDV]HJR SURJUDPX WDN E\ REOLF]Dá RQ SROH WUyMNWD QD SRGVWDZLH

ZSURZDG]RQHM]NODZLDWXU\GáXJRFLSRGVWDZ\LZ\VRNRFL

=DSDPLWDM

•

'RSU]HFKRZ\ZDQLDZDUWRFLVáX*ZSURJUDPLH]PLHQQH

•

&HFKDPL FKDUDNWHU\VW\F]Q\PL ]PLHQQHM V QD]ZD L W\S 1D]ZD SR]ZDOD QD

]LGHQW\ILNRZDQLH]PLHQQHM]DW\SRNUHODMHMZHZQWU]QUHSUH]HQWDFML]DNUHV

ZDUWRFLRUD]GRSXV]F]DOQ\FKRSHUDFML

•

3U]HGX*\FLHP]PLHQQDPXVL]RVWDü]DGHNODURZDQD]DSRPRFVáRZDNOXczo-
wego

var

) oraz zaincjalizowana (przez przypisanie lub wprowadzenie war

WRFL

]HZQWU]QS]NODZLDWXU\

•

'R ZSURZDG]DQLD ZDUWRFL ]PLHQQ\FK ] NODZLDWXU\ VáX* SURFHGXU\

readln

read

•

7XUER 3DVFDO RIHUXMH NLONDQDFLH VWDQGDUGRZ\FK W\SyZ VSRUyG NWyU\FK

QDMF]FLHM VWRVRZDQ\PL V W\S FDáNRZLW\

integer

), rzeczywisty (

real

znakowy (

char

LáDFXFKRZ\

string

•

7\S\ FDáNRZLWROLF]ERZH ]QDNRZH RUD] W\S

boolean

WZRU] JUXS W\SyZ

SRU]GNRZ\FK

:\UD*HQLD

7HPDWZ\UD*HQLD]RVWDáÄSU]HP\FRQ\´GRNVL*NLMX*GRüGDZQRWHPXLZ\SDGDáRE\
w

NRFX W NZHVWL Z\MDQLü : QLQLHMV]\P UR]G]LDOH VSUyEXMHP\ Z\MDQLü F]\P V

Z\UD*HQLDGRF]HJRVáX*RUD]MDNLHVLFKVNáDGQLNLLUHJXá\WZRU]HQLD

:\UD*HQLD SR]ZDODM QD SU]HNV]WDáFDQLH LQIRUPDFML Z FHOX X]\VNDQLD RGSRZLHGQLFK

Z\QLNyZLVWDQRZLMHGHQ]SRGVWDZRZ\FKVNáDGQLNyZSURJUDPyZ.D*GHZ\UD*HQLH
stanowi symboliczny zapis pewnej operacji na danych reprezentowanych przez zmienne

RSLVDQHLGHQW\ILNDWRUDPLLVWDáH]DSLVDQHMDZQLH6DPDRSHUDFMDUHDOL]RZDQDMHVW za

SRPRFoperatorów oraz funkcji3RMFLHZ\UD*HQLDQDMáDWZLHMEG]LHQDP]LOXVWURZDü

QDSU]\NáDG]LHPDWHPDW\F]Q\PMDNZLDGRPRGáXJRüSU]HFLZSURVWRNWQHMcWUyMNWD

SURVWRNWQHJRZ\UD*DVLZ]RUHP

3U]HNáDGDMFWRQD3DVFDORWU]\PDP\

c := sqrt(a*a + b*b)

=DSLV]QDMGXMF\VLSRSUDZHMVWURQLH]QDNX

(tak zwanego operatora przypisania)

MHVWZáDQLHZ\UD*HQLHP:MHJRVNáDGZFKRG]F]WHU\LGHQW\ILNDWRU\

) symbo-

OL]XMFH ]PLHQQH SU]HFKRZXMFH GáXJRFL SU]\SURVWRNWQ\FK WU]y operatory (

)

V\PEROL]XMFHRSHUDFMHPQR*HQLDLGRGDZDQLDRUD]LGHQW\ILNDWRU

sqrt

UHSUH]HQWXMF\

IXQNFM—SLHUZLDVWHNNZDGUDWRZ\3RQLHZD*R]PLHQQ\FKLVWDá\FKMX*PyZLOLP\

]DMPLHP\VLREHFQLHRSHUDWRUDPL

2SHUDWRU MHVW ]DVWU]H*RQ\P VáRZHP M]\ND VWDQRZLF\P V\PEROLF]Q UHSUH]HQWDFM

SHZQHJRG]LDáDQLDQDGDQ\FKUHSUH]HQWRZDQ\FKSU]H]argumentyRSHUDWRUD:ZLN-

V]RFLSU]\SDGNyZRSHUDWRU\SRVLDGDMGZDDUJXPHQW\LVWQLHMMHGQDNUyZQLH*RSHUD-
tory jednoargumentowe. W Pascalu zdefiniowano kilka grup operatorów, z których

QDMF]FLHMZ\NRU]\VW\ZDQ\PLV]DSHZQHoperatory arytmetyczne:

42 Turbo

Pascal

—

programowanie

Tablica 2. Operatory arytmetyczne

Operator Znaczenie

3U]\NáDG

PQR*HQLH

2 = 4

dzielenie 2

3 = 0.66666...

div

G]LHOHQLHFDáNRZLWH 2

div

3 = 0

mod

reszta z dzielenia

mod

2 = 1

dodawanie 2

3 = 5

–

odejmowanie

–

3 = –1

–

(jednoargumentowy)

zmiana znaku

–

1 = –1

=Z\MWNLHPRSHUDWRUyZ

div

mod

SU]H]QDF]RQ\FKZ\áF]QLHGRG]LDáDQDOLF]EDFK

FDáNRZLW\FKZV]\VWNLHSR]RVWDáHRSHUDWRU\ÄZVSyáSUDFXM´]DUyZQR]OLF]EDPLFDáNR-

ZLW\PLMDNLU]HF]\ZLVW\PL:SU]\SDGNXZ\NRQ\ZDQLDNLONXG]LDáDZREUELHMHG-

QHJR Z\UD*HQLD LVWRWQ\ MHVW W]Z priorytet operatorów RNUHODMF\ SLHUZV]HVWZR

SHZQ\FK G]LDáD SU]HG LQQ\PL 'OD RSHUDWRUyZ DU\WPHW\F]Q\FK SULRU\WHW\ Z\JOGDM

PQLHM ZLFHM WDN MDN Z Ä]Z\NáHM´ PDWHPDW\FH SLHUZV]HVWZR PDM RSHUDWRU\ PQR-

*HQLDLG]LHOHQLD

div

mod

), wykonywane zawsze przed dodawaniem i odejmo-

ZDQLHP']LDáDQLDUHSUH]HQWRZDQHSU]H]RSHUDWRU\RW\PVDP\PSULRU\WHFLHZ\NRQ\-
wane

VZNROHMQRFLRGOHZHMGRSUDZHM

3DPLWDQLH R SULRU\WHWDFK RSHUDWRUyZ MHVW VSUDZ EDUG]R LVWRWQ JG\* QLHZáDFLZD

NROHMQRüZ\NRQ\ZDQLDG]LDáDSURZDG]LF]VWRGRX]\VNDQLD]XSHáQLHLQQHJRZ\QLNX

QL*VLVSRG]LHZDOLP\3U]\NáDGRZRLORUD]

1 2

QLH]RVWDQLHSRSUDZQLHREOLF]RQ\MHOL]DSLV]HV]JRZSRVWDFL

1 + 2 / 3

ERZLHP]DPLDVWZDUWRFLRWU]\PDV]SOXVF]\OL:áDFLZNROHMQRü

Z\NRQ\ZDQLD G]LDáD PR*HV] MHGQDN Z\PXVLü ]D SRPRF QDZLDVyZ ]DSLVXMF QDV]
iloraz jako

(1 + 2) / 3

)UDJPHQW\ Z\UD*HQLD XMWH Z QDZLDV\ V ]DZV]H REOLF]DQH SU]HG Z\NRQDQLHP

ZV]\VWNLFK SR]RVWDá\FK G]LDáD 1DZLDVyZ ZDUWR D QDZHW QDOH*\ X*\ZDü UyZQLH*

ZyZF]DVJG\QLHMHVWVLSHZQ\PFRGRNROHMQRFLZ\NRQ\ZDQLDG]LDáD3DPLWDM*H

QDZLDV\QLHSRZRGXMJHQHURZDQLDGRGDWNRZHJRNRGXZ\QLNRZHJRDMHG\QLH]PLH-

QLDMNROHMQRüRSHUDFMLDZLFÄQLFQLHNRV]WXM´RSUyF]NRQLHF]QRFLZSLVDQLDNLONX

GRGDWNRZ\FK ]QDNyZ FR MHGQDN MHVW OHSV]H RG QDUD*DQLD VL QD WUXGQR Z\NU\ZDOQH

EáG\

Operat

RU\ DU\WPHW\F]QH QLH Z\F]HUSXM RF]\ZLFLH DUVHQDáX GRVWSQHJR Z 7XUER

3DVFDOX .ROHMQ JUXS WZRU] operatory bitowe i logiczne QD]ZDQH WDN GODWHJR L*

:\UD*HQLD

SU]H]QDF]RQH V GR Z\NRQ\ZDQLD G]LDáD QD ELWDFK OLF]E FDáNRZLW\FK OXE GR

SU]HNV]WDáFDQLDZDUWRFLORJLF]Q\FK$RWRRQH

Tablica 3. Operatory bitowe i logiczne

Operator Znaczenie

3U]\NáDG

logiczny

bitowy

not

negacja

not

true = false

not

15 = 240

and

iloczyn logiczny

true and false = false 7

and

15 = 7

shl

SU]HVXQLFLHELWyZZOHZR

shl

2 = 28

shr

SU]HVXQLFLHELWyZZSUDZR

128

shr

4 = 8

suma logiczna

true

false = true 7

128 = 135

xor

suma modulo 2

true

xor

true = false 7

xor

15 = 8

=UR]XPLHQLH G]LDáDQLD RSHUDWRUyZ ORJLF]Q\FK QLH SRZLQQR QDVWUF]Dü WUXGQRFL -HOL

FKRG]LRRSHUDWRU\ELWRZHWRLFKG]LDáDQLHVSURZDG]DVLGRPDQLSXORZDQLDSRV]F]H-
gól

Q\PLELWDPLPRJF\PLSU]\MPRZDüZDUWRFLOXEZNRPyUNDFKSDPLFL]DMPR-

Q\FK SU]H] OLF]E -HGQRDUJXPHQWRZ\ RSHUDWRU

not

neguje poszczególne bity

]PLHQLDLFKZDUWRFLQDSU]HFLZQe), operator

and

ustawia dany bit wyniku na 1 tylko

ZWHG\JG\RGSRZLDGDMFHVRELHELW\REXDUJXPHQWyZPDMZDUWRü

— gdy co

QDMPQLHMMHGHQ]QLFKPDZDUWRü]D

xor

ustawia bit na 1 tylko wtedy, gdy jeden

ELWyZPDZDUWRüDGUXJL2SHUDWRU\

shl

shr

PDMFKDUDNWHUZ\áF]QLHELWRZ\

GODOLF]EFDáNRZLW\FKZSHZQ\PXSURV]F]HQLXSU]HVXQLFLHELWyZRn pozycji w lewo
lub w

SUDZR RGSRZLDGD SRPQR*HQLX OXE SRG]LHOHQLX SU]H]

: UDPDFK üZLF]H

SURSRQXM&LVSUDZG]LüSRSUDZQRüSRGDQ\FKZ\*HMSU]\NáDGyZSRWU]HEQD&LEG]LH

]QDMRPRüV\VWHPXGZyMNRZHJRZNWyU\PQSFDáNRZLWDOLF]ED]DSLV\ZDQDMHVWMDNR

F]\OLVHNZHQFMDRPLXELWyZ]NWyU\FKWU]\QDMPQLHM]QDF]FHPDMZDUWRü
1).

2VWDWQLZD*QJUXSRSHUDWRUyZVWDQRZLoperatory relacyjneVáX*FHGRSRUyZQ\-

ZDQLD RELHNWyZ QLH W\ONR OLF]E DOH UyZQLH* ]QDNyZ F]\ áDFXFKyZ :V]\VWNLH

RSHUDWRU\UHODF\MQHVGZXDUJXPHQWRZHRF]\ZLFLHW\S\REXDUJXPHQWyZPXV]E\ü

]JRGQH WM QLH PR*QD SRUyZQ\ZDü áDFXFKD ] OLF]E L GDM Z Z\QLNX ZDUWRü

ORJLF]Q

Tablica 4. Operatory relacyjne

Operator Znaczenie

3U]\NáDG

równy... 3

3.14 (false)

Uy*Q\RG 3

3.14 (true)

mniejszy od...

3.14 (true)

mniejszy lub równy... 3

3.14 (false)

ZLNV]\RG 3

3.14 (false)

ZLNV]\OXEUyZQ\ 3

3 (true)

44 Turbo

Pascal

—

programowanie

0XVLP\MHV]F]HXVWRVXQNRZDüVLGRZ\UD*HÄPLHV]DQ\FK´]DZLHUDMF\FKRSHUDWRU\

QDOH*FH GR NLONX JUXS 3U]\NáDGRZR REOLF]DMF Z\VRNRü VW\SHQGLXP VWXGHQFNLHJR

QDOH*\RNUHOLüF]\UHGQLDRFHQGHOLNZHQWDMHVWZ\VWDUF]DMFRZysoka, a dochód na

MHGQHJR F]áRQND URG]LQ\ Z\VWDUF]DMFR QLVNL $E\ ]DWHP XVWDOLü F]\ .RZDOVNLHPX

QDOH*\VLVW\SHQGLXPX*\MHP\SU]\NáDGRZHJRZ\UD*HQLD

(Dochod/LiczbaOsob < 150) and (Srednia > 3.75)

:\UD*HQLH WR ]DZLHUD GRVNRQDá PLHV]DQN RSHUDWRUyZ DU\WPHW\F]Q\FK ORJLF]Q\FK
i

UHODF\MQ\FK:WDNLFKV\WXDFMDFKNROHMQRüZ\NRQ\ZDQLDG]LDáDMHVWQDVWSXMFD

Tablica 5. Priorytety operatorów

Operatory Priorytet

not

QDMZ\*V]\

* / div mod and shl shr

QL*V]\

+ – or xor

MHV]F]HQL*V]\

= <> < <= > >=

QDMQL*V]\

2F]\ZLFLHMHOLZ\UD*HQLH]DZLHUDQDZLDV\LFK]DZDUWRü]RVWDQLHZ\OLF]RQDSU]HG

Z\NRQDQLHPSR]RVWDá\FKG]LDáD3RND]DQ\Z\*HMSU]\NáDGLOXVWUXMHMHGQRF]HQLHGRü

W\SRZ V\WXDFM Z NWyUHM PXVLP\ SRáF]\ü ]H VRE NLOND ZDUXQNyZ Z\UD*RQ\FK

QLHUyZQRFLDPLF]\OLRSHUDWRUDPLUHODF\MQ\PL3RQLHZD*GRáF]HQLDZDUXQNyZVáX*
operatory logiczne (zwykle

lub

and

PDMFHZ\*V]\SULRU\WHWQLH]EGQHMHVWX*\FLH

QDZLDVyZLFKSRPLQLFLHMHVWEDUG]RSRVSROLW\PEáGHPRUHDNFMLNRPSLODWRra najle-

SLHMSU]HNRQDMVLVDP

-DN MX* SRZLHG]LHOLP\ Z\UD*HQLD PRJ ]DZLHUDü HOHPHQW\ QDMUy*QLHMV]\FK W\SyZ

OLF]E\ ]QDNL áDFXFK\ LWS MHGQDN QDMF]FLHM EG]LHV] VSRW\NDá VL ] Z\UD*HQLDPL

UHSUH]HQWXMF\PLRSHUDFMHDU\WPHW\F]QH$E\UR]G]LDáWHQQLHRJUDQLF]DáVLGRSXVWHJR

WHURUHW\]RZDQLDVSUyEXMHP\]DVWRVRZDüZ\UD*HQLDZSUDNW\FHWZRU]FSURJUDPUR]-

ZL]XMF\UyZQDQLHNZDGUDWRZH]QDQ&L]DSHZQHPHWRGZ\]QDF]QLNyZ

=DSLVXMFQDV]HUyZQDQLHZSRVWDFL

a x

b x

⋅

+ ⋅ +

PR*HP\REOLF]\üSLHUZLDVWNLWMZDUWRFLxGODNWyU\FKUyZQDQLHSU]\MPXMHZDUWRü
zero) jako

− ±

∆

gdzie

' jest tzw. wyznacznikiem równania, obliczanym jako

∆ =

− ⋅ ⋅

a c

:\UD*HQLD

Znak

ZSRSU]HGQLPZ]RU]HR]QDF]D*HUyZQDQLHPDZRJyOQRFLGZDSLHUZLDVWNL

NWyU\FK MHGHQ REOLF]D VL SU]H] GRGDQLH ZDUWRFL Z OLF]QLNX XáDPND ]D GUXJL —

SU]H]LFKRGMFLH

6DPSURJUDPSRZLQLHQZ\JOGDüQDVWSXMFR

SRF]WHN

RGF]\WDMZDUWRFLZVSyáF]\QQLNyZDELF

REOLF]ZDUWRüZ\]QDF]QLND
oblicz pierwiastki i wypisz je na ekranie
koniec

:SRVWDFLSDVFDORZHMEG]LHWRQLHFREDUG]LHMVNRPSOLNRZDQH

program Rownanie_Kwadratowe;

^3URJUDPUR]ZL]XMHUyZQDQLHNZDGUDWRZHPHWRGZ\]QDF]QLNyZ`

var

DEFUHDO^ZVSyáF]\QQLNL`

delta : real; { wyznacznik }
x1, x2 : real; { pierwiastki }

begin
writeln('Program rozwiazuje rownanie kwadratowe')
writeln('a*x^2 + b*x + c');

ZULWH3RGDMZVSROF]\QQLND^ZSURZDG(ZVSyáF]\QQLNL`

readln(a);
write('Podaj wspolczynnik b: ');
readln(b);
write('Podaj wspolczynnik c: ');
readln(c);
delta := sqr(b) - 4*a*c; { oblicz wyznacznik }
x1 := (-b + sqrt(delta))/(2*a); { oblicz pierwiastki }
x2 := (-b - sqrt(delta))/(2*a); { znaczek := to tzw. }
{ przypisanie }

ZULWHOQ3LHUZLDVWNL^Z\ZLHWOSLHUZLDVWNL`

writeln('x1 = ', x1:12:4);
writeln('x2 = ', x2:12:4);
readln;
end.

:\UD*HQLDZ\NRU]\VW\ZDQHGRREOLF]DQLDSRV]F]HJyOQ\FKZDUWRFLVWXQLHFREDUG]LHM
skompli

NRZDQH DOH QDGDO QLH SRZLQLHQH PLHü SUREOHPyZ ] LFK DQDOL] 'ZRPD

nowy

PLQRQLHGRNRFDHOHPHQWDPLVoperator przypisania oraz funkcje.

Operator przypisania jest jednym z najpospoliciej wykorzystywanych operatorów
pascalowych. Znaczek

GZXNURSHN L ]QDN UyZQRFL F]\WD VL ÄVWDMH VL´ OXE

ÄSU]\SLV]´]DMHJRHIHNWVSURZDG]DVLGRXPLHV]F]HQLDZRELHNFLH]QDMGXMF\PVL

SROHZHMVWURQLHZDUWRFL]QDMGXMFHMVLSRSUDZHMVWURQLHÄ2ELHNW´XPLHV]F]RQ\SR

OHZHMVWURQLHRSHUDWRUDSU]\SLVDQLDRNUHlany jest mianem l-ZDUWRFLDQJlvalue). Jest

WRQDRJyá]PLHQQDPR*OLZHMHVWMHGQDNSU]\SLVDQLHZDUWRFLGRLGHQW\ILNDWRUDIXQNFML

R W\P EG]LHP\ MHV]F]H PyZLü 3RQLHZD* SU]\SLVDQLH SROHJD QD XPLHV]F]HQLX

46 Turbo

Pascal

—

programowanie

ZDUWRFLJG]LHZSDPLFLNRPSXWHUDZPLHMVFXRNUHORQ\PSU]H]QD]ZRELHNWXnie

PR*HV]SROHZHMVWURQLHRSHUDWRUDSU]\SLVDQLDXPLHFLüVWDáHMF]\Z\UD*HQLD3RSUDZHM

VWURQLH RSHUDWRUD SU]\SLVDQLD SDQXMH ]QDF]QLH ZLNV]D GHPRNUDFMD GRSXV]F]DOQH V

WDPSUDNW\F]QLHGRZROQHZ\UD*HQLDDZLFZV]F]HJyOQRFLUyZQLH*SRMHG\QF]HVWDáH
i

]PLHQQHE\OHE\W\SZDUWRFLX]\VNDQHMZZ\QLNXREOLF]HQLDZ\UD*HQLDE\á]JRGQ\

W\SHPRELHNWX]QDMGXMFHJRVLSRGUXJLHMVWURQLHRSHUDWRUD

=DJDGQLHQLH]JRGQRFLW\SyZZVHQVLHSU]\SLVDQLDDQJassignment compatibility) jest

W\OH* LVWRWQH FR ]áR*RQH = GRü GREU\P SU]\EOL*HQLHP PR*QD SRZLHG]LHü *H W\S
wyra

*HQLD]QDMGXMFHJRVLSRSUDZHMVWURQLHRSHUDWRUD

SRZLQLHQE\üLGHQW\F]Q\]

W\SHP RELHNWX ]QDMGXMFHJR VL SR OHZHM VWURQLH ] NLONRPD Z\MWNDPL 'R
najw

D*QLHMV]\FKZ\MWNyZQDOH*SU]\SLVDQLD

•

ZDUWRFLW\SXFDáNRZLWHJRGRRELHNWXW\SXU]HF]\ZLVWHJRDOHQLHRGZURWQLH

•

ZDUWRFLW\SXU]HF]\ZLVWHJRGRRELHNWXLQQHJRW\SXU]HF]\ZLVWHJRZGRZROQ

VWURQ

•

ZDUWRFLW\SX]QDNRZHJRGRRELHNWXW\SXáDFXFKRZHJR

•

ZDUWRFLW\SXÄZVND(QLNGRW\SX´GRRELHNWXW\SX

pointer

3U]\ WHM RND]ML ZDUWR UyZQLH* ZVSRPQLHü *H QLHNWyUH SU]\SLVDQLD SRPLG]\ W\SDPL

U]HF]\ZLVW\PL PRJ VSRZRGRZDü XWUDW GRNáDGQRFL OXE SU]HNURF]HQLH ]DNUHVX QS

SUyEDÄZFLQLFLD´ZDUWRFLW\SX

extended

do zmiennej typu

single

-HOLLG]LHRGUXJQRZRüF]\OLIXQNFMHWRZQDV]\PSURJUDPLHSRMDZLá\VLZ\ZR-

áDQLD GZyFK W]Z ELEOLRWHF]Q\FK IXQNFML DU\WPHW\F]Q\FK

sqr

sqrt

. Temat funkcji

EG]LH G\VNXWRZDQ\ QLHFR Sy(QLHM QDUD]LHZ\VWDUF]\&LZLHG]LHü*HIXQNFMDLSR-

NUHZQD MHM SURFHGXUD MHVW SHZQ\P QDU]G]LHP SR]ZDODMF\P QD SU]HNV]WDáFHQLH

SRGDQ\FKMHMZDUWRFLW]ZargumentówGR*GDQHMSRVWDFL3UDNW\F]QLHND*G\M]\N

SURJUDPRZDQLD G\VSRQXMH PQLHMV]\P OXE ZLNV]\P ]HVWDZHP ELEOLRWHN Iunkcji

UHDOL]XMF\FK RSHUDFMH DU\WPHW\F]QH ]QDNRZH JUDILF]QH L LQQH %LEOLRWHND IXQNFML
i

SURFHGXU GRVWSQ\FK Z 7XUER 3DVFDOX MHVW RJURPQD L RPDZLDQLH MHM PLMDáRE\ VL

FHOHP ZUyG F]VWR Z\NRU]\VW\ZDQ\FK IXQNFML DU\WPHW\F]Q\FK RSUyF] QLHU]DGNR

mylo

Q\FK]HVRE

sqr

(podniesienie do kwadratu) i

sqrt

(pierwiastek kwadratowy),

]QDMGXM VL UyZQLH* IXQNFMH WU\JRQRPHWU\F]QH

sin

cos

arctan

), logarytmiczne

(

exp

) i wiele innych.

:WHQVSRVyERPyZLOLP\]DVDGQLF]HWHPDW\]ZL]DQH]Z\UD*HQLDPLLUHDOL]DFMREOL-

F]HDU\WPHW\F]Q\FK:\NRU]\VWXMFSR]QDQHZLDGRPRFLPR*HV]SRNXVLüVLRQDSL-

VDQLHSURJUDPXREOLF]DMFHJRZDUWRFLEDUG]LHMVNRPSOLNRZDQ\FKZ]RUyZMDNLFK"WR

MX*SHZQLHVDPZLHV]QDMOHSLHM1LHVWHW\RF]\PE\üPR*HMX*VLSU]HNRQDáH7XUER

3DVFDO QLH MHVW QD W\OH LQWHOLJHQWQ\ E\ REURQLü VL SU]HG SUyE Z\NRQDQLD RSHUDFML

QLHOHJDOQHM]PDWHPDW\F]QHJRSXQNWXZLG]HQLDQSG]LHOHQLDSU]H]]HUR-HOLMHV]F]H

QLH PLDáH RND]ML SRWNQü VL R WHQ SUREOHP VSUyEXM ]D SRPRF QDV]HJR SURJUDPLNX
zn

DOH(üPLHMVFD]HURZHIXQNFML

:\UD*HQLD

1DV]HUyZQDQLHQLHPDSLHUZLDVWNyZU]HF]\ZLVW\FKZDUWRüZ\]QDF]QLNDZ\QRVL–8,
a

]DWHP MHJR SLHUZLDVWHN NZDGUDWRZ\ QLH GDMH VL REOLF]\ü 3RQLHZD* MHGQDN 7XUER

Pas

FDO R W\P QLH ZLH HIHNWHP SRGMWHM SUyE\ MHVW EáG Z\NRQDQLD Invalid floating

point operation — nielegalna operacja zmiennoprzecinkowa) i przerwanie realizacji
prog

UDPX &R SUDZGD *DGQD WR WUDJHGLD ER IXQNFMD L WDN QLH PD SLHUZLDVWNyZ DOH

SURJUDP PyJáE\ ]DFKRZ\ZDü VL SU]\]ZRLFLHM WM ]DPLDVW ÄSDGDü´ — Z\ZLHWODü

RGSRZLHGQLLQIRUPDFM

1LHPDSUREOHPXDOHWRMX*PR*HZQDVWSQ\PUR]G]LDOH

=DSDPLWDM

•

'RSU]HNV]WDáFDQLDLQIRUPDFMLZSURJUDPLHVáX*Z\UD*HQLD

•

:VNáDGZ\UD*HZFKRG]VWDáHL]PLHQQHUHSUH]HQWXMFHGDQHRUD]RSHUDWRU\
i

IXQNFMHUHSUH]HQWXMFHVSRVRE\SU]HNV]WDáFDQLDLQIRUPDFML

•

1DMZD*QLHMV]HJUXS\RSHUDWRUyZSDVFDORZ\FKWRRSHUDWRU\DU\WPHW\F]QHELWR-
we, logiczne oraz relacyjne (operatory porównania).

•

.RQVWUXXMF Z\UD*HQLD PXVLV] SDPLWDü R NROHMQRFL Z\NRQ\ZDQLD G]LDáD
czyli priorytetach operatorów.

•

'R]PLDQ\NROHMQRFLG]LDáDVáX*QDZLDV\

•

)XQNFMH UHSUH]HQWXM EDUG]LHM ]áR*RQ\ VSRVyE SU]HNV]WDáFDQLD LQIRUPDFML QL*
operatory.

•

'RQDGDZDQLDZDUWRFL]PLHQQ\PVáX*\RSHUDWRUSU]\SLVDQLD

•

3R OHZHM VWURQLH RSHUDWRUD SU]\SLVDQLD PXVL ]QDMGRZDü VL l-ZDUWRü 3R MHJR

SUDZHMVWURQLHPR*H]QDMGRZDüVLGRZROQHZ\UD*HQLH

48 Turbo

Pascal

—

programowanie

Instrukcja warunkowa

$E\XQLNQüEáGXZ\QLNDMFHJR]SUyE\SLHUZLDVWNRZDQLDOLF]E\XMHPQHMZ\SDdaáR-

E\XPLHFLüZQDV]\PSURJUDPLH]DVWU]H*HQLHZSRVWDFLÄMH*HOLZ\]QDF]QLNMHVWZLN-
szy od zera to wykonaj dalsze obliczenia, w przeciwnym przypadku wypisz odpowiedni

NRPXQLNDW´3U]HNáDGDMFWRQDM]\NDQJLHOVNLLQLHFRXRJyOQLDMFRWU]\PXMHP\VWUXN-

WXUinstrukcji warunkowej:

if warunek
then instrukcja-1
else instrukcja-2

: SRZ\*V]\P ]DSLVLH

warunek

MHVW QLF]\P LQQ\P MDN Z\UD*HQLHP GDMF\P Z

Z\QLNX ZDUWRü true lub false QD RJyá Z\NRU]\VWXMF\P ]QDQH &L MX* RSHUDWRU\

UHODF\MQH PyZLF SR OXG]NX MHVW WR ]Z\NáH SRUyZQDQLH

Instrukcje

RSLVXM

czynn

RFLNWyUHSRZLQQ\E\üZ\NRQDQHSRVSHáQLHQLXOXEQLHVSHáQLHQLXZDUXQNXSU]\

F]\PF]ü]DF]\QDMFDVLRGVáRZDNOXF]RZHJR

else

QLHMHVWRERZL]NRZDWMQLH

PXVLV]RNUHODüÄZDULDQWXDZDU\MQHJR´

,QVWUXNFMDZDUXQNRZDGRVWSQDSUDNW\F]QLHZND*G\PM]\NXSURJUDPRZDQLDVWDQRZL

SRGVWDZRZH QDU]G]LH XPR*OLZLDMFH SRGHMPRZDQLH GHF\]ML Z ]DOH*QRFL RG DNWX-

DOQ\FK ZDUXQNyZ F]\OL ZEXGRZ\ZDQLH Z SURJUDP ÄLQWHOLJHQFML´ SR]ZDODMFHM PX

]DFKRZDü VL RGSRZLHGQLR GR V\WXDFML 6SUyEXMP\ ZNRPSRQRZDü LQVWUXNFM ZDUun-

NRZZQDV]SRSU]HGQLSURJUDP

program Nowe_Rownanie_Kwadratowe;

^3URJUDPUR]ZL]XMHUyZQDQLHNZDGUDWRZHPHWRGZ\]QDF]QLNyZ`

^XZ]JOGQLDMFPR*OLZRüXMHPQHJR]QDNXZ\]QDF]QLND`

var

DEFUHDO^ZVSyáF]\QQLNL`

delta : real; { wyznacznik }
x1, x2 : real; { pierwiastki }

begin
writeln('Program rozwiazuje rownanie kwadratowe')
writeln('a*x^2 + b*x + c');

ZULWH3RGDMZVSROF]\QQLND^ZSURZDG(ZVSyáF]\QQLNL`

readln(a);

Instrukcja

warunkowa

write('Podaj wspolczynnik b: ');
readln(b);
write('Podaj wspolczynnik c: ');
readln(c);
delta := sqr(b) - 4*a*c; { oblicz wyznacznik }
  if delta >= 0 then { wyznacznik OK }
  begin { wykonujemy obliczenia}
x1 := (-b + sqrt(delta))/(2*a); { oblicz pierwiastki }
x2 := (-b - sqrt(delta))/(2*a);

ZULWHOQ3LHUZLDVWNL^Z\ZLHWOSLHUZLDVWNL`

writeln('x1 = ', x1:12:4);
writeln('x2 = ', x2:12:4);
end { tu

1,(0$UHGQLND`

else { wyznacznik ujemny }
writeln('Rownanie nie ma pierwiastkow rzeczywistych.');
readln;
end.

3RVWDüZDUXQNXMHVWZQDV]\PSU]\SDGNXRF]\ZLVWD

if delta >=0

F]\OL ÄMH*HOL Z\]QDF]QLN QLH MHVW PQLHMV]\ RG ]HUD´ =DXZD* *H MHOL ZDUXQHN MHVW

VSHáQLRQ\ QDOH*\ Z\NRQDü ZLFHM QL* MHGQ LQVWUXNFM D ]DWHP FDáD JUXSD LQVWUXNFML

]DMPXMF\FK VL REOLF]DQLHP L Z\ZLHWODQLHP SLHUZLDVWNyZ PXVL ]RVWDü RWRF]RQD

VáRZDPLNOXF]RZ\PL

begin

end

R]QDF]DMF\PLtzw. LQVWUXNFM]áR*RQ, czyli zestaw

LQVWUXNFMLZ\NRQ\ZDQ\FKMDNRMHGQDFDáRü=DSRPLQDQLHRW\PZ\PDJDQLXMHVWMHG-

Q\P]SRVSROLWV]\FKEáGyZSRSHáQLDQ\FKSU]H]SURJUDPLVWyZSDVFDORZ\FKQLHW\ONR

SRF]WNXMF\FK L PR*H SURZDG]Lü GR QLH]E\W SU]\MHPQ\FK EáGyZ Z\NRQDQLD 2WR

SU]\NáDG

if n <> 0 then
LiczbaProbek := n;
srednia := suma/LiczbaProbek;

3RZ\*V]\IUDJPHQWSRZLQLHQSU]\SLV\ZDü]PLHQQHM

LiczbaProbek

ZDUWRü

, a nas-

WSQLHREOLF]Dü

srednia

jako

suma

podzielona przez

LiczbaProbek

JZDUDQWXMF*H

w przypadku

UyZQHJR ]HUR G]LHOHQLH QLH EG]LH Z\NRQ\ZDQH 3RQLHZD* MHGQDN

SU]\SLVDQLDQLH]RVWDá\SRáF]RQHZLQVWUXNFM]áR*RQGOD

równego zeru pierwsze

SU]\SLVDQLH QLH Z\NRQD VL D ]DWHP ]PLHQQD

LiczbaProbek

EG]LH PLDáD ZDUWRü

QLHRNUHORQ 0R*H WR E\ü ]HUR ZyZF]DV Z\NRQDQLH SURJUDPX ]RVWDQLH SU]HUZDQH

OXEGRZROQDZDUWRüFRRF]\ZLFLHGRSURZDG]LGR]XSHáQLHEH]VHQVRZQHJRZ\QLNX

3UDZLGáRZDSRVWDüSRZ\*V]HMLQVWUXNFMLEG]LHZ\JOGDáDQDVWSXMFR

if n <> 0 then
begin
LiczbaProbek := n;
srednia := suma/LiczbaProbek;
end;

50 Turbo

Pascal

—

programowanie

:UyüP\GRQDV]HJRUyZQDQLD=DXZD**HZSHZQ\PV]F]HJyOQ\PSU]\SDGNX— gdy
wyznacznik jest równy zeru — ma ono tylko jeden pierwiastek: jest tak dla równania

którego podwójnym pierwiastkiem jest liczba –1. W tym przypadku musimy

XZ]JOGQLüWU]\PR*OLZRFLZ]DOH*QRFLRGZDUWRFLZ\]QDF]QLND

Wyznacznik Pierwiastki

ZLNV]\RG]HUD

− +

∆

− −

∆

równy zeru

−

mniejszy od zera

brak pierwiastków rzeczywistych

3RQLHZD*SRMHG\QF]DLQVWUXNFMDZDUXQNRZDSRWUDILREVáX*\üW\ONRGZLHZ]DMHPQLHVL

Z\NOXF]DMFH V\WXDFMH DE\ XZ]JOGQLü ZV]\VWNLH ZDULDQW\ QLH]EGQH MHVW ]DJQLH*-

G*HQLHGZyFKWDNLFKLQVWUXNFML6FKHPDWSRVWSRZDQLDSRND]DQ\MHVWSRQL*HMZUDPDFK

üZLF]HSURSRQXM&LVDPRG]LHOQHGRNRQDQLHRGSRZLHGQLFKPRG\ILNDFMLZSURJUDPLH

if delta < 0 then
{ brak pierwiastków rzeczywistych }
else
if delta = 0 then
{ oblicz i wypisz pojedynczy pierwiastek }
else

^RGQRVLVLGR

drugiego if-a }

{ oblicz i wypisz obydwa pierwiastki }

:SU]\SDGNXZLNV]HMOLF]E\ZDULDQWyZWDNLHÄSLWURZH´NRQVWUXNFMHVWDMVLQLHSR-

UF]QH WUXGQH Z LQWHUSUHWDFML L SRGDWQH QD EáG\ =DVWDQyZ VL QD SU]\NáDG MDN

Z\JOGDáDE\LQVWUXNFMDZDUXQNRZDZ\SLVXMFDQDHNUDQLHQD]ZGQLDW\JRGQLDGDQHJR

QXPHUHPQLHFKR]QDF]DSRQLHG]LDáHN0R*HWDN

if dzien = 1 then writeln('Poniedzialek')
else if dzien = 2 then writeln('Wtorek')
else if ...

&RSUDZGDX*\ZDQLHSHáQHMIRUP\LQVWUXNFMLZDUXQNRZHM

if-then-else

) nie jest tu

NRQLHF]QH L VáRZD

else

PR*QD XVXQü SDPLWDMF R UHGQLNDFK MHGQDN Z GDOV]\P

FLJXSRZ\*V]\WZyUEG]LHFRQDMPQLHMQLHHOHJDQFNL6NXWHF]Q\PVSRVREHPREVáXJL
wyborów wielowariantowych jest instrukcja wyboru

case

RGSRZLDGDMFD ] JUXEV]D

ÄVWHUFLH´]DJQLH*G*RQ\FKLQVWUXNFMLZDUXQNRZ\FK

case

SU]HáF]QLN

ZDUWRü

-1 : akcja-1;

ZDUWRü

-2 : akcja-2;

...
else akcja-

GRP\OQD

end;

Instrukcja

warunkowa

3RZ\*V]DVWUXNWXUDMHVWVZRLVWWDEOLFDNFMLRGSRZLDGDMF\FKSRV]F]HJyOQ\PZDUWR-
ciom zmiennej

SU]HáF]

nik

LGRVNRQDOHQDGDMHVLGRUHDOL]DFMLZLHORZDULDQWRZ\FK

Z\ERUyZNWyU\FKNODV\F]Q\PSU]\NáDGHPMHVWPHQX=DXZD**HRSUyF]DNFMLVNRMD-

U]RQ\FK]SRV]F]HJyOQ\PLZDUWRFLDPLSU]HáF]QLNDPDV]PR*OLZRüRNUHOHQLDDNFML

GRP\OQHMUHDOL]RZDQHMZSU]\SDGNXZ\VWSLHQLDZDUWRFLQLH]QDMGXMFHMVLZQDV]HM

ÄWDEOLF\´ 2GSRZLDGD ]D QL VáRZR NOXF]RZH

else

XPLHV]F]RQH QD NRFX LQVWUXNFML

3HZQ\P RJUDQLF]HQLHP QDU]XFDQ\P SU]H] LQVWUXNFM

case

jest wymaganie, by

zmienna

SU]HáF]QLN

E\áD W\SX SRU]GNRZHJR WDN ZLF QLH EG]LHP\ PRJOL

]DVWRVRZDü MHM Z QDV]\P SURJUDPLH Z NWyU\P Z\]QDF]QLN MHVW OLF]E U]HF]\ZLVW

8áDWZLHQLHP QDWRPLDVW MHVW PR*OLZRü ÄJUXSRZHJR´ GHILQLRZDQLD ZDUWRFL

RGSRZLDGDMF\FKSRV]czególnym akcjom, np.:

case liczba_interesantow of
0 : mozna_wyjsc_do_fryzjera;
1, 2 : niech_czekaja;
3..6 : trzeba_obsluzyc;
else wypisz('INWENTARYZACJA')
end;

:DUWRFLRGSRZLDGDMFHSRV]F]HJyOQ\PDNFMRPPRJE\üZ\OLF]DQHMDZQLHOXESRGD-

ZDQH Z SRVWDFL ]DNUHVyZ RGGR R LOH W\ONR WZRU] FLJá JUXS 0XVLV] UyZQLH*

SDPLWDü *H — Z RGUy*QLHQLX RG LQVWUXNFML ZDUXQNRZHM — SU]HG VáRZHP

else

PR*HV]SRVWDZLüUHGQLN

,WRE\E\áRQDW\OHFRRF]\ZLFLHQLH]QDF]\*HPR*HV]VSRF]üQDODXUDFK0LáRMHVW

PLHü SURJUDP SRWUDILF\ UR]ZL]Dü UyZQDQLH NZDGUDWRZH MHGQDN ]QDF]QLH SU]\MHP-

QLHMV]H E\áRE\ SRVLDGDQLH QDU]G]LD GR UR]ZL]\ZDQLD EDUG]LHM VNRPSOLNRZDQ\FK

UyZQD$OHF]\WRDE\QLH]DWUXGQH"%\QDMPQLHM

=DSDPLWDM

•

'R ZDUXQNRZHJR Z\NRQ\ZDQLD RSHUDFML VáX*\ Z SURJUDPDFK SDVFDORZ\FK
instrukcja warunkowa

if-then-else

•

8*\ZDMF LQVWUXNFML ZDUXQNRZ\FK PXVLV] SDPLWDü R ZáDFLZ\P VWRVRZDQLX

LQVWUXNFML]áR*RQHMRUD]REUDNXUHGQLNDSU]HGVáRZHP

else

•

$E\REVáX*\üZLFHMQL*GZDZDULDQW\PR*HV]X*\ü]DJQLH*G*RQ\FKLQVWUXNFML
warunkowych.

•

-HOLZ\ERUHPVWHUXMHZDUWRüW\SXSRU]GNRZHJROHSV]\PUR]ZL]DQLHPMHVW

X*\FLHLQVWUXNFMLZ\ERUX

case

52 Turbo

Pascal

—

programowanie

5R]ZL]XMHP\

dowolne równanie

3UREOHP UR]ZL]DQLD GRZROQHJR UyZQDQLD QLH QDOH*\ E\QDMPQLHM GR ]DGD W\SX
kamienia filozoficznego czy uniwersalnego rozpuszczalnika. Chocia

*GODSHZQ\FKNODV

UyZQDLVWQLHMGDZQRRSUDFRZDQHZ]RU\LPHWRG\VSRUDJUXSDUyZQDQLHOLQLRZ\FK

QLHGDMHVLUR]ZL]DüÄQDSDSLHU]H´ZVSRVyEGRNáDGQ\1LHR]QDF]DWRMHGQDN*HQLH

PR*QDLFKZRJyOHUR]ZL]DüNZHVWLLSU]\EOL*RQHJRUR]ZL]\ZDQLDUyZQDQLHOLQLR-

Z\FK SRZLFRQR ] QLH]á\P VNXWNLHP VSRU\ G]LDá PDWHPDW\NL ]QDQ\ MDNR metody
numeryczne

: QLQLHMV]\P UR]G]LDOH VSUyEXMHP\ ]DGHPRQVWURZDü MHGQ ] QDMSURVW-

V]\FK PHWRG UR]ZL]\ZDQLD UyZQD QLHOLQLRZ\FK — WDN ]ZDQ PHWRG ELVHNFML. Jest
ona na tyle

SURVWD*HSUDNW\F]QLHQLHZ\PDJD]QDMRPRFLVNRPSOLNRZDQHMPDWHPDW\NL

DMHG\QLHORJLF]QHJRP\OHQLDDMHGQRF]HQLHFDáNLHPVNXWHF]QD

a c

f(x)

Rysunek 9.

=DVDGDG]LDáDQLDPHWRG\ELVHNFML

=Dáy*P\ *H FKFHP\ ]QDOH(ü PLHMVFH ]HURZH IXQNFML f(x) SU]HGVWDZLRQHM SRZ\*HM

6]XNDP\ZLFWDNLHJRSXQNWXc na osi x, dla którego f(c) :\ELHUDMFQDRVLx dwa
punkty a i b

WDNLHE\ZDUWRFLf(a) i f(b)PLDá\SU]HFLZQH]QDNLPR*HP\]SHZQRFL

VWZLHUG]Lü*HIXQNFMDPDSRPLG]\a i b co najmniHMMHGQRPLHMVFH]HURZHJG\*PXVL

JG]LHSU]HFLüRx3RG]LHOP\SU]HG]LDáSRPLG]\a i bQDGZLHUyZQHF]FL:DU-

WRüIXQNFMLZQRZRX]\VNDQ\PSXQNFLHc

ma nadal znak przeciwny do f(a), a zatem

PLHMVFH ]HURZH OH*\ JG]LH SRPLG]\ a i c

3RG]LHOP\ QRZR X]\VNDQ\ SU]HG]LDá QD

SRáRZ\W\PUD]HPRND]XMHVL*HZDUWRüIXQNFMLZSXQNFLHc

ma znak przeciwny do

5R]ZL]XMHP\GRZROQHUyZQDQLH

f(c

)

D ZLF PLHMVFH ]HURZH OH*\ SRPLG]\ c

a c

:\NRQXMF NROHMQH SRG]LDá\

GRMG]LHP\ZNRFXGRSXQNWXQRZáDQLH=DXZD**H]ND*G\PNROHMQ\PSRG]LDáHP

]EOL*DP\VLGRPLHMVFD]HURZHJRFRUD]ZROQLHM]DND*G\PUD]HPSU]HG]LDáSRV]XNL-

ZDQLD ]DZ*DQ\ MHVW GZXNURWQLH WDN ZLF WHRUHW\F]QLH GRNáDGQH SRáR*HQLH PLHMVFD

]HURZHJR RGSRZLDGDMFH SU]HG]LDáRZL R ]HURZHM V]HURNRFL F]\OL SRMHG\QF]HPX

SXQNWRZL RVLJQLHP\ SR QLHVNRF]RQHM OLF]ELH SRG]LDáyZ &K\ED QLH PDV] ]DPLDUX

F]HNDüD*WDNGáXJR

5R]ZL]DQLHPWHJRSUREOHPXMHVWZáDFLZHVIRUPXáRZDQLHW]ZNU\WHULXP]DNRF]HQLD

REOLF]H lub kryterium stopu : QDV]\P SU]\SDGNX NROHMQH F\NOH SRG]LDáów (zwane
fachowo iteracjami

EG]LHP\ SURZDG]LOL WDN GáXJR D* EH]Z]JOGQD ZDUWRü IXQNFML

w punkcie c

]PDOHMHSRQL*HM]DGDQHJRSURJX

6SUyEXMP\]DSLVDüZEDUG]LHMIRUPDOQ\VSRVyESRMHG\QF]\SRG]LDá

SRF]WHN

Z\]QDF]SXQNWFZSRáRZLHRGOHJáRFLSRPLG]\DLE

MH*HOLIDPD]QDNUy*Q\RGIFWRSU]HQLHSXQNWEGRSXQNWXF

ZSU]HFLZQ\PSU]\SDGNXSU]HQLHSXQNWDGRSXQNWXF
koniec

$OHMDN]DEUDüVL]DZ\NRQ\ZDQLHNROHMQ\FKSRG]LDáyZ"2F]\ZLFLHQLHEG]LHV]PX-

VLDáZLHORNURWQLHZSLV\ZDüRdpowiednich instrukcji: zamiast tego wykorzystasz do ich
cyklicznego wykonywania

LQVWUXNFMSWOL.

6SRUyG WU]HFK GRVWSQ\FK Z 3DVFDOX VWUXNWXU SWOL GR UHDOL]DFML QDV]HJR ]DGDQLD

RGSRZLHGQLH V GZLH —

while

repeat

WU]HFL SWO

for

]DMPLHP\ VL QLHFR

Sy(QLHM. 1DOH*RQHGRJUXS\SWOLVWHURZDQ\FKZDUXQNLHPFRR]QDF]D*HZ\NRQXM

VLWDNGáXJRMDNGáXJRVSHáQLRQHEG]LHRGSRZLHGQLHNU\WHULXP

while

— powtarzaj,

GRSyNLOXEGRPRPHQWXNLHG\]RVWDQLHRQRVSHáQLRQH

repeat

—

SRZWDU]DMD*

HWU]HEDFK\EDGRGDZDü*HRZ\PNU\WHULXPEG]LHZáDQLHQDV]HNU\WHULXPVWRSX

]DNRF]LWHUDFMHMHOLZDUWRüEH]Z]JOGQDIFMHVWPQLHMV]DRG]DGDQHJRSURJX

.WyUHM LQVWUXNFML X*\ü" : ]DVDG]LH Z QDV]\P SU]\SDGNX MHVW WR RERMWQH ']LDáDQLH

SWOL

while

repeat

MHVW EDUG]R ]EOL*RQH ]D Uy*QLFD VSURZDG]D VL GR IDNWX *H

SLHUZV]HM]QLFKZDUXQHNSU]HUZDQLDSWOLVSUDZG]DQ\MHVWQDSRF]WNX

while warunek
do instrukcja

]DZGUXJLHM—QDNRFXSWOL

repeat instrukcja
until warunek

W konsekwencji instru

NFMH WZRU]FH ]DZDUWRü SWOL

repeat

PXV] Z\NRQDü VL FR

QDMPQLHMUD]]DZSU]\SDGNXSWOL

while

PRJQLHZ\NRQDüVLDQLUD]XMHOL

waru

nek

EG]LHRGUD]XVSHáQLRQ\3RQDGWRPXVLV]SDPLWDü*HVIRUPXáRZDQLHZDUXQNX

MHVWGODREXSWOLGRNáDGQLHSU]HFLZQHSWOD

while

Z\NRQXMHVLWDNGáXJRMDNGáXJR

54 Turbo

Pascal

—

programowanie

warunek

MHVWVSHáQLRQ\

repeat

—

WDNGáXJRMDNGáXJRMHVWQLHVSHáQLRQ\=DSDPLWDM

UyZQLH**HXPLHV]F]DMFNLONDLQVWUXNFMLZSWOL

while

PXVLV]SRáF]\üMHZLQVWUXNFM

]áR*RQ VáRZDPL

begin

end

, z

D Z SU]\SDGNX SWOL

repeat

NRQLHF]QRü WD QLH

Z\VWSXMHRJUDQLF]QLNDPLLQVWUXNFML]áR*RQHMVWXVáRZD

repeat

until

6SUyEXMP\]DSLVDüQDV]DOJRU\WP]Z\NRU]\VWDQLHPSWOL

repeat

%G]LHRQZ\JOGDá

PQLHMZLFHMWDN

SRF]WHN

ZSURZDG(ZDUWRFLNUDFyZSU]HG]LDáXLGRNáDGQRFL
powtarzaj

Z\]QDF]SXQNWFZSRáRZLHRGOHJáRFLSRPLG]\DLE

MH*HOLIDPD]QDNUy*Q\RGIFWRSU]HQLHSXQNWEGRSXQNWXF

ZSU]HFLZQ\PSU]\SDGNXSU]HQLHSXQNWDGRSXQNWXF

D*GRPRPHQWX, gdyZDUWRüEH]Z]JOGQDIFMHVWPQLHMV]DRG]DGDQHJRSURJX

wypisz znalezione miejsce zerowe
koniec

=Dáy*P\*HFKFHP\UR]ZL]DüUyZQDQLH

−

⋅

sin

cos

SRVLDGDMFHMDNQLHWUXGQRREOLF]\üQDNDUWFHSLHUZLDVWHNZSXQNFLHx 7áXPDF]F

SRZ\*V]\VFKHPDWQDDQJLHOVNLL3DVFDORWU]\PDP\QDVWSXMF\SURJUDP

program Bisekcja;

^3URJUDPUR]ZL]XMHUyZQDQLDQLHOLQLRZHPHWRGELVHNFML`

var

DEFUHDO^JUDQLFHSU]HG]LDáXLSXQNWSRG]LDáX`

HSVUHDO^GRNáDGQRü`

begin
writeln('Program znajduje miejsce zerowe funkcji')
writeln('w przedziale [a;b]');

ZULWH3RGDMZDUWRVFD^ZSURZDG(JUDQLFHSU]HG]LDáX`

readln(a);
write('Podaj wartosc b: ');
readln(b);
write('Podaj dokladnosc: ');
readln(eps);
repeat

F DE^SRG]LHOSU]HG]LDáQDSyá`

  if (1 - exp(sin(a)*cos(a)))*(1 - exp(sin(c)*cos(c))) < 0
  then
b := c { funkcja ma przeciwne znaki w a i c }
  else
a := c; { funkcja ma przeciwne znaki w b i c }
writeln(c);
  until abs(1 - exp(sin(c)*cos(c))) < eps;

^EDGDP\ZDUWRüEH]Z]JOGQ`

writeln('Miejsce zerowe: c = ',c:12:8);
readln;

5R]ZL]XMHP\GRZROQHUyZQDQLH

end.

1DV]SURJUDPGRüGRNáDGQLHRGSRZLDGDVFKHPDWRZLSRGDQHPXSRZ\*HMLZ]DVDG]LH

QLH Z\PDJD GRGDWNRZ\FK NRPHQWDU]\ PLPRFKRGHP SR]QDáH NLOND QRZ\FK IXQNFML
arytmetycznych —

exp

sin

cos

abs

:DUWRMHGQDN]ZUyFLüXZDJQDNU\WHULXP

stopu:

until abs(1 - exp(sin(c)*cos(c))) < eps;

-DN ZVSRPQLHOLP\ ]DSLV WHQ SR]ZDOD XQLNQü QLHVNRF]HQLH GáXJLHJR GRFKRG]HQLD

NROHMQ\FK SRG]LDáyZ GR SXQNWX VWDQRZLFHJR ZáDFLZH UR]ZL]DQLH $OH F]\ W\ONR"

6SUyEXMZ\NRQDüSRQL*V]\SURJUDP

program Dodawanie;

^LOXVWUDFMDNXPXODFMLEáGyZ]DRNUJOH`

{ zmiennoprzecinkowych }

var x : real;

begin
x := 0.0
repeat
x := x + 0.1;

^SRGRGDZDQLDFKSRZLQQLP\`

writeln(x:16:12);
until

[ ^RWU]\PDüGRNáDGQLH`

end.

-DNáDWZRVSUDZG]LüQDV]DSWODZFDOHQLHPD]DPLDUX]DNRF]\üG]LDáDQLDSRRVLJ-

QLFLXZDUWRFL&]\*E\ZLFG]LHVLFLRNURWQHGRGDQLHGRQLHGDZDáR"

,VWRWQLH OLF]E\ U]HF]\ZLVWH UHSUH]HQWRZDQH V Z NRPSXWHU]H ]H VNRF]RQ GRNáDG-

QRFLLRSHUDFMHQDZLNV]RFL]QLFKREDUF]RQHVSHZQ\PEáGHPNWyU\NXPXOXMH

VL Z SU]\SDGNX Z\NRQ\ZDQLD ZLNV]HM LORFL REOLF]H 'ODWHJR WH* SRUyZQDQLD

]PLHQQRSU]HFLQNRZH Z\NRU]\VWXMFH RSHUDWRU

VSUDZG]DMF\ GRNáDGQ UyZQRü

]Z\NOHRND]XMVLQLHVNXWHF]QH5R]ZL]DQLHPMHVWX*\FLHRSHUDWRUyZ

, czyli

QLHUyZQRFLQLHRVWU\FK3RSUDZQHNU\WHULXP]DNRF]HQLDSWOLPLDáRE\XQDVSRVWDü

until x >= 10.0;

LHOXSRF]WNXMF\FKSURJUDPLVWyZ]DSRPLQDRQLHGRVNRQDáRFLNRPSXWHUDSUyEXMF

SU]HáR*\üÄLGHDOQ\´]DSLVPDWHPDW\F]Q\ZSURVWQDM]\NSURJUDPRZDQLD(IHNW\PRJ

E\üQLH]E\WSU]\MHPQH]ZáDV]F]DZSU]\SDGNXZ\NRU]\VWDQLDWDNLFK]DSLVyZZSW-

ODFKGRGDWNRZRZ\VWSXMHZyZF]DVNXPXODFMDEáGyZLLQVWUXNFMDFKZDUXQNRZ\FK

3URJUDPXMFRSHUDFMHQDOLF]EDFKU]HF]\ZLVW\FKQDOH*\]DZV]HSDPLWDüRLFK

QLHGRNáDGQHMUHSUH]HQWDFML

2PyZLRQHZ\*HMSWOH

while

repeat

QDOH*GRJUXS\SWOLVWHURZDQ\FKZDUXQNLHP

FR R]QDF]D *H OLF]ED SU]HELHJyZ SWOL QLH MHVW ] JyU\ RNUHORQD 7\SRZ\P ]DVWRVR-

ZDQLHPSWOL

while

repeat

MHVWZ\NRQ\ZDQLHREOLF]HOXELQQ\FKG]LDáDD*GR

VSHáQLHQLDRNUHORQHJRNU\WHULXPZSURZDG]DQLHGDQ\FK]NODZLDWXU\OXESOLNXLZV]HO-

56 Turbo

Pascal

—

programowanie

NLH LQQH RSHUDFMH Z NWyU\FK QLH MHVWHP\ Z VWDQLH ZF]HQLHM XVWDOLü MDN ZLHOH F\NOL

WU]HED EG]LH Z\NRQDü &]DVHP MHGQDN RND]XMH VL *H PXVLP\ ]UHDOL]RZDü FLOH

RNUHORQOLF]ERSHUDFMLQSZ\SLVDüQDHNUDQLHZV]\VWNLHOLWHU\RGÄ$´GRÄ=´ZUD]
z ich kodami

$6&,,2F]\ZLFLHLWRPR*QD]URELü]DSRPRFSWOL

while

lub

repeat

MHGQDN]QDF]QLHSRUF]QLHMV]DRND]XMHVLWXSWOD

for

, sterowana nie warunkiem, lecz

licznikiem. A oto i sam program:

program ASCII;
{ wyprowadza znaki ASCII od 'A' do 'Z' i ich kody }

var c : char; { wypisywany znak }

begin
for c := 'A' to 'Z' do
write(c:4, ord(c):4)
end.

-DNZLGDüVNáDGQLDSWOL

for

MHVWQDVWSXMFD

for

OLF]QLN SRF]WHN

to koniec do

instrukcja

FR WáXPDF]\ VL ÄQD QDV]H´ MDNR ÄGOD

licznika

SU]HELHJDMFHJR ZDUWRFL RG

SRF]WHN

koniec

wykonuj

LQVWUXNFM

´ 3WO ÄZ Gyá´ ZDUWRü NRFRZD

licznika

MHVWPQLHMV]DRGSRF]WNRZHM]DSLVXMHVLQLHFRLQDF]HM

for

OLF]QLN SRF]WHN

downto koniec do

instrukcja

:DUWR R W\P SDPLWDü JG\* X*\FLH GR WHJR FHOX SRSU]HGQLHM SRVWDFL VSRZRGXMH *H

SWODQLHZ\NRQDVLDQLUD]X-HOLZUHV]FLHZDUWRüSRF]WNRZD

licznika

jest równa

NRFRZHMSWODZ\NRQDVLGRNáDGQLHMHGHQUD]FRPDQLHZLHONLVHQVQLH]DOH*QLHRG

WHJRNWyUHM]SRZ\*V]\FKIRUPX*\MHP\

3URJUDPXMFSWO

for

PXVLV]GRNáDGQLHZLHG]LHüLOHUD]\EG]LHVLRQDZ\NRQ\ZDáD

F]\OL]QDüZDUWRüSRF]WNRZLNRFRZ

licznika

1LHMHVWRF]\ZLFLHSRZLHG]LDQH

*HZDUWRFLWHPXVLV]SRGDüZSRVWDFLVWDá\FKUyZQLHGREU]HPR*HV]X*\üGRWHJRFHOX

]PLHQQ\FKOXEZ\UD*HE\OHW\ONRGDZDá\RQHZZ\QLNXZDUWRFLW\SXSRU]GNRZHJR
np:

for i := 1 to MaxIndex div 2 do { ... }

Sam

licznik

UyZQLH* PXVL E\ü ]PLHQQ W\SX SRU]GNRZHJR ]Z\NOH

integer

lub

char

LZWUDNFLHZ\NRQ\ZDQLDSWOL]PLHQLDVL]NURNLHPRGZDUWRFL

SRF]WHN

koniec

ZáF]QLH=DSURJUDPRZDQLHZ3DVFDOXSWOL]NURNLHPUy*Q\PRGZV]F]H-

JyOQRFLQLHFDáNRZLW\PMHVWQLHFREDUG]LHMVNRPSOLNRZDQH]Z\NOHOHSLHMZW\PFHOX

X*\üSWOL

while

lub

repeat

FKRFLD*PR*QDWR]URELüWDN

for i := 1 to 20 do
begin
writeln(i);
Inc(i) { dodaj 1 do licznika }
end;

5R]ZL]XMHP\GRZROQHUyZQDQLH

3RZ\*V]DNRQVWUXNFMDZ\SLV]HQDHNUDQLHZV]\VWNLHOLF]E\QLHSDU]\VWH]DZDUWHPLG]\

D6]WXF]NDNWyUHMWXX*\OLP\SROHJDQD]PLDQLHOLF]QLNDZWUDNFLHZ\NRQ\ZDQLD

SWOLQRUPDOQLH]DMPXMHVLW\PVDPDSWODDP\QLHSRZLQQLP\VLGRWHJRZWUFDü
i —

FKRFLD* OHJDOQD L SRSUDZQD — MHVW QLH]E\W EH]SLHF]QD 6SUyEXM QS ]PLHQLü

ZDUWRü NRFRZ OLF]QLND QD SURJUDP ÄSU]HVNRF]\´ ]DNRF]HQLH SWOL OXE

LQVWUXNFM

Inc(i)

Dec(i)

]PQLHMV]HQLHOLF]QLNDR]DPLDVW]ZLNV]HQLD—SWOD

Ä]DSWOLVL´QDZDUWRFL

3URJUDPXMFSWO

for

QDOH*\VWDQRZF]RXQLNDüMDZQHJRPRG\ILNRZDQLD

OLF]QLNDZHZQWU]SWOL$E\]DSURJUDPRZDüSWO]NURNLHPUy*Q\PRG
lepiej

X*\üNRQVWUXNFML

while

lub

repeat

:]PLDQNRZDQH Z\*HM LQVWUXNFMH

Inc

Dec

SR]ZDODM RGSRZLHGQLR QD ]ZLNV]HQLH

(in

NUHPHQWDFM OXE ]PQLHMV]HQLH GHNUHPHQWDFM ZDUWRFL DUJXPHQWX W\SX

SRU]GNRZHJR R ]DGDQ ZDUWRü UyZQLH* W\SX SRU]GNRZHJR L RGSRZLDGDM

LQVWUXNFMRPGRGDQLDOXERGMFLDZDUWRFLQS

Dec(k, 30); { to samo, co k := k - 30; }

1DW\P]DNRF]\P\UR]ZD*DQLDQDWHPDWSWOLZ3DVFDOXLNLONXGUREQ\FKGRGDWNyZ

FKRüGR]DVWRVRZDSWOLEG]LHP\ZUDFDüMHV]F]HZLHORNURWQLH:NROHMQ\PUR]G]LDOH

]DMPLHP\VLSHZQQLHGRJRGQRFLSURJUDPX

Bisekcja

SROHJDMFQDNáRSRWOLZ\P

]DGDZDQLXSRVWDFLUR]ZL]\ZDQHJRUyZQDQLD=DXZD**HQDV]DIXQNFMDQLHOLQLRZD

f x

( )

sin

cos

= −

⋅

MHVWZSURJUDPLHZ\NRU]\VW\ZDQDGZDUD]\UD]SRGF]DVZáDFLZHMLWHUDFMLGUXJLUD]
w

NU\WHULXP VWRSX -HVW WR QLHZ\JRGQH L QLHHOHJDQFNLH JG\* FKFF ]QDOH(ü PLHMVFH

]HURZH LQQHM IXQNFML PXVLP\ ZSLV\ZDü M GZD UD]\ -HGQRF]HQLH VDP DOJRU\WP

SR]ZDODQDP]QDOH(üPLHMVFH]HURZHGRZROQHMIXQNFMLf(x)&]\]DWHPQLHGDáRE\VL

]DPNQü QDV]HM IXQNFML Z MDNLH SXGHáNR GR NWyUHJR ZNáDGDOLE\P\ W\ONR ZDUWRü

DUJXPHQWXLRGELHUDOLZ\QLN"2F]\ZLFLH*HWDN

:UDPDFKüZLF]HSUDNW\F]Q\FKSURSRQXM&LQDVWSXMFH]DGDQLD

•

zmodyfikuj program Bisekcja

WDNE\Z\NRU]\VW\ZDáSWO

while

;

•

QDSLV]SURJUDPZ\SLVXMF\ZDUWRFLIXQNFML f x

( )

sin

cos

= −

⋅

w przedziale od

x = 0 do x = 360 stopni (2

]NURNLHPVWRSQL3DPLWDM*HDUJXPHQW\IXQNFML

WU\JRQRPHWU\F]Q\FKSRGDZDQHVZUDGLDQDFK6SUyEXMZ\NRU]\VWDüZV]\VWNLH

SR]QDQHSWOH

=DSDPLWDM

•

Do cyklicznego (iteracyjn

HJRZ\NRQ\ZDQLDLQVWUXNFMLVáX*Z3DVFDOXSWOH

•

,QVWUXNFMH SWOL PRJ E\ü VWHURZDQH ZDUXQNLHP

while-do

repeat-until

)

lub licznikiem (

for-to/downto

58 Turbo

Pascal

—

programowanie

•

3WOH

while

repeat

X*\ZDQHVZyZF]DVJG\QLH]QDP\]JyU\OLF]E\SU]H-

ELHJyZSWOLPR*HP\QDWRPLDVWRNUHOLüZDUXQHNMHM]DNRF]HQLD

•

3URJUDPXMFNU\WHULXP]DNRF]HQLDSWOL

while

repeat

LQLHW\ONRQDOH*\

SDPLWDüRQLHGRNáDGQRFLUHSUH]HQWDFMLOLF]EU]HF]\ZLVW\FKLNXPXODFMLEáGyZ

REOLF]H

•

3WOD

for

Z\NRU]\VW\ZDQD MHVW Z V\WXDFMDFK JG\ PR*HP\ GRNáDGQLH RNUHOLü

OLF]ESU]HELHJyZ

•

/LF]QLNSWOL

for

MHVW]DZV]HW\SXSRU]GNRZHJRL]PLHQLDVL]NURNLHP 1.

•

0RG\ILNDFMDOLF]QLNDZHZQWU]SWOL

for

MHVWGRSXV]F]DOQDDOHPR*HSURZDG]Lü

GRWUXGQ\FKGRZ\NU\FLDEáGyZLQDOH*\MHMXQLNDü

•

'R LQNUHPHQWDFML OXE GHNUHPHQWDFML ]PLHQQ\FK W\SX SRU]GNRZHJR PR*QD

Z\NRU]\VWDüLQVWUXNFMH

Inc

Dec

Funkcje i procedury

-DN Z *\FLX WDN L Z SURJUDPRZDQLX RERZL]XMH ]DVDGD *H QLH QDOH*\ URELü WHJR

VDPHJR ZLFHM QL* UD] -HOL QS PXVLV] NLONDNURWQLH REOLF]\ü Z SURJUDPLH ZDUWRü

MDNLHJRVNRPSOLNRZDQHJRZ\UD*HQLDWRRF]\ZLFLHPR*HV]WR]URELüSU]HSLVXMFOXE

SRZLHODMF]DSRPRFRSHUDFMLEORNRZ\FKRGSRZLHGQLHIUDJPHQW\SURJUDPXDOHWUXG-

QRSRZLHG]LHüE\E\áRWRQDMOHSV]HUR]ZL]DQLH3RSLHUZV]HZ\PDJDWRWURFKSUDF\

3RGUXJLHSURJUDPURELVLGáX*V]\PQLHMHODVW\F]Q\LPQLHMF]\WHOQ\RHOHJDQFMLQLH

PyZLF 3R WU]HFLH MDNDNROZLHN SRSUDZND Z WUHFL Z\UD*HQLD PXVL ]RVWDü ZSURZD-

G]RQD GR ZV]\VWNLFK SRZLHORQ\FK IUDJPHQWyZ MHOL ]DSRPQLV] FKRüE\ R MHGQ\m,

Z\QLNLPRJE\üRSáDNDQH

3RZ\*V]H DUJXPHQW\ Z Z\VWDUF]DMF\P VWRSQLX X]DVDGQLDM SRWU]HE ZSURZDG]HQLD

UR]ZL]DQLDXPR*OLZLDMFHJRÄXNU\FLH´Z\EUDQHMRSHUDFMLOXEJUXS\RSHUDFMLZSR-

MHPQLNX GR NWyUHJR GRVWDUF]DOLE\P\ GDQH L RGELHUDOL Z\QLN EH] SU]HMPRZDQLD VL

VSRVREHPSU]HWZDU]DQLDLQIRUPDFMLZHZQWU]5R]ZL]DQLHPWDNLPVfunkcje i proce-
dury

2E\GZD SRMFLD V &L MX* ]QDQH — ZLHORNURWQLH Z\NRU]\VW\ZDáH SURFHGXU\

i funkcje biblioteczne Pascala (np.

writeln

czy

exp

EH]]DVWDQDZLDQLDVLQDG]DVDG

LFK G]LDáDQLD 2ND]XMH VL MHGQDN *H Z QLHVNRPSOLNRZDQ\ VSRVyE PR*HV] UyZQLH*

WZRU]\üZáDVQHSURFHGXU\LIXQNFMHFRSR]ZROL&LXQLNQüSURZL]RUNLMDN]DSUH]HQ-

WRZDOLP\ZSRSU]HGQLPUR]G]LDOH

&]\PMHVWIXQNFMD"=SXQNWXZLG]HQLDSURJUDPXNWyU\MZ\NRU]\VWXMHMHVWWRURG]DM

ÄF]DUQHM VNU]\QNL´ SU]HWZDU]DMFHM ZáR*RQH GR QLHM LQIRUPDFMH L ]ZUDFDMFHM RGSR-
wiedni wynik. Z punktu widzenia programisty natomiast funkcja jest swoistym „mini-
programem” —

]HVWDZHP]DPNQLW\FKZORJLF]QFDáRüLQVWUXNFML,QVWUXNFMHWHPRJ

]DMPRZDü VL Z\NRQ\ZDQLHP GRZROQ\FK RSHUDFML FKRFLD* QD RJyá LFK FHOHP MHVW

SU]HNV]WDáFHQLH ZSURZDG]RQ\FK GR IXQNFML LQIRUPDFML W]Z parametrów GR *GDQHM

SRVWDFL ]ZUDFDQHM QDVWSQLH SRSU]H] QD]Z IXQNFML 3URFHGXUD Uy*QL VL RG IXQNFML

MHG\QLHVSRVREHP]ZUDFDQLDZ\QLNXRF]\PSRZLHP\]DFKZLO

&RQDOH*\]URELü*HE\Z\NRU]\VWDüZSURJUDPLHIXQNFMOXESURFHGXU"3RSLHUZV]H

WU]HEDM]GHILQLRZDüDQDVWSQLHZ\ZRáDü=DMPLMP\VLQDSRF]WHNGHILQLFMNWyUD
polega na:

•

RNUHOHQLX VSRVREX NRQWDNWRZDQLD VL MHM ] RWRF]HQLHP XVWDOHQLX QD]Z\
zestawu parametrów i typu zwracanego wyniku), oraz

60 Turbo

Pascal

—

programowanie

•

RNUHOHQLXMHM]DZDUWRFLF]\OL]HVWDZXWZRU]F\FKMLQVWUXNFMLLSRPRFQLF]\FK

RELHNWyZORNDOQ\FKRNWyU\FKSy(QLHM

$RWRVNáDGQLDGHILQLFMLIXQNFML

function nazwa-funkcji(lista-parametrów):typ-wyniku;
deklaracje-i-definicje-obiektów lokalnych
begin
instrukcje-

UHDOL]XMFH

WUHüIXQNFML

end;

procedure nazwa-procedury(lista-parametrów);
deklaracje-i-definicje-obiektów-lokalnych
begin
instrukcje-

UHDOL]XMFH

WUHü

-procedury

end;

'HILQLFMD UR]SRF]\QD VL WDN ]ZDQ\P QDJáyZNLHP V\JQDOL]RZDQ\P VáRZHP NOXF]R-
wym

function

lub

procedure

SR NWyU\P QDVWSXMH XPLHV]F]RQD Z QDZLDVDFK

RNUJá\FK OLVWD parametrów (argumentów) formalnych 3DUDPHWU\ WH V\PEROL]XM

ZDUWRFLNWyUH]RVWDQSU]HND]DQHGRIXQNFMLLSU]HWZRU]RQH]DVDPDOLVWDPDSRVWDü

lista-nazw : typ; lista-nazw : typ; ...

F]\OL ]DZLHUD ]HVWDZ\ QD]Z SDUDPHWUyZ WHJR VDPHJR W\SX UR]G]LHORQH UHGQLNDPL
(w

REUELH]HVWDZXQD]Z\SDUDPHWUyZUR]G]LHORQHVSU]HFLQNDPL:DUWR]DXZD*\ü

*HOLVWDSDUDPHWUyZQLHMHVWRERZL]NRZ\PHOHPHQWHPGHILQLFMLWDNZLFLVWQLHMHPR*-

OLZRü]GHILQLRZDQLDIXQNFMLEH]SDUDPHWURZHMQLHSRELHUDMFHMLQIRUPDFML]RWRF]HQLD

2VWDWQLP HOHPHQWHP QDJáyZND MHVW RNUHOHQLH W\SX ]ZUDFDQHJR Z\QLNX Z\PDJDQH

Z\áF]QLHGODIXQNFML

6DPD WUHü IXQNFML ]GHILQLRZDQD MHVW SRPLG]\ VáRZDPL NOXF]RZ\PL

begin

end

PR*H E\ü SRSU]HG]RQD GHNODUDFMDPL L GHILQLFMDPL WDN ]ZDQ\FK RELHNWyZ ORNDOQ\FK

Z\NRU]\VW\ZDQ\FKSU]H]IXQNFMGRX*\WNXZHZQWU]QHJR2ELHNWDPLORNDOQ\PL]DM-

PLHP\ VL V]HU]HM Z GDOV]HM F]FL NVL*NL 6DPH LQVWUXNFMH VNáDGDMFH VL QD WUHü

GHILQLFMLIXQNFMLQLHUy*QLVLQLF]\PRGX*\ZDQ\FKZÄ]Z\Ná\P´SURJUDPLH]Z\MW-

NLHPWHJR*HZSU]\SDGNXIXQNFMLQDOH*\XPLHFLüZGHILQLFMLLQVWUXNFMSU]\SLVDQLD

nazwa-

IXQNFML ZDUWRü

-wyniku

XPR*OLZLDMFSU]HND]DQLHREOLF]RQHJRZ\QLNXÄQD]HZQWU]´&RFLHNDZHREHFQRü

WHMLQVWUXNFMLZWUHFLIXQNFMLQLHMHVWVSUDZG]DQDSU]H]NRPSLODWRUMDNPDWRPLHMVFH
np. dla kompilat

RUyZM]\ND&WRWH*]DSRPLQDOVNLPSURJUDPLVWRPPR*HVLSU]\WUDILü

]GHILQLRZDQLHIXQNFMLNRPSOHWQLHQLHSRWUDILFHMVNRPXQLNRZDüVL]RWRF]HQLHPQLH

SRELHUDMFHM *DGQ\FK SDUDPHWUyZ L QLH ]ZUDFDMFHM Z\QLNX D ZLF SUDNW\F]QLH EH]-

X*\WHF]QHM:DUWR]GDZDüVRELHVSUDZ*HZ\ZRáDQLHIXQNFMLSR]EDZLRQHMLQVWUXNFML

]ZUyFHQLDZ\QLNXGDZUH]XOWDFLHZDUWRüQLHRNUHORQSU]\SDGNRZFRUDF]HMQLH

PR*HE\üX]QDQH]DHIHNWSR]\W\ZQ\

'ODXSURV]F]HQLDZGDOV]\PFLJXQDV]\FKUR]ZD*DEG]LHP\X*\ZDOLVáRZDÄIXQNFMD´

]DUyZQR QD RNUHOHQLH IXQNFML MDN L SURFHGXU\ (ZHQWXDOQH Uy*QLFH EG Z\UD(nie
zaznaczane.

Funkcje i procedury

-DN ZLGDü ] SRZ\*V]\FK ]DSLVyZ GHILQLFMD IXQNFML OXE SURFHGXU\ SU]\SRPLQD PDá\
program. Definicje wszystkich funkcji i procedur wykorzystywanych w programie

PXV] E\ü XPLHV]F]RQH SU]HG PLHMVFHP LFK Z\ZRáDQLD 7R RVWDWQLH PR*H QDVWSLü
w

F]FL RSHUDF\MQHM SURJUDPX D ]DWHP GHILQLFMH PXV] SRSU]HG]Dü UR]SRF]\QDMFH

ZáDFLZ\SURJUDPVáRZRbeginOXEZWUHFLLQQHMIXQNFMLOXESURFHGXU\FRZ\PXV]D

RGSRZLHGQLH XáR*HQLH GHILQLFML Z]JOGHP VLHELH

). Struktura programu wykorzys

WXM-

FHJRIXQNFMHLSURFHGXU\SRZLQQDZLFZ\JOGDüQDVWSXMFR

QDJáyZHN

-programu

deklaracje-i-definicje-obiektów-globalnych
definicje-funkcji-i-procedur
begin

F]ü

-operacyjna-programu

end.

8PLHV]F]DQLHGHNODUDFMLLGHILQLFMLRELHNWyZJOREDOQ\FKRNWyU\FKUyZQLH*SRZLHP\

Sy(QLHMSU]HGGHILQLFMDPLIXQNFMLQLHMHVWFRSUDZGDRERZL]NRZHFK\ED*HRELHNW\

WHVZ\NRU]\VW\ZDQHZIXQNFMDFKVWDQRZLMHGQDNHOHPHQWGREUHMSUDNW\NLSURJramis-

W\F]QHM 1DWRPLDVW MHGQ\P ] SRVSROLW\FK EáGyZ SRSHáQLDQ\FK SU]H] SRF]WNXMF\FK

SURJUDPLVWyZMHVWSUyEDXPLHV]F]DQLDGHILQLFMLIXQNFMLLSURFHGXUZF]FLRSHUDF\MQHM
progra

PXFRMHVWRF]\ZLFLHQLHOHJDOQH

6DPR ]GHILQLRZDQLH IXQNFML QLF QDP MHV]F]H QLH GDMH MHJR HIHNWHP MHVW Z\áF]QLH
utworzenie odpowiedniego fragmentu kodu wynikowego). Dopiero

Z\ZRáDQLH funkcji

SRZRGXMH Z\NRQDQLH VNáDGDMF\FK VL QD MHM WUHü LQVWUXNFMLLU]HF]\ZLVWHSU]HNV]WDá-

FHQLHLQIRUPDFMLSRGDQHMZSRVWDFLSDUDPHWUyZ$E\Z\ZRáDüSURFHGXUOXEIXQNFM

Z\VWDUF]\XPLHFLüZSURJUDPLHMHMQD]ZZUD]]OLVWparametrów aktualnych, czyli

Z\UD*H]DZLHUDMF\FKLQIRUPDFMNWyUDPDE\üSU]HWZRU]RQD=DZDUWRüOLVW\SDUD-

PHWUyZ DNWXDOQ\FK PXVL RGSRZLDGDü OLFLH SRGDQHM Z GHILQLFML IXQNFML : V]F]HJyO-

QRFLMHOLZGHILQLFMLSRPLQLWROLVWSDUDPHWUyZQLHSRGDMHVLLFKSRGF]DVZ\ZR-

áDQLDPDP\ZyZF]DVGRF]\QLHQLD]IXQNFMOXESURFHGXUEH]SDUDPHWURZ

:\ZRáDQLHSURFHGXU\PDSRVWDü

nazwa-procedury(lista-parametrów-aktualnych);

]DZSU]\SDGNXIXQNFMLNWyUD]ZUDFDREOLF]RQZDUWRüSRSU]H]VZRMQD]ZPXVLV]

GRGDWNRZR]DGEDüRXPLHV]F]HQLHJG]LH]ZUyFRQHJRZ\QLNXQSWDN

zmienna := nazwa-funkcji(lista-parametrów-aktualnych);

)XQNFM PR*HV] UyZQLH* Z\NRU]\VWDü MDNR HOHPHQW Z\UD*HQLD OXE LQVWUXNFML QS

writeln

RJyOQLH PR*HV] M ]DVWRVRZDü ZV]G]LH WDP JG]LH PR*OLZH MHVW X*\FLH

Z\UD*HQLD

2JUDQLF]HQLHWRPR*QDREHMüZ\NRU]\VWXMFW]ZGHNODUDFMH]DSRZLDGDMFHUR]SRF]\-

QDQHVáRZHPNOXF]RZ\P

forward

3DPLWDM *H LGHQW\ILNDWRU IXQNFML X*\W\ Z SURJUDPLH QLH MHVW l-ZDUWRFL D ZLF QLH

PR*HV] X*\ZDü IXQNFML WDN VDPR MDN ]PLHQQHM — QLH PR*HV] QS SU]\SLV\ZDü MHM

ZDUWRFLPR*OLZHWRMHVWZ\áF]QLHZREUELHGHILQLFMLIXQNFMLLPDZyZF]DVQLHFRLQQH
znaczenie).

62 Turbo

Pascal

—

programowanie

3RF]ZV]\RGZHUVML7XUER3DVFDOXPR*OLZLD&L]LJQRURZDQLHZ\QLNX

]ZUDFDQHJRSU]H]IXQNFMF]\OLZ\NRU]\VWDQLHMHMWDNVDPRMDNSURFHGXU\
Jest

WRPR*OLZHSRZáF]HQLXRSFMLNRPSLODWRUDExtended SyntaxOXEX*\FLX

RGSRZLDGDMFHMMHMG\UHNW\Z\

{$X+}

8II3RWHMVROLGQHMLQX*FHMGDZFHWHRULLF]DVQDQLHFRSUDNW\NL1DSRF]WHNVSUy-

EXMP\]DUDG]LüSUREOHPRZLSU]HGVWDZLRQHPXSRGNRQLHFSRSU]HGQLHJRUR]G]LDáX2WR
poprawiona wersja programu

Bisekcja

Z\NRU]\VWXMFDIXQNFM

program Bisekcja;

^3URJUDPUR]ZL]XMHUyZQDQLDQLHOLQLRZHPHWRGELVHNFML`

var

DEFUHDO^JUDQLFHSU]HG]LDáXLSXQNWSRG]LDáX`

HSVUHDO^GRNáDGQRü`

function f(x:real):real; { badana funkcja }

begin
f := 1 -

H[SVLQ[FRV[^WUHüIXQNFML`

end;

begin
writeln('Program znajduje miejsce zerowe funkcji')
writeln('w przedziale [a; b]');

ZULWH3RGDMZDUWRVFD^ZSURZDG(JUDQLFHSU]HG]LDOX`

readln(a);
write('Podaj wartosc b: ');
readln(b);
write('Podaj dokladnosc: ');
readln(eps);
repeat

F DE^SRG]LHOSU]HG]LDáQDSyá`

if (f(a)*f(c)) < 0 then

^Z\JOGDáDGQLHMSUDZGD"`

b := c { funkcja ma przeciwne znaki w a i c }
else
a := c; { funkcja ma przeciwne znaki w b i c }
writeln(c);
until

DEVIFHSV^EDGDP\ZDUWRüEH]Z]JOGQ`

writeln('Miejsce zerowe: c = ',c:12:8);
readln;
end.

&]\P Uy*QL VL QDV] SURJUDP RG ZHUVML SRSU]HGQLHM" 3R SLHUZV]H GHILQLFMD EDGDQHM

IXQNFML]RVWDáDZ\RGUEQLRQDMDNRRGG]LHOQ\IUDJPHQWNWyU\áDWZR]QDOH(ü]LQWHUSUH-

WRZDü L SRSUDZLü 3R GUXJLH WUHü VDPHJR SURJUDPX MHVW F]\WHOQLHMV]D SURJUDP

]DMPXMH VL WHUD] Z\áF]QLH UHDOL]DFM ZáDFLZHJR DOJRU\WPX F]\OL V]XNDQLHP SLHU-
wiastka pewnej funkcji f(x)

3R WU]HFLH ]PQLHMV]\áD VL SRGDWQRüSURJUDPXQDEáG\

(zmiana definicji funkcji wymaga poprawie

QLD W\ONR MHGQHM OLQLMNL ]DVWDQyZ VL MDN

Z\JOGDáDE\ SRSU]HGQLD ZHUVMD SURJUDPX JG\E\ REOLF]HQLD Z\PDJDá\ X*\FLD NLONX

RGG]LHOQ\FK LQVWUXNFML :UHV]FLH SR F]ZDUWH SURJUDP Z\JOGD áDGQLHM MHVW EDUG]LHM
elegancki i wymaga mniej pisania.

Funkcje i procedury

.RU]\VWDQLH]SURFHGXUZ\JOGDEDUG]RSRGREQLH]Z\MWNLHPWHJR*HQLHPXVLV]VL

WURV]F]\üR]DJRVSRGDURZDQLH]ZUDFDQHMZDUWRFLSRQLHZD*MHMQLHPD2JyOQLHU]HF]

ELRUF IXQNFMH Z\NRU]\VW\ZDQH V JáyZQLH WDP JG]LH ]DFKRG]L SRWU]HED REOLF]HQLD

MDNLHM SRMHG\QF]HM ZDUWRFL L SU]HND]DQLD MHM GR NROHMQ\FK LQVWUXNFML SURJUDPX

QDWRPLDVW SURFHGXU\ SR]ZDODM QD HIHNW\ZQH Z\NRQ\ZDQLH SRZWDU]DMF\FK VL UXW\-

QRZ\FK F]\QQRFL $E\ QD SU]\NáDG XDWUDNF\MQLü V]DW JUDILF]Q SURJUDPX PR*HV]

Z\NRU]\VWDüZQLPQDVWSXMFSURFHGXU

procedure Szlaczek;

begin
for i := 1 to 60 do { wypisz szlaczek }

ZULWH^]áR*RQ\]JZLD]GHN`

ZULWHOQ^SU]HMG(GRQRZHJRZLHUV]D`

end;

*G]LH XPLHFLü GHILQLFM SURFHGXU\ — MX* ZLHV] 3R]RVWDMH M Z\ZRáDü FR UREL VL
bardzo prosto:

Szlaczek;

.D*GH WDNLH Z\ZRáDQLH XPLHFL QD HNUDQLH ÄV]ODF]HN´ VNáDGDMF\ VL ] JZLD]GHN

2F]\ZLFLH SRZ\*V]D SURFHGXUD QLH MHVW LGHDOQD ER MHOL QS ]DFKFH &L VL Z\SLVDü

V]ODF]HN]áR*RQ\]NUHVHNEG]LHV]PXVLDá]PLHQLüMHMWUHü=QDF]QLHOHSV]\PUR]ZL-

]DQLHPMHVWFRWDNLHJR

procedure Szlaczek(Znak:char; Ile:byte);

begin
for i := 1 to Ile do { wypisz szlaczek }

ZULWH=QDN^]áR*RQ\]LOX]QDNyZ`

writeln;
end;

6SUyEXMP\ZUDPDFK]DEDZ\Z\NRU]\VWDüQDV]SURFHGXUGRZ\ZLHWlenia na ekranie

WUyMNWD]áR*RQHJR]JZLD]GHNF]\OLF]HJRWDNLHJR

*
**
***
****

LWG2GSRZLHGQLSURJUDPEG]LHZ\JOGDáWDN

program Szlaczki;

var
i : integer; { licznik wierszy }

procedure Szlaczek(Znak : char; Ile : integer);

begin
for i := 1 to Ile do { wypisz szlaczek }

ZULWH=QDN^]áR*RQ\]LOX]QDNyZ`

64 Turbo

Pascal

—

programowanie

writeln
end;

begin
for i := 1 to 20 do { wypisz 20 szlaczków }
Szlaczek('*', i);
end.

-HOL XZD*DV] *H ZV]\VWNR MHVW 2. VSUyEXM WHUD] ]PLHQLü SURJUDP WDN E\ ND*G\

V]ODF]HN PLDá GáXJRü UyZQ NROHMQHM OLF]ELH QLHSDU]\VWHM WM SLHUZV]\ GUXJL LWG

2JyOQLH GáXJRü V]ODF]ND Z\UD]L VL Z]RUHP Ile

numer

= ⋅

−

, gdzie numer jest

QXPHUHPZLHUV]DWDNZLFZ\VWDUF]\]PLHQLüJáyZQSWOSURJUDPXQD

for i := 1 to 20 do { wypisz 20 szlaczków }
Szlaczek('*', 2*i - 1);

+PQRFK\EDQLHFDáNLHPWRFKFLDáHX]\VNDüSUDZGD"(IHNWNWyUHJRGRZLDGF]\áH

XUXFKDPLDMFSURJUDPZ\QLND]X*\FLDZSURFHGXU]HLZ\ZRáXMFHMMSWOLWHMVDPHM
zmiennej

DZ\JOGDQDVWSXMFR

:DUWRü

3U]HELHJSWOL

PDE\ü 2

MHVWSU]HGSURFHGXU 2

jest po procedurze

jest po inkrementacji licznika

.D*GHZ\ZRáDQLHSURFHGXU\SRZRGXMHPRG\ILNDFM]PLHQQHM

NWyUDMHVWMHGQRF]HQLH

OLF]QLNLHP SWOL Z SURJUDPLH JáyZQ\P $E\ WHJR XQLNQü QDOH*DáRE\ Z SURFHGXU]H

X*\üMDNROLF]QLNDSWOLLQQHM]PLHQQHM7R]NROHLQDNáDGDQDSURJUDPLVWRERZL]HN
przejrzenia wszystkich proced

XU]QDMGXMF\FKVLZSURJUDPLHLZF]HQLHMV]HJR]DGHN-

ODURZDQLD RGSRZLHGQLFK ]PLHQQ\FK WDN E\ VL QLH ÄQDNáDGDá\´ : HIHNFLH RWU]\PX-

MHP\NROHMQ\]HVWDZáDWZ\FKGRSU]HRF]HQLDSXáDSHN5R]ZL]DQLHPWHJRSUREOHPXV
zmienne lokalne, którymi jednak zajmiem

\VLMX*ZQDVWSQ\PUR]G]LDOH7DPUyZQLH*

GRNRF]\P\ RPDZLDQLH SU]HND]\ZDQLD SDUDPHWUyZ L ZDUWRFL ] L GR SURFHGXU L
funkcji.

Zapamietaj

•

3URFHGXU\LIXQNFMHSDVFDORZHSR]ZDODM]DPNQüGDQ\]HVWDZRSHUDFMLZOR-

JLF]Q FDáRü SRELHUDMF ] RWRF]HQLD RGSRZLHGQLH LQIRUPDFMH L ]ZUDFDMF

*GDQ\Z\QLN

•

3U]HGZ\NRU]\VWDQLHPZ\ZRáDQLHPIXQNFMLOXESURFHGXU\QDOH*\M]GHILnio-

ZDüF]\OLRNUHOLüMHMWUHüLVSRVyENRPXQLNRZDQLDVL]RWRF]HQLHP

66 Turbo

Pascal

—

programowanie

Jak program

SRUR]XPLHZDVL

]IXQNFM"

-DN SRZLHG]LHOLP\ Z SRSU]HGQLP UR]G]LDOH IXQNFMD SURFHGXUD SR]ZDOD ]DPNQü

]HVWDZ ]áR*RQ\FK RSHUDFML Z VZRLVW\ SRMHPQLN Z\NRU]\VW\ZDQ\ SU]H] Z\ZRáXMF\

SURJUDP QD ]DVDG]LH F]DUQHM VNU]\QNL SR ZáR*HQLX GR IXQNFML ]HVWDZX LQIormacji,
prog

UDP RGELHUD Z\QLN QLH SU]HMPXMF VL VSRVREHP MHJR X]\VNDQLD 1LHVWHW\ MDN

PRJáH VL MX* SU]HNRQDü QDV]D VNU]\QND QLH MHVW V]F]HOQD L VWRVXQNRZR áDWZR

GRSURZDG]Lü GR V\WXDFML Z NWyUHM IXQNFMD Z VSRVyE QLHNRQWURORZDQ\ ÄXV]NRG]L´
zmienne programu. Zjawiska tego typu (zarówno kontrolowane, jak i niekontrolowane)

]ZDQH V efektami ubocznymi (ang. side effects L GRü F]VWR XWUXGQLDM *\FLH PQLHM

GRZLDGF]RQ\PSURJUDPLVWRP1DV]F]FLHHIHNWyZXERF]Q\FKPR*QDáDWZRXQLNQü

SR]ZDODMQDWRzmienne lokalne

-DN VDPD QD]ZD ZVND]XMH ]PLHQQD ORNDOQD MHVW ÄSU\ZDWQ ZáDVQRFL´ IXQNFML OXE

SURFHGXU\ ZHZQWU] NWyUHM ]RVWDáD ]GHILQLRZDQD =PLHQQD WDND QLH MHVW ZLGRF]QD QD

]HZQWU]IXQNFMLF]\OLQSZZ\ZRáXMF\PMSURJUDPLHQDWRPLDVWMHVWGRVWSQDGOD

ZV]HONLFK IXQNFML L SURFHGXU ]GHILQLRZDQ\FK Z REUELH GDQHM IXQNFML OXE SURFHGXU\
(o

LOHLFKGHILQLFMHXPLHV]F]RQHVSRGHNODUDFML]PLHQQHM3U]HFLZLHVWZHP]PLHQQHM

ORNDOQHMMHVWRF]\ZLFLH]PLHQQDglobalnaÄZLGRF]QD´ZFDá\PREV]DU]HSURJUDPXod

PRPHQWXMHM]DGHNODURZDQLD.D*GD]GHILQLRZDQDZSURJUDPLHIXQNFMDLSURFHGXUDPD

SHáQ\GRVWSGRZV]\VWNLFK]PLHQQ\FKJOREDOQ\FKF]HJRMHGQDNQLHQDOH*\QDGX*\ZDü

DZUF]QLHQDOH*\X*\ZDüZRJyOHÄ=DNUHVZLG]LDOQRFL´]PLHQQHMQD]\ZDQ\MHVWMHM

]DVLJLHP (ang. scope).

=DUyZQRGHNODUDFMDMDNLVSRVyEZ\NRU]\VWDQLD]PLHQQ\FKORNDOQ\FKVÄQDRNR´WDNLH

VDPH MDN GOD ]PLHQQ\FK JOREDOQ\FK 5y*QLFD NU\MH VL Z ORNDOL]DFML ]PLHQQ\FK REX

FLOHM obiekty ORNDOQH ERZLHP RSUyF] ]PLHQQ\FK ORNDOQH PRJ E\ü UyZQLH* VWDáH
i typy, o których jednak na ra

]LHQLHPyZLOLP\

-DNSURJUDPSRUR]XPLHZDVL]IXQNFM"

W\SyZ]PLHQQHJOREDOQHSU]HFKRZ\ZDQHVZW]Zsegmencie danych i LVWQLHMSU]H]

FDá\F]DVZ\NRQ\ZDQLDSURJUDPX']LNLWHPXV]DZV]HGRVWSQHGODND*GHM]H]GH-

ILQLRZDQ\FKZSURJUDPLHIXQNFMLRLOHQLH]DFKRG]LW]Z]MDZLVNRSU]\VáDQLDQLDRNWy-

U\P]DFKZLO=PLHQQHORNDOQHXPLHV]F]DQHV]NROHLQDstosie, czyli w specjalnym

REV]DU]H SDPLFL SU]H]QDF]RQ\P GR W\PF]DVRZHJR SU]HFKRZ\ZDQLD LQIRUPDFML
W

RGUy*QLHQLXRG]PLHQQ\FKJOREDOQ\FKF]DV*\FLD]PLHQQ\FKORNDOQ\FKRJUDQLF]RQ\

MHVWGRF]DVXZ\NRQ\ZDQLDSRVLDGDMFHMMHIXQNFMLWDNZLFÄORNDOQRü´PDFKDUDNWHU
nie tylko przestrzenny, ale i czasowy —

]PLHQQH ORNDOQH V WZRU]RQH Z PRPHQFLH

UR]SRF]FLDZ\NRQ\ZDQLDIXQNFMLL]QLNDMSRMHM]DNRF]HQLX2F]\ZLVWHMHVWZLF*H

SUyED RGZRáDQLD VL GR ]PLHQQHM ORNDOQHM QD ]HZQWU] GHNODUXMFHM M IXQNFML MHVW

QLHOHJDOQDJG\*]PLHQQDWDNDSRSURVWXQLHLVWQLHMH

-DN ZF]HQLHM ZVSRPQLHOLP\ IXQNFMD SURFHGXUD SU]\SRPLQD VWUXNWXU PDá\ SURJ-

UDP WRWH* GHNODUDFMH ]PLHQQ\FK ORNDOQ\FK XPLHV]F]D VL ]Z\NOH QD MHM SRF]WNX SR

QDJáyZNX 8*\FLH ]PLHQQ\FK ORNDOQ\FK ]DGHPRQVWUXMHP\ QD SU]\NáDG]LH SURJUDPX

Szlaczki

GRSURZDG]DMFJRSU]\RND]MLGRVWDQXSHáQHMX*\ZDOQRFL$E\WR]URELü

Z\VWDUF]\SRSUDZLüSURFHGXU

Szlaczek

procedure Szlaczek(Znak : char; Ile : integer);

var { deklaracja zmiennej lokalnej, }
i : integer; { czyli licznika znaków }

begin
for i := 1 to Ile do { wypisz szlaczek }

ZULWH=QDN^]áR*RQ\]LOX]QDNyZ`

writeln
end;

7DNSRSUDZLRQ\SURJUDPSRZLQLHQG]LDáDüSRSUDZQLHQLH]DOH*QLHRG*GDQHMGáXJRFL

FLJX ]QDNyZ :SURZDG]DMF GR SURFHGury

Szlaczek

GHNODUDFM ]PLHQQHM

spowodo

ZDáH*HSRGF]DVND*GHJRZ\ZRáDQLDNRU]\VWDRQDQLH]H]PLHQQHMJOREDOQHM

DOH ]H VZRMHM ÄSU\ZDWQHM´ ]PLHQQHM ORNDOQHM =DXZD* SU]\ RND]ML *H RELH ]PLHQQH

QD]\ZDMVLWDNVDPRDPLPRWRSURJUDPG]LDáDSRSUDZQLH=MDZLVNRÄPDVNRZDQLD´

]PLHQQHM JOREDOQHM SU]H] LGHQW\F]QLH QD]ZDQ ]PLHQQ ORNDOQ QD]\ZD VL

SU]\VáDQLDQLHP L GDMH &L JZDUDQFM *H QDZHW MHOL ]DGHNODUXMHV] Z IXQNFML ]PLHQQ

ORNDOQ R QD]ZLH WDNLHM VDPHM MDN ]PLHQQD ]HZQWU]QD Z V]F]HJyOQRFL JOREDOna),

ZV]HONLHRGZRáDQLDZHZQWU]IXQNFMLEG]DZV]HNLHURZDQHGR]PLHQQHMORNDOQHM]D

RGSRZLHGQLD ]PLHQQD ]HZQWU]QD SR]RVWDQLH QLHQDUXV]RQD ']LNL WHPX QLH PXVLV]

GEDü R WR E\ ]PLHQQH GHNODURZDQH Z UDPDFK SRV]F]HJyOQ\FK IXQNFML PLDá\ Uy*QH

QD]Z\LE\NWyUDSU]\SDGNLHPQLHQD]\ZDáDVLWDNVDPRMDNRGSRZLHGQLD]PLHQQD
globalna.

$E\]REUD]RZDüSRMFLD]DVLJXLSU]\VáDQLDQLDZ\REUD(P\VRELHSHZLHQDEVWUDNF\MQ\
program, w którym zdefiniowano kilka zmiennych globalnych oraz procedur i funkcji

:\MWNLHPVWXWDMORNDOQH]PLHQQHSUHGHILQLRZDQH]PLHQQH]ZDUWRFLSRF]WNRZ

NWyUH ORNRZDQH V Z VHJPHQFLH GDQ\FK D ZLF LVWQLHM SU]H] FDá\ F]DV Z\NRQ\ZDQLD

SURJUDPX1LH]PLHQLDWRIDNWX*HLRQHQLHVZLGRF]QHQD]HZQWU]SRVLDGDMF\FKMH
funkcji i procedur.

68 Turbo

Pascal

—

programowanie

posiada

MF\FK VZRMH ]PLHQQH ORNDOQH 1D U\VXQNX RERN SU]HGVWDZLRQ\ MHVW VFKHPDW

WDNLHJRSURJUDPX:WDEHOFHSRND]DQ\MHVW]DVLJSRV]F]HJyOQ\FK]PLHQQ\FKZLG]LDO-

QRüZ SURJUDPLHLSURFHGXUDFK]QDNJZLD]GNLR]QDF]DSU]\VáDQLDQLH

.LHG\ X*\ZDü ]PLHQQ\FK ORNDOQ\FK D NLHG\ JOREDOQ\FK" =DVDGQLF]R ]PLHQQ\FK

JOREDOQ\FKZSURFHGXUDFKLIXQNFMDFKQLHQDOH*\X*\ZDüZRJyOH=GDU]DMVLMHGQDN
sytuacje, kiedy

ZLDGRPH X*\FLH ]PLHQQHM JOREDOQHM F]\OL ZLDGRPH Z\NRU]\VWDQLH

efektów ubocznych) upraszcza program. Efekty

XERF]QH]QDMGXMQDRJyá]DVWRVRZDQLH

GR SU]HND]\ZDQLD LQIRUPDFML ] L GR IXQNFML SURFHGXU SR]ZDODMF QD ]UHGXNRZDQLH

OLF]E\ SDUDPHWUyZ -HOL MHGQDN FKFLDáE\ ]DRV]F]G]Lü VRELH SLVDQLD GHNODUXMF Z
prog

UDPLHMHGQ]PLHQQJOREDOQ

LX*\ZDMFMHMMDNROLF]QLNDZHZV]\VWNLFKSURFH-

UDFK NWyUH WDNRZHJR SRWU]HEXM V]XNDV] JX]D 3UG]HM F]\ Sy(QLHM NWyUD

SU]\V]á\FK PRG\ILNDFML SURJUDPX VSRZRGXMH XMDZQLHQLH VL HIHNWyZ XERF]Q\FK

w formie prowa

G]FHMGREáGXZ\NRQDQLD

3RQLHZD*ZV]HONLHF]\QQRFLZ\NRQ\ZDQHSU]H]IXQNFMOXESURFHGXUVQLHGRVWU]H-

JDOQH GOD Z\ZRáXMFHJR M SURJUDPX ]PLHQQH Z\NRU]\VW\ZDQH Z WUDNFLH Z\NRQ\-

ZDQLD W\FK F]\QQRFL SRZLQQ\ E\ü GOD QLHJR QLHGRVWU]HJDOQH D ]DWHP SRZLQQ\ E\ü

GHNODURZDQH MDNR ]PLHQQH ORNDOQH : V]F]HJyOQRFL GRW\F]\ WR ]PLHQQ\FK W\PF]D-

VRZ\FKLSRPRFQLF]\FKMDNOLF]QLNLSWOLW\PF]DVRZHZDUWRFLPDNVLPyZLPLQLPyZ

]PLHQQHWHNVWRZHX*\ZDQHSU]\Z\SURZDG]DQLXNRPXQLNDWyZLWS

:V]HONLH]PLHQQHSU]H]QDF]RQHZ\áF]QLHGRX*\WNXZHZQWU]QHJRIXQNFML
i proc

HGXUSRZLQQ\E\üEH]Z]JOGQLHGHNODURZDQHMDNR]PLHQQHORNDOQH

=PLHQQHJOREDOQHSRZLQQ\E\üZ\NRU]\VW\ZDQHW\ONRGRSU]HFKRZ\ZDQLD

GDQ\FKLVWQLHMF\FKSU]H]FDá\F]DVWUZDQLDSURJUDPX

: RVWDWQLHM F]FL WHJR UR]G]LDáX ]DMPLHP\ VL VSUDZ SU]HND]\ZDQLD LQIRUPDFML

SRPLG]\ IXQNFMDPL L SURFHGXUDPL D Z\ZRáXMF\P MH SURJUDPHP -DN MX* ZLHV]

Z\PLDQD WDND PR*H E\ü ]UHDOL]RZDQD ] Z\NRU]\VWDQLHP HIHNWyZ XERF]Q\FK FR QLH

MHVW ZVND]DQH OXE ]D SRPRF SDUDPHWUyZ DUJXPHQWyZ 'HNODURZDQLH L
wykorzystanie parametró

Z E\áR MX* RPDZLDQH SRSU]HGQLR SU]\SRPQLMP\ ZLF Z

skrócie:

•

SDUDPHWU\GHNODURZDQHVZQDJáyZNXIXQNFMLSURFHGXU\MDNRW]Zparametry
formalne

F]\OL LGHQW\ILNDWRU\ QD]Z\ V\PEROL]XMFH GDQH SU]HND]\ZDQH GR

funkcji;

•

SRGF]DV Z\ZRáDQLDZPLHMVFHSDUDPHWUyZIRUPDOQ\FKSRGVWDZLDQHVU]HF]\-

ZLVWHZDUWRFL]PLHQQ\FKVWDá\FKLZ\UD*HWZRU]FHW]Zparametry aktualne;

•

SDUDPHWU\IRUPDOQHRSLVXMMHG\QLHSRVWDüLQIRUPDFMLSU]HND]\ZDQHMGRIXQNFML

SURFHGXU\U]HF]\ZLVWLQIRUPDFMQLRV]HVREGRSLHURSDUDPetry aktualne.

-DNSURJUDPSRUR]XPLHZDVL]IXQNFM"

SURJUDP=DVLHJL

YDULMLQWHJHU

[UHDO

SURFHGXUH7U]HFLD[UHDO

YDUNLQWHJHU

SURFHGXUH:HZQ

YDUNOLQWHJHU

SURFHGXUH3LHUZV]D

YDUNLQWHJHU

SURFHGXUH'UXJD[UHDO

YDUNLQWHJHU

Zmienna

=DVLJ

ZáDFLFLHO

Program Pierwsza Druga

Trzecia

Wewn

(

program

)

tak

(

program

)

tak

nie (*)

tak

(

program

)

tak

nie (*)

nie

(

Pierwsza

)

nie

tak

nie nie nie

(

Pierwsza

)

nie

tak

nie nie nie

(

Druga

)

nie nie

tak

nie nie

(

Druga

)

nie nie

tak

nie nie

(

Trzecia

)

nie nie nie

tak tak

(

Trzecia

)

nie nie nie

tak

nie (*)

(

Wewn

)

nie nie nie nie

tak

(

Wewn

)

nie nie nie nie

tak

Rysunek 10.

:LG]LDOQRü]PLHQQych lokalnych i globalnych w programie

70 Turbo

Pascal

—

programowanie

:HZQWU]IXQNFMLSDUDPHWU\]DFKRZXMVLMDNQRUPDOQH]PLHQQHPR*QDZ\NRQ\ZDü

QD QLFK ZV]HONLH RSHUDFMH WDN VDPR MDN QD ]PLHQQ\FK ORNDOQ\FK 0R*OLZH MHVW

]DGHNODURZDQLHSDUDPHWUXRQD]ZLHWDNLHMVDPHMMDN]PLHQQDJOREDOQDZRJyOQRFL—

]PLHQQD]DGHNODURZDQDZEORNXQDGU]GQ\PZ\VWSLZyZF]DVHIHNWSU]\VáDQLDQLDWM

ZV]HONLH RGZRáDQLD ZHZQWU] IXQNFML NRU]\VWDMFHM]SDUDPHWUXEGRGQRVLá\VLGR

QLHJRDQLHGRSU]\VáRQLWHMSU]H]H]PLHQQHM1LHOHJDOQHMHVWnatomiast deklarowanie

]PLHQQ\FKORNDOQ\FKLSDUDPHWUyZRLGHQW\F]Q\FKQD]ZDFKQLHPyZLFMX*R]DGHN-

ODURZDQLXSDUDPHWUXRQD]ZLHLGHQW\F]QHM]QD]ZIXQNFMLNWyUDJRZ\NRrzystuje).

:V]\VWNLHLGHQW\ILNDWRU\WMQD]Z\]PLHQQ\FKVWDá\FKW\SyZSDUDPHWUyZ

SURFHGXULIXQNFMLGHNODURZDQHZREUELHGDQHJREORNX]Z\MWNLHPEORNyZ

SRGU]GQ\FKPXV]E\üXQLNDOQH0R*OLZHMHVWQDWRPLDVWÄ]GXEORZDQLH´

LGHQW\ILNDWRUDZEORNXSRGU]GQ\PFRVSRZRGXMHHIHNWSU]\VáDQLDQLD

:DUWR ZVSRPQLHü *H SRF]WNXMF\ SURJUDPLFL F]VWR QDGX*\ZDM SDUDPHWUyZ

Z\NRU]\VWXMFMHMDNR]PLHQQHORNDOQHOXEFRMHVWMX*]EURGQLGHNODUXMGRGDWNRZH

SDUDPHWU\ W\ONR L Z\áF]QLH Z W\P FHOX 3UDNW\ND WD FKRFLD* OHJDOQD MHVW VSU]HF]QD
z

]DVDGDPL SRSUDZQHJR SURJUDPRZDQLD SDUDPHWU\ SU]H]QDF]RQH V GR Z\PLDQ\

LQIRUPDFMLSRPLG]\IXQNFMQLH]DGRÄSRGSLHUDQLDVL´ZZ\NRQ\ZDQ\FKSU]H]QL

RSHUDFMDFKRFKDUDNWHU]HZHZQWU]Q\P

7ZRU]FSURJUDPPXVLV]SDPLWDüRZáDFLZ\PSRG]LDOHNRPSHWHQFMLSRPLG]\

VNáDGDMF\PLVLQDRELHNWDPL-HOLRELHNWSU]H]QDF]RQ\MHVWGRSU]HND]\ZDQLD

LQIRUPDFMLQLHSRZLQLHQHX*\ZDüJRMDNR]PLHQQHMORNDOQHM3RF]WDQLHVáX*\

GRSU]HV\áDQLDZLDGRPRFLGRVVLHGQLHJRSRNRMX

'RWHMSRU\NRQFHQWURZDOLP\VLQDSU]HND]\ZDQLXLQIRUPDFML]Z\ZRáXMFHJRSURJ-

UDPX GR IXQNFML OXE SURFHGXU\ 3R SU]HWZRU]HQLX WHM LQIRUPDFML QD RJyá ]DFKRG]L

NRQLHF]QRü ]ZUyFHQLD Z\QLNX GR Z\ZRáXMFHJR -HOL Z\QLN MHVW SRMHG\QF]

ZDUWRFL MHVW W\SX SURVWHJR QDMOHSLHM X*\ü IXQNFML NWyUDSR]ZDODQD]ZUyFHQLHJR
przez nazw

5R]ZL]DQLH WR E\ZD MHGQDN F]DVDPL QLHZ\JRGQH QLH PyZLF MX* R

V\WXDFMDFKJG\WU]HED]ZUyFLüGRZ\ZRáXMFHJRGZLHOXEZLFHMZDUWRFL3RQLHZD*

WU]\PDP\ VL ] daleka od efektów ubocznych, pozostaje wykorzystanie do tego celu

SDUDPHWUyZ :\REUD( VRELH QD SU]\NáDG *H MHVW &L SRWU]HEQD IXQNFMD REOLF]DMFD

MHGQRF]HQLHVLQXVLFRVLQXVGDQHJRNWD0R*QDWR]URELüQSWDN

program Trygonometria;
{ demonstracja przekazywania parametrów }
var
i : integer;
s, c : real;

procedure SinCos(x : real; SinX, CosX : real);

^REOLF]DMHGQRF]HQLHVLQXVLFRVLQXVDUJXPHQWX`

begin
SinX := sin(x);
CosX := cos(x);
end;

-DNSURJUDPSRUR]XPLHZDVL]IXQNFM"

begin

6LQ&RV3LVF^REOLF]ZDUWRFL`

writeln(s:8:3, c:8:3); { i wypisz je na ekranie }
end.

1LHVWHW\ Z\QLN E\QDMPQLHM QLH MHVW VDW\VIDNFMRQXMF\ ]DPLDVW REOLF]RQ\FK ZDUWRFL

SURJUDP Z\ZLHWOD ]HUD OXE LQQH SR]EDZLRQH VHQVX OLF]E\ ']LHMH VL WDN GODWHJR L*
w swojej obecnej formie parametry

SinX

CosX

SR]ZDODM MHG\QLH QD SU]HND]DQLH

LQIRUPDFML GR SURFHGXU\ QLH ]D RGZURWQLH 1D V]F]FLH Z\VWDUF]\ MHGQD GUREQD
modyfikacja w programie:

procedure SinCos(x : real; var SinX, CosX : real);

E\ZV]\VWNR]DF]áRG]LDáDüSRSUDZQLH&RWDNLHJRVL]PLHQLáR"

2Wy*GRGDQLHVáRZDNOXF]RZHJR

var

SU]HGQD]ZSDUDPHWUXSDUDPHWUyZ]DVDGQLF]R

]PLHQLD VSRVyE LFK SU]HND]\ZDQLD 3RSU]HGQLR PLHOLP\ GR F]\QLHQLD ] WDN ]ZDQ\P

SU]HND]\ZDQLHPSU]H]ZDUWRüXPR*OLZLDMF\PZ\áF]QLHZáR*HQLHGDQ\FKGRIXQNFML

SURFHGXU\ ']LDáDQLH SU]HND]\ZDQLD SU]H] QD]Z VSURZDG]DáR VL GR XPLHV]F]HQLD
w odpowiednim miejscu (tj. na stosie)

NRSLLZDUWRFLSDUDPHWUXDNWXDOQHJR, która nas-

WSQLHPRJáDE\üSU]HWZDU]DQDZHZQWU]IXQNFMLOXESURFHGXU\2EHFQLHZ\NRU]\VW\-

ZDQ\ PHFKDQL]P QRVL QD]Z SU]HND]\ZDQLD SU]H] QD]Z LQQH PGUH RNUHOHQLH WR

SU]HND]\ZDQLHSU]H]ZVND(QLNOXESU]H]UHIHUHQFMLUy*QLVLRGSRSU]HGQLHJRW\P*H

SURFHGXUDRWU]\PXMHQLHNRSLZDUWRFLSDUDPHWUXDNWXDOQHJROHF]LQIRUPDFMRMHJR

SRáR*HQLX0R*QDWRSU]HGVWDZLüQDVWSXMFR

Rysunek 11.

0HFKDQL]PSU]HND]\ZDQLDSDUDPHWUyZDSU]H]ZDUWRüESU]H]QD]Z

:SU]\SDGNXSU]HND]\ZDQLDSU]H]ZDUWRüIXQNFMDRWU]\PXMHMHG\QLHNRSLU]HF]\ZLV-

WHJRSDUDPHWUX=DVLJRSHUDFMLGRNRQ\ZDQ\FKQDWDNLHMNRSLLRJUDQLF]DVLGRZQWU]D

IXQNFML ]D JG\ WD NRF]\ G]LDáDQLH ZDUWRü SDUDPHWUX MHVW WUDFRQD 3DUDPHWU\

SU]HND]\ZDQH SU]H] ZDUWRü ]DFKRZXM VL ZLF LGHQW\F]QLH MDN ]PLHQQH ORNDOQH

Uy*QLF VL RG QLFK MHG\QLH SU]H]QDF]HQLHP ,QDF]HM Z\JOGD VSUDZD Z SU]\SDGNX

SU]HND]\ZDQLDSU]H]QD]ZIXQNFMDRWU]\PXMHWXQLHNRSLSDUDPHWUXOHF]W]ZZVND(-
nik op

LVXMF\MHJRU]HF]\ZLVWHSRáR*HQLH:V]HONLHRSHUDFMHGRNRQ\ZDQHSU]H]IXQNFM

QD SDUDPHWU]H SU]HND]\ZDQ\P SU]H] QD]Z GRW\F] QLH NRSLL DOH U]HF]\ZLVWHJR

RELHNWXEGFHJRZáDVQRFLSURJUDPX0R*QDZLFSRZLHG]LHü*HIXQNFMDÄVLJDQD

72 Turbo

Pascal

—

programowanie

]HZQWU]´ GR ]DVREyZ SURJUDPX L PRG\ILNXMH MH ]H VNXWNLHP QDW\FKPLDVWRZ\P D
efek

W\ ZV]\VWNLFK RSHUDFML SR]RVWDM ÄXWUZDORQH´ Z WUHFL RELHNWX EGFHJR

SDUDPHWUHP =DXZD* *H SRQLHZD* IXQNFMD RWU]\PXMH WX ZVND(QLN GR U]HF]\ZLVWHJR

SDUDPHWUXQLHPR*HV]SU]HND]DüSU]H]QD]ZRELHNWXQLHSRVLDGDMFHJRORNDOL]DFMLZ

SDPLFLQSVWDáHMF]\Z\UD*HQLDF]\OLQLHEGFHJRl-ZDUWRFL3U]HND]DQLHWDNLHJR

SDUDPHWUXSU]H]ZDUWRüMHVWQDWRPLDVWQDM]XSHáQLHMOHJDOQH
.LHG\ VWRVRZDü SU]HND]\ZDQLH SDUDPHWUyZ SU]H] ZDUWRü D NLHG\ SU]H] QD]Z"

3U]HND]\ZDQLH SU]H] ZDUWRü X*\ZDQH MHVW Z ÄNRPXQLNDFML MHGQRNLHUXQNRZHM´ F]\OL

ZyZF]DVJG\]ZUyFHQLHZDUWRFLGRZ\ZRáXMFHJRSURJUDPXQLHMHVWZ\PDJDQHOXE

ZUF] MHVW QLHZVND]DQH WM FKFHP\ ]DEH]SLHF]\ü VL SU]HG PRG\ILNDFM RELHNWX

EGFHJRSDUDPHWUHP-H*HOL]DFKRG]LSRWU]HEDSU]HND]DQLDZDUWRFL]SRZURWHPGR

Z\ZRáXMFHJR NRQLHF]QH MHVWX*\FLHSU]HND]\ZDQLDSU]H]QD]ZF]\OLSRSU]HG]HQLH

QD]Z\ SDUDPHWUX VáRZHP

var

3U]HND]\ZDQLH SU]H] QD]Z VWRVXMH VL UyZQLH* GOD

DUJXPHQWyZ R ZLNV]\FK UR]PLDUDFK QS WDEOLF áDFXFKyZ L LQQ\FK ]PLHQQ\FK

VWUXNWXUDOQ\FKRNWyU\FKSRZLHP\ZNUyWFHQDZHWZyZF]DVJG\QLHFKFHP\]ZUDFDü

LFK ZDUWRFL -DN SRZLHG]LHOLP\ SU]HG FKZLO SU]HND]DQLH SU]H] ZDUWRü SRZRGXMH
umieszczenie na stosie kopii paramet

UX FR SU]\ ZLNV]\FK UR]PLDUDFK SDUDPHWUyZ

]DMPXMHVSRURF]DVXLPR*HGRSURZDG]LüGRSU]HSHáQLHQLDVWRVXQDNWyU\PRSUyF]WHJR

PXV] ]PLHFLü VL ]PLHQQH ORNDOQH L NLOND LQQ\FK U]HF]\ 3RGF]DV SU]HND]\ZDQLD

SU]H] QD]Z QD VWRVLH XPLHV]F]DQ\ MHVW ]DZV]H F]WHUREDMWRZHM GáXJRFL ZVND(QLN GR

SDUDPHWUX QLH]DOH*QLH RG IDNW\F]QHM ZLHONRFL WHJR RVWDWQLHJR FR RF]\ZLFLH WUZD

]QDF]QLH NUyFHM $E\ ]DEH]SLHF]\ü WDNL SDUDPHWU SU]HG QLHSR*GDQ PRG\ILNDFM

PR*HP\ ]DVWRVRZDü Z PLHMVFH VáRZD

var

VáRZR NOXF]RZH

const

NWyUH UyZQLH*

SRZRGXMH SU]HND]DQLH ZVND(QLND GR SDUDPHWUX EORNXMF MHGQRF]HQLH PR*OLZRü

PRG\ILNRZDQLD WHJR RVWDWQLHJR $E\ VL R W\P SU]HNRQDü VSUyEXM ]PLHU]\ü F]DV

Z\NRQDQLDQDVWSXMFHJRSURJUDPX

program Parametry;

type
TablInt = array [1..5000] of integer;

var
i : integer;
ti : TablInt;

procedure Pusta(t : TablInt);

var k : integer;

begin
k := t[1]
end;

begin
for i := 1 to 1000 do

^WRPR*HSRWUZDü`

Pusta(ti);
end.

-DNSURJUDPSRUR]XPLHZDVL]IXQNFM"

-HOLMX*WR]URELáH]PLHQDJáyZHNSURFHGXU\

Pusta

procedure Pusta(var t : TablInt)

7\PUD]HPSURJUDPSRZLQLHQZ\NRQDüVLEá\VNDZLF]QLHSU]\QDMPQLHMZSRUyZQDQLX

GRSRSU]HGQLHMZHUVML']LHMHVLWDNGODWHJR*HSRGF]DVND*GHJRZ\ZRáDQLDSURFH-

GXU\QDVWRVLHXPLHV]F]DQ\MHVWMHG\QLHZVND(QLNGRWDEOLF\

ZVXPLHW\VLFUD]\SR

EDMW\SRGF]DVJG\SRSU]HGQLRQDVWRVNRSLRZDQDE\áDFDáDWDEOLFDW\VLFUD]\

EDMWyZ F]\OL UD]\ ZLFHM 'RGDWNRZ ÄDWUDNFM´ ]ZL]DQ ] SU]HND]\ZDQLHP

ZLNV]\FK VWUXNWXU SU]H] ZDUWRü MHVW PR*OLZRü SU]HSHáQLHQLD Vtosu (standardowo

ZLHONRüVHJPHQWXVWRVXXVWDZLDQDMHVWSU]H]7XUER3DVFDODQDN%$E\VLRW\P

SU]HNRQDü ]PLH Z SLHUZRWQHM ZHUVML SURJUDPX WHM EH] VáRZD

var

Z QDJáyZNX

procedury) rozmiar tablicy na 10000 liczb:

type
TablInt = array [1..10000] of integer;

3UyED Z\NRQDQLD SURJUDPX VNRF]\ VL W\P UD]HP NRPXQLNDWHP

Stack overflow

error

: sumaryczny rozmiar tablicy wynosi 20000 bajtów (10000 dwubajtowych liczb

FDáNRZLW\FK F]\OL ZLFHM QL* PR*QD XPLHFLü QD VWRVLH 3RGREQLH MDN SRSU]HGQLR
przekazan

LHSDUDPHWUXSU]H]QD]ZUR]ZL]XMHSUREOHP

3U]HND]XMFZLNV]HVWUXNWXU\GDQ\FKMDNRSDUDPHWU\IXQNFMLLSURFHGXUQDOH*\

XQLNDüSU]HND]\ZDQLDSU]H]ZDUWRüLVWRVRZDüZ]DPLDQSU]HND]\ZDQLHSU]H]

QD]Z$E\]DEH]SLHF]\üVLSU]HGSU]\SDGNRZPRG\ILNDFMZDUWRFL

SDUDPHWUXPR*QD]DVWRVRZDüVáRZRNOXF]RZH

const

w miejsce

var

:WHQVSRVyE]DNRF]\OLP\RPDZLDQLHSRGVWDZRZ\FK]DJDGQLH]ZL]DQ\FK]SURFH-

GXUDPL L IXQNFMDPL : QDVWSQ\FK UR]G]LDáDFK ]DMPLHP\ VL Z\MDQLDQLHP GZyFK

QRZLQHNNWyUHSRMDZLá\VLZRVWDWQLPSURJUDPLHLNWyUH]DSHZQHSU]\MáHQDZLDU

6 WR PLDQRZLFLH WDEOLFH D ZáDFLZLH W\S\ VWUXNWXUDOQH RUD] GHILQLRZDQLH ZáDVQ\FK

W\SyZF]\OLVáRZRNOXF]RZH

type

=DSDPLWDM

•

:V]HONLH RELHNW\ ]DGHNODURZDQH ZHZQWU] IXQNFML SURFHGXU\ V W]Z RELHN-

WDPLORNDOQ\PL2ELHNW\ORNDOQHVQLHZLGRF]QHQD]HZQWU]IXQNFML

•

2ELHNW\]DGHNODURZDQHZSURJUDPLHJáyZQ\PQD]HZQWU]ZV]\VWNLFKSURFH-

GXULIXQNFMLVRELHNWDPLJOREDOQ\PL6RQHGRVWSQHGODZV]\VWNLFKHOHPHQ-
tów programu.

•

Wszelkie obiek

W\ SU]H]QDF]RQH Z\áF]QLH GR X*\WNX ZHZQWU]QHJR IXQNFML

SURFHGXU\SRZLQQ\E\üGHNODURZDQHMDNRORNDOQH

•

=DNUHVÄZLG]LDOQRFL´RELHNWX]ZDQ\MHVWMHJR]DVLJLHP

•

Zadeklarowanie w funkcji (procedurze) obiektu lokalnego o takiej samej nazwie

MDNRELHNW]EORNXQDGU]GQHJRSRZRGXMHSU]\VáRQLFLHWHJRRVWDWQLHJR

74 Turbo

Pascal

—

programowanie

•

Modyfikowanie obiektów nielokalnych (czyli przekazywanie informacji do/z

IXQNFML OXE SURFHGXU\ GURJ LQQ QL* SU]H] SDUDPHWU\ OXE QD]Z IXQNFML QRVL

QD]ZHIHNWyZXERF]Q\FK

•

(IHNWyZXERF]Q\FKQDOH*\XQLNDüDMHOLVLLFKX*\ZD—F]\QLüWR]UR]ZDJ

•

3DVFDO XGRVWSQLD GZLH PHWRG\ SU]HND]\ZDQLD SDUDPHWUyZ SU]H] ZDUWRü
i

SU]H]QD]Z

•

3U]HND]\ZDQLHSU]H]ZDUWRüG]LDáDMHGQRNLHUXQNRZRWMSU]HND]XMHLQIRUPDFM

RGZ\ZRáXMFHJRGRZ\ZRá\ZDQHMIXQNFMLOXESURFHGXU\

•

3U]HND]\ZDQLH SU]H] QD]Z XPR*OLZLD ]ZUyFHQLH ]PRG\ILNRZDQHM ZDUWRFL

SDUDPHWUXGRZ\ZRáXMFHJR

•

3U]HND]XMFGRIXQNFMLOXESURFHGXUZLNV]HVWUXNWXU\GDQ\FKQDOH*\VWRVRZDü

SU]HND]\ZDQLH SU]H] QD]Z 6NUDFD WR F]DV Z\NRQDQLD SURJUDPX L XPR*liwia

XQLNQLFLHSU]HSHáQLHQLDVWRVX

3URJUDPRZDQLHQDSRZD*QLH

Programowanie
na

SRZD*QLH

: NROHMQ\FK NLONX UR]G]LDáDFK ]DMPLHP\ VL UHDOL]DFM SURVWHJR DF] SRXF]DMFHJR

]DGDQLD PDV] RWR QDSLVDü SURJUDP ZVSRPDJDMF\ REVáXJ PDáHM ELEOLRWHNL 2SUyF]

Z\MDQLHQLD ]DV\JQDOL]RZDQHJR XSU]HGQLR WHPDWX SU]HFKRZ\ZDQLD ZLNV]\FK LORFL

GDQ\FKLNLONXLQQ\FKU]HF]\VSUyEXMHP\QDW\PSU]\NáDG]LHSU]HGVWDZLüPHWRG\N

SURMHNWRZDQLDSURJUDPXUHDOL]XMFHJRSHZQHU]HF]\ZLVWHLSUDNW\F]QH]DGDQLH

6IRUPXáRZDQLHQDV]HJR]DGDQLDEU]PLÄ1DSLV]SURJUDPZVSRPDJDMF\REVáXJELEOLR-

WHNLV]NROQHM´LMHVWRF]\ZLFLH]E\WRJyOQLNRZHE\GDáRVLVNXWHF]QLHSU]HWáXPDF]\ü

QD SURJUDP $E\ MH XFLOLü PXVLP\ VSUHF\]RZDü Z\PDJDQLD X*\WNRZQLND F]\OL

RVRE\ REVáXJXMFHM ELEOLRWHN RUD] RNUHOLü RJUDQLF]HQLD SURJUDPX F]\OL U]HF]\

NWyU\FK]GHILQLFMLQLHEG]LHRQZVWDQLH]URELüLQDGNWyU\PLQLHEG]LHP\VLZRJyOH

]DVWDQDZLDü

$E\ XVWDOLü OLVW Z\PDJD EGF SRGVWDZ GR ]DSURMHNWRZDQLD SRV]F]HJyOQ\FK

IXQNFML SURJUDPX PXVLP\ VNRQVXOWRZDü VL ] MHJR SU]\V]á\P X*\WNRZQLNLHP FR
w

]QDF]QHMPLHU]HVSURZDG]DVLGRWáXPDF]HQLDGODF]HJRWHJRF]\WDPWHJRVLQLHGD

]URELü =Dáy*P\ *H Z Z\QLNX SHUWUDNWDFML ] ELEOLRWHNDUN XVWDOLOLP\ *H QDV]

NRPSXWHURZ\NDWDORJSRZLQLHQXPR*OLZLDü

•

ZSURZDG]HQLH ] NODZLDWXU\ L Z\ZLHWOHQLH QD HNUDQLH LQIRUPDFML R DXWRU]H
i

W\WXOHNVL*NL

•

Z\ZLHWOHQLH OLVW\ NVL*HN XSRU]GNRZDQ\FK DOIDEHW\F]QLH ZHGáXJ QD]ZLVND

DXWRUDOXEW\WXáX

•

Z\V]XNDQLHNVL*NLZHGáXJSLHUZV]\FKOLWHUW\WXáX

•

VSUDZG]HQLHF]\NVL*NDMHVWQDSyáFHF]\WH*]RVWDáDZ\SR*\F]RQDMHOLWDN—
to komu);

•

Z\V]XNDQLHNVL*NLQDMF]FLHMLQDMU]DG]LHMZ\SR*\F]DQHM

76 Turbo

Pascal

—

programowanie

'X*RWHJRDOHMDNRVRELHSRUDG]LP\0DMFGRG\VSR]\FMLOLVW*\F]HNOLHQWDPR*H-

P\ SU]\VWSLü GR SURMHNWRZDQLD SURJUDPX NWyUHJR ]DVDGQLF]\PL HOHPHQWHP EG]LH
ustalenie sposobu przechowywania informacji (czyli struktur danych) oraz sposobu jej

SU]HWZDU]DQLD F]\OL DOJRU\WPyZ 3RQLHZD* GDQH UHSUH]HQWXM SHZQH U]HF]\ZLVWH

RELHNW\ NVL*NL PXVLP\ SURMHNWRZDü QDV] SURJUDP SRG NWHP ZáDFLZRFL W\FK
obiekt

yZ 1DMSLHUZ ]DWHP XWZRU]\P\ UHSUH]HQWDFM GDQ\FK D QDVWSQLH PHWRG\ ]D

SRPRFNWyU\FKEG]LHP\MHSU]HWZDU]Dü7DNDZáDQLHNROHMQRüSRVWSRZDQLDVWRVR-

ZDQDMHVWSRGF]DVSURMHNWRZDQLDZLNV]RFLSURJUDPyZ

&KRFLD* ELEOLRWHND ]DZLHUD ZLHOH NVL*HN ZV]\VWNLH RQH PDM SHZLHQ ]HVWDZ ZVSyO-

Q\FKFHFK.ROHMQHXFLOHQLHEG]LHSROHJDáRQDRSLVDQLXSRMHG\QF]HMNVL*NLU]HF]

MDVQD QDOH*\ SRPLQü LQIRUPDFMH PDMFH PDáH ]QDF]HQLH GOD X*\WNRZQLND MDN QS

OLF]EDVWURQ3RSU]\MU]HQLXVLOLFLH*\F]HPR*QDVWZLHUG]Lü*HZVNáDGRSLVXSRMH-

G\QF]HMNVL*NLSRZLQQ\ZFKRG]LüQDVWSXMFHLQIRUPDFMH

•

W\WXáFLJ]QDNyZ

•

QD]ZLVNRDXWRUDFLJ]QDNyZ

•

QD]ZLVNRRVRE\NWyUDNVL*NZ\SR*\F]\áDFLJ]QDNyZ

•

OLF]QLNZ\SR*\F]HOLF]EDFDáNRZLWD

,WXSLHUZV]\SUREOHPMDNUHSUH]HQWXMHVLZSURJUDPLHFLJ]QDNyZ":7XUER3DVFDOX

VáX*\ GR WHJR FHOX VSHFMDOQ\ W\S áDFXFKRZ\, z angielska

string

. Zmienna typu

áDFXFKRZHJRPR*HSU]HFKRZ\ZDüFLJRGáXJRFLGR]QDNyZLGHNODURZDQDMHVW
np. tak:

tytul : string;

Aby nie

QDUXV]DüFLJáRFLWHJRUR]G]LDáXGRNáDGQLHMV]\RSLVZáDFLZRFLLPR*OLZRFL

W\SX áDFXFKRZHJR SU]HQLHVLHP\ QLHFR GDOHM ]REDF] UR]G]LDá àDFXFK\ na stronie

QDUD]LH]DZUyFLP\GRELEOLRWHNL6NRURPDP\MX*GRG\VSR]\FMLZáDFLZHW\S\

PR*HP\]DGHNODURZDüZSURJUDPLH]PLHQQHRSLVXMFHNVL*N

var
tytul, autor, wypozyczajacy : string;
l_wypozyczen : integer;

1LHVWHW\ELEOLRWHND]DZLHUD]QDF]QLHZLFHMQL*MHGQNVL*N5]HF]MDVQDGHNODURwa-

QLHGODND*GHMSR]\FMLRGG]LHOQ\FK]PLHQQ\FKW\SX

Tytul1

Tytul2

MHVWFDáNRZLFLH

EH] VHQVX Z\PDJDáRE\ ERZLHP XWZRU]HQLD RJURPQHM OLF]E\ ]PLHQQ\FK SRPLMDMF

IDNW*HQLH]DZV]HZLDGRPR]LORPDRELHNWDPLEG]LHP\PLHOLGRF]\QLHQLD3UREOHP

WHQ ]RVWDá MHGQDN MX* GDZQR UR]ZL]DQ\ DE\ PyF REVáX*\ü Z SURJUDPLH GX*OLF]E

MHGQDNRZ\FKSRGZ]JOGHPVWUXNWXU\RELHNWyZPXVLV]Z\NRU]\VWDütablice.

7DNRWRSU]HFKRG]LP\GREDUG]RZD*QHJR]DJDGQLHQLDMDNLPVW\S\VWUXNWXUDOQH

7\S\VWUXNWXUDOQHF]\OLMDNSU]HFKRZDüZLFHMGDQ\FK

Typy strukturalne,

F]\OLMDNSU]HFKRZDü

ZLFHMGDQ\FK

=SXQNWXZLG]HQLDX*\WNRZQLNDWDEOLFDMHVWSRSURVWXFLJLHPMHGQROLW\FKÄV]XIODGHN´

SU]HFKRZXMF\FKWRZD*QHGDQHWHJRVDPHJRW\SX.D*GDV]XIODGNDNWyUZQDV]\P

SU]\SDGNX PR*QD ] JUXEV]D XWR*VDPLDü ] NDUW NDWDORJRZ MHVW LGHQW\ILNRZDQD
numerem — tzw. indeksem —

NWyU\ PXVL E\ü W\SX SRU]GNRZHJR WUXGQR ERZLHP

Z\REUD]LüVRELHHOHPHQWWDEOLF\RQXPHU]HSyáWRUD7DEOLFHGHNODURZDQHV]DSRPRF

VáRZDNOXF]RZHJR

array

WDEOLFD]DVNáDGQLDGHNODUDFMLMHVWQDVWSXMFD

nazwa_tablicy : array[indeks_dolny..indeks_górny] of typ;

:QDZLDVDFKNZDGUDWRZ\FKF]\QLHNRMDU]&LVL]WDEOLF"PXVLV]XPLHFLüGZLH

VWDáH RNUHODMFH QDMPQLHMV]\ L QDMZLNV]\ GRSXV]F]DOQ\ LQGHNV WDEOLF\ 3DPLWDM *H

ZDUWRFL X*\WH Z GHNODUDFML PXV] E\ü ]QDQH Z PRPHQFLH NRPSLODFML SURJUDPX

QDMF]FLHM SRGDZDQH V MDZQLH HZHQWXDOQLH Z SRVWDFL SURVW\FK Z\UD*H GRSXV]-

F]DOQ\FKZGHILQLFMDFKVWDá\FK3DVFDOZ\PDJDRNUHOHQLDUR]PLDUXWDEOLF\ZFKZLOL

NRPSLODFMLLQLHGRSXV]F]DX*\FLDW]ZWDEOLFG\QDPLF]Q\FKRUR]PLDU]HRNUHODQ\P
podczas wykonania) znan

\FK]%DVLFD2EDLQGHNV\PRJPLHüGRZROQHZDUWRFLDOH

PXV]E\üWHJRVDPHJRW\SXSRU]GNRZHJRDJyUQ\LQGHNVQLHPR*HE\üPQLHMV]\RG

GROQHJR=Z\NOHWDEOLFHLQGHNVXMHVLRGMDNQSWDEOLFDXWRUyZNVL*HN

var
Autorzy : array[1..1000] of string[30];

DOHFDáNRZLFLHOHJDOQHVUyZQLH*GHNODUDFMH

var
Sinusy : array[0..359] of real;
Odchylka : array[–10..10] of real;

78 Turbo

Pascal

—

programowanie

1LH GRü WHJR WDEOLFH ZFDOH QLH PXV] E\ü LQGHNVRZDQH OLF]EDPL -HOL QS FKFHV]

]OLF]\ü F]VWRü Z\VWSRZDQLD Z WHNFLH SRV]F]HJyOQ\FK ]QDNyZ DOIDEHWX PR*HV]

X*\üHIHNWRZQHMNRQVWUXNFML

var

Liczniki : array['a'..'z'] of word;

.D*G\]HOHPHQWyZWDNLHMWDEOLF\MHVWOLF]QLNLHPRSRMHPQRFLRNRáRW\VLF\ÄLPSXO-

VyZ´DGUHVRZDQ\P]DSRPRFRGSRZLHGQLHJR]QDNXDOIDEHWX

$E\RGZRáDüVLGRHOHPHQWXWDEOLF\RGDQ\PQXPHU]HPXVLV]X*\üVNáDGQL

nazwa_tablicy[indeks]

gdzie

indeks

MHVWQXPHUHP*GDQHJRHOHPHQWXVWDáOXE]PLHQQW\SXSRU]GNRZHJR

R ZDUWRFL ]DZDUWHM SRPLG]\ GROQ\P D JyUQ\P ]DGHNODURZDQ\P LQGHNVHP $E\

]DWHPZ\ZLHWOLüWU]HFL]NROHLSR]\FMWDEOLF\DXWRUyZZ\VWDUF]\X*\üLQVWUXNFML

writeln(Autorzy[3]);

]DLQVWUXNFMD

Autorzy[5] := 'Ernest Hemingway';

XVWDOLQD]ZLVNRDXWRUDSLWHMNVL*NLZNDWDORJX:SU]\SDGNXQDV]HMWDEOLF\OLF]QLNyZ

]QDNyZRGZRáDQLDEGZ\JOGDá\QDVWSXMFR

,QF/LF]QLNL>]QDN@^]ZLNV]\OLF]QLNGOD]QDNXR`

ZULWHOQ/LF]QLNL>D@^Z\ZLHWOLZDUWRü`

{ licznika znaków 'a' }

3UyED X*\FLD LQGHNVX OH*FHJR SR]D ]DGHNODURZDQ\P ]DNUHVHP NRF]\ VL QD RJyá

EáGHPZ\NRQania, o ile opcja kontroli zakresów (Options-Compiler-Range checking)

QLH]RVWDáDZ\áF]RQDuwagaGRP\OQLHRSFMDWDMHVWZ\áF]RQD:W\PRVWDWQLP

SU]\SDGNXRGF]\W]WDEOLF\]ZUyFLEH]VHQVRZQZDUWRü]D]DSLVPR*HPLHüVNXWNL

RSáDNDQH ] ]DZLHV]HQLHP NRPSXWHUD ZáF]QLH JG\* ZDUWRü ]RVWDQLH ZVWDZLRQD
w

PLHMVFHSU]H]QDF]RQHQDFR]XSHáQLHLQQHJR

'ZD JáyZQH REV]DU\ ]DVWRVRZDQLD WDEOLF WR ED]\ GDQ\FK F]\OL SURJUDP\ VáX*FH GR

SU]HFKRZ\ZDQLD L ]DU]G]DQLD LQIRUPDFM RSLVXMF U]HF]\ZLVWH RELHNW\ QS NVL*NL
w

ELEOLRWHFH WRZDU\ Z KXUWRZQL LWS RUD] RSURJUDPRZDQLH LQ*\QLHUVNLH L QDXNRZH

Z\NRU]\VWXMFHW]ZZHNWRU\LPDFLHU]HF]\OLOLQLRZHLSURVWRNWQHWDEOLFHOLF]E-DN

]DSLVDüZHNWRUF]\OLOLQLRZOXEMHGQRZ\PLDURZWDEOLFOLF]EMX*ZLHV]3U]\NáDGR-

ZHPXZHNWRURZL]áR*RQHPX]G]LHVLFLXOLF]EU]HF]\ZLVW\FK

[

]

...

EG]LHRGSRZLDGDáDWDEOLFD

Wektor : array[1..10] of real

]DGODSURVWRNWQHMWDEOLF\PDFLHU]\RZ\PLDUDFKm na n:

7\S\VWUXNWXUDOQHF]\OLMDNSU]HFKRZDüZLFHMGDQ\FK

...
...
...

...













X*\MHP\GHNODUDFML

Macierz : array[1..M, 1..N] of real

-DN ZLGDü WZRU]HQLH WDEOLF RGSRZLDGDMF\FK GZX- L ZLFHMZ\PLDURZ\P VWUXNWXURP

GDQ\FK QLH VWDQRZL Z 3DVFDOX WUXGQHJR ]DGDQLD 2JyOQD VNáDGQLD GHNODUDFML WDEOLF\

ZLHORZ\PLDURZHMZ\JOGDWDN

nazwa_tablicy : array[zakres_1, zakres_2, ... zakres_n] of typ

gdzie

zakres_k

opisuje zakres indeksów dla k-

WHJR Z\PLDUX L PD IRUP

SRF]-

tek..koniec

. Dla tablic dwuwymiarowych pierwszy indeks oznacza numer wiersza,

]DGUXJL—QXPHUNROXPQ\ZSDPLFLNRPSXWHUDGDQHSU]HFKRZ\ZDQHVZLHUVzami

XáR*RQ\PLMHGHQ]DGUXJLP&KRFLD*3DVFDOQLHQDU]XFDRJUDQLF]HQLDQDOLF]EZ\PLD-

UyZWDEOLF\MHG\Q\PLRJUDQLF]HQLDPLVáF]Q\UR]PLDUHOHPHQWyZQLHPRJF\SU]HN-

UDF]DüEDMWyZRUD]]DNUHVLQGHNVyZQLHPRJF\Z\NUDF]DüSR]D]DNUHVOLF]E

FDáNRZLW\FK WDEOLF ZLFHM QL* GZXZ\PLDURZ\FK X*\ZD VL EDUG]R U]DGNR 7DEOLFH

GZXZ\PLDURZH VWRVRZDQH V SU]HGH ZV]\VWNLP Z SURJUDPDFK REOLF]HQLRZ\FK

UHDOL]XMF\FK REOLF]HQLD W]Z UDFKXQNX PDFLHU]RZHJR L QLH EG]LHP\ VL WX QLPL

V]F]HJyáRZR]DMPRZDü$E\MHGQDNQLHSRSU]HVWDZDüQDVDP\PRSLVLH]DGHPRQVWUXM-

P\NUyWNLSU]\NáDGRWRSURJUDPSR]ZDODMF\QDZSURZDG]HQLH]NODZLDWXU\ZDUWRFL

HOHPHQWyZ PDFLHU]\ R Z\PLDUDFK QD L Z\ZLHWODMF\ QDMZLNV]\ ZSURZDG]RQ\

HOHPHQWRUD]VXPZV]\VWNLFKHOHPHQWyZOH*F\FKQDSU]HNWQHMLSRZ\*HMQLHM

program Macierz3x3;
{ program demonstruje elementarne obliczenia macierzowe }
var
t : array[1..3, 1..3] of real; { macierz 3x3 }
max, sum : real; { tymczasowe maksimum i suma elementów }
i, j : integer; { liczniki wierszy i kolumn }

begin

^ZF]\WDQLH]DZDUWRFLPDFLHU]\`

  for i := 1 to 3 do
  for j := 1 to 3 do
  begin
write('Podaj element macierzy x[',i,',',j,']: ');
readln(t[i,j]);
  end;
{ wyszukanie maksymalnego elementu }
max := -

H^SDPLWDMRLQLFMDOL]DFMLPDNVLPXP`

  for i := 1 to 3 do
  for j := 1 to 3 do
  if t[i,j] > max then max := t[i,j];

^REOLF]HQLHVXP\HOHPHQWyZQDLQDGSU]HNWQ`

VXP ^SDPLWDMRZ\]HURZDQLXVXP\SU]HGREOLF]DQLHP`

for i := 1 to 3 do

80 Turbo

Pascal

—

programowanie

for j := i to 3 do
sum := sum+t[i,j];
writeln('Najwiekszy element: ', max:8:3);
writeln('Suma elementow na i nad przekatna: ', sum:8:3);
readln;
end.

-DN QLHWUXGQR VL GRP\OLü REVáXJD WDEOLF QLH W\ONR GZXZ\PLDURZ\FK Z\PDJD

LQWHQV\ZQHJRX*\FLDSWOL

for

QDRJyáÄSU]HFKRG]LP\´NROHMQRSRHOHPHQWDFKZLHUV]D

OXE NROXPQ\ ]QDMF QXPHU SLHUZV]HJR L RVWDWQLHJR HOHPHQWX 3RZ\*V]\ SURJUDP
demonstruje dwie typowe operacje na tablicach:

•

wyszukanie maksymalnego (minimalnego) elementu

SROHJDMFH QD

VSUDZG]DQLX F]\ NROHMQ\ HOHPHQW QLH MHVW ZLNV]\ PQLHMV]\ RG DNWXDOQHM

ZDUWRFL PDNVLPXP PLQLPXP D MHOL WDN — SU]\MFLH MHJR ZDUWRFL MDNR
nowego maksimum (minimum);

•

REOLF]HQLHZDUWRFLVXP\HOHPHQWyZQDLSRQDGSU]HNWQZ]EOL*RQ\VSRVyE

REOLF]DVLVXPHOHPHQWyZSRGSU]HNWQVXPZV]\VWNLFKHOHPHQWyZGRGDW-
nich itp.).

=DXZD**HZWUDNFLHREOLF]HQDOH*\SU]HV]XNLZDü]DUyZQRZLHUV]HMDNLNROXPQ\FR

UHDOL]RZDQH MHVW ]D SRPRF GZyFK ]DJQLH*G*RQ\FK XPLHV]F]RQ\FK MHGQD Z GUXJiej)

SWOL

for

=DJQLH*G*DMF SWOH PXVLV] SDPLWDü E\ X*\ZDá\ RQH Uy*Q\FK OLF]QLNyZ,

SU]HFLZQ\P SU]\SDGNX ERZLHP ZHZQWU]QD SWOD EG]LH Z QLH]DPLHU]RQ\ VSRVyE

PRG\ILNRZDáDOLF]QLNSWOL]HZQWU]QHMEáGWHQMHVWW\OH*SRVSROLW\FRQLHSU]\MHPQ\

=DXZD*SRQDGWR*HZHZQWU]QDSWODUR]SRF]\QDVLQLHRGMHG\QNLOHF]RGELH*FHJR

LQGHNVX SWOL ]HZQWU]QHM G]LNL F]HPX RG UD]X RPLMDP\ HOHPHQW\ OH*FH SRG SU]H-

NWQPDMFHQXPHUZLHUV]DZLNV]\RGQXPHUXNROXPQ\

0DMF GR G\VSR]\FML WDEOLFH PR*HP\ MX* ]DSURMHNWRZDü VWUXNWXU\ GDQ\FK RSLVXMFH

]DZDUWRü NDWDORJX ELEOLRWHF]QHJR 'OD XSURV]F]HQLD ]Dáy*P\ *H ZV]\VWNLH GDQH

EG]LHP\SU]HFKRZ\ZDOLZSDPLFLNRPSXWHUD3RQLHZD*PDRQDRJUDQLF]RQSRMHP-

QRüZDUWRRGUD]XSU]\MüSHZQH]DáR*HQLDFRGRPDNV\PDOQHMSRMHPQRFLNDWDORJX
i

SRV]F]HJyOQ\FKIUDJPHQWyZRSLVXNVL*NL'RüRF]\ZLVW\PSRGHMFLHPEG]LHRJra-

QLF]HQLH GáXJRFL SyO SU]H]QDF]RQ\FK QD W\WXá L QD]ZLVNR DXWRUD RUD] RVRE\ Z\SR-

*\F]DMFHM1LHFKRSLVSRMHG\QF]HMNVL*NLZ\JOGDWDN

•

W\WXá

string[30]

;

•

nazwisko autora:

string[25]

;

•

QD]ZLVNRZ\SR*\F]DMFHJR

string[25]

;

•

OLF]QLNZ\SR*\F]H

word

:V]\VWNLHSRODáF]QLH]DMPXMEDMWyZWDNZLF]DNáDGDMF*HPDP\GRG\VSR]\FML

N%FRWU]HEDMHV]F]H]RVWDZLüQDSRPRFQLF]H]PLHQQHMHVWHP\ZVWDQLHRSLVDü

RNRáR SR]\FML 6NG MHGQDN Z]Lá\ VL WH NLOREDMW\ SU]HFLH* Z NRPSXWHU]H

SDPLFL MHVW ]QDF]QLH ZLFHM — PyJáE\ ]DS\WDü 7R SUDZGD MHGQDN DE\ VL GR QLHM

7\S\VWUXNWXUDOQHF]\OLMDNSU]HFKRZDüZLFHMGDQ\FK

GRVWDü SRWU]HEQH V QLHFR EDUG]LHM Z\P\OQH UR]ZL]DQLD NWyUH ]RVWDQ RPyZLRQH
w rozdziale pt.

:LFHMSDPLFL (strona 114).

:\JOGDáRE\QDWR*HPR*QD]DNDVDüUNDZ\LZ]LüVLGRURERW\F]\OL]DGHNODURZDü

QDVWSXMFHWDEOLFH

var

Tytul : array[1..750] of string[30];
Autor : array[1..750] of string[25];
Wypozyczajacy : array[1..750] of string[25];
Licznik : array[1..750] of word;

=DXZD*MHGQDN*HRSLVSRMHG\QF]HMNVL*NLUR]SURV]RQ\MHVWZF]WHUHFKUy*Q\FKWDE-

OLFDFK&RSUDZGDSRV]F]HJyOQHHOHPHQW\RSLVXVÄ]MHGQRF]RQH´ZVSyOQ\PQXPHUHP
(indeksem), jednak z punktu wi

G]HQLD ORJLNL UR]ZL]DQLH WDNLH MHVW QLHVSyMQH L PDáR

HOHJDQFNLHFKRFLD*GDVLZ\NRU]\VWDü5R]SURV]HQLHGDQ\FKRSLVXMF\FKSRMHG\QF]\

RELHNW Z IL]\F]QLH RGUEQ\FK VWUXNWXUDFK GDQ\FK PD WH* W ZDG *H áDWZLHM MHVW

SU]HRF]\ü MDNL IUDJPHQW LQIRUPDFML OXE SRP\OLü QXPHUDFM -DN WHPX ]DUDG]Lü"

3U]\MU]\MP\VLQDV]HMNDUFLHNDWDORJRZHM

7\WXá Emigranci
Autor

0UR*HN6áDZRPLU

:\SR*\F]DMF\

Nowak Krzysztof

Licznik 78

:V]\VWNLH GDQH RSLVXMFH IL]\F]Q\ RELHNW V WX SRáF]RQH Z MHGQ ORJLF]QLH VSyMQ

FDáRüVWDQRZLF]QDF]QLHEDUG]LHMSU]HNRQXMF\LVHQVRZQ\RSLVDQL*HOLSRSU]HGQLR

Z\REUD( VRELH MDN XFLHV]\áE\ VL ELEOLRWHNDU] JG\E\ ND]DQR PX SRVáXJLZDü VL

RGUEQ\PL NDWDORJDPL ]DZLHUDMF\PL W\WXá\ QD]ZLVND LWG 3DVFDORZ\P
odpowiednikiem takiego opisu jest rekord.

2LOHWDEOLFHSR]ZDODá\QDSRPLHV]F]HQLHZMHGQHMVWUXNWXU]HZLHOXGDQ\FKWHJRVDPHJR

W\SXUHNRUG\XPR*OLZLDM]DPNQLFLHZFDáRüGDQ\FKUy*Q\FKW\SyZQLHSR]ZDODMF

]NROHLQDLQGHNVRZDQ\GRQLFKGRVWS6NáDGQLDGHNODUDFML]PLHQQHMW\SXrekordowego

MHVWQDVWSXMFD

nazwa : record
pole-1 : typ-1;
pole-2 : typ-2;
...
pole-n : typ-n;
end;

gdzie

pola

VSRSURVWXQD]ZDPLHOHPHQWyZSyOUHNRUGX]DZLHUDMF\FKSRV]F]HJyOQH

GDQH ]D

typy

RNUHODM LFK W\S 3U]\NáDGRZ\ UHNRUG RGSRZLDGDMF\ QDV]HM NDUFLH

NDWDORJRZHMQDOH*DáRE\]DGHNODURZDüWDN

var
Ksiazka : record

82 Turbo

Pascal

—

programowanie

Tytul : string[30];
Autor : string[25];
Wypozyczajacy : string[25];
Licznik : word
end;

5]HF]MDVQDSRZ\*V]DGHNODUDFMDQLHUR]ZL]XMHQDV]HJRSUREOHPu, pozwala bowiem

QD RSLVDQLH W\ONR MHGQHM NVL*NL 'ODF]HJR MHGQDN QLH ]RUJDQL]RZDü UHNRUGyZ Z

WDEOLFH"2WRSU]\NáDG

var
Katalog : array[1..750] of record
Tytul : string[30];
Autor : string[25];
Wypozyczajacy : string[25];
Licznik : word
end;

3U]HGVWDZLRQDSRZ\*HMVWUXNWXUDGDQ\FKMHVWWDEOLFUHNRUGyZLVWDQRZLQLHXZ]JOG-

QLDMF NLONX GUREQ\FK SRSUDZHN RVWDWHF]Q IRUP MDN EG]LHP\ VL SRVáXJLZDü
w naszym programie. Podobnie, jak szuflada katalogu zawiera wiele jednakowych kart
o

SLVXMF\FKSRMHG\QF]HNVL*NLWDNLQDV]DWDEOLFD]DZLHUDZLHOHMHGQDNRZ\FKUHNRU-

GyZVWDQRZLF\FKHOHNWURQLF]QIRUPWDNLHJRRSLVX7DEOLFHUHNRUGyZVWDQRZLMHGQ

] F]FLHM Z\NRU]\VW\ZDQ\FK VWUXNWXU GDQ\FK XPR*OLZLDMF\FK HIHNW\ZQH WZRU]HQLH
baz dany

FKLSU]HFKRZ\ZDQLHLQIRUPDFMLRSLVXMFHMZLHOHMHGQDNRZ\FKRELHNWyZ

-DN]DSDPLW\ZDüLRGF]\W\ZDüLQIRUPDFM]UHNRUGX"=DXZD**HND*G\HOHPHQWRSLVX

LGHQW\ILNRZDQ\ MHVW GZLHPD QD]ZDPL QD]Z VDPHJR UHNRUGX

Katalog[..]

) oraz

odpowiedniego pola (np.

Tytul

$E\ RGZRáDü VL GR NRQNUHWQHJR SROD UHNRUGX

PXVLV]SRGDüRE\GZLHQD]Z\UR]G]LHODMFMHNURSN

nazwa-rekordu.nazwa-pola

&KFF ZLF ZVWDZLü GR UHNRUGX QXPHU QD]ZLVNR DXWRUD NVL*NL Z\NRU]\VWDP\

LQVWUXNFM

Katalog[45].Autor := 'Mrozek Slawomir';

LQVWUXNFMD

writeln(Katalog[29].Wypozyczajacy);

SRLQIRUPXMH QDV Z F]\LP SRVLDGDQLX ]QDMGXMH VL REHFQLH NVL*ND RSLVDQD UHNRUGHP
numer 29.

Typy strukturalne, czyli jak przechowac wiecej danych

:SU]\SDGNXZ\NRQ\ZDQLDNLONXRSHUDFMLQDSRODFKWHJRVDPHJRUHNRUGXX*\ZDQLH]D

ND*G\PUD]HPQRWDFMLÄ]NURSN´MHVWQLHFRXFL*OLZH3DVFDOXPR*OLZLDXSURV]F]HQLH

RGZRáDGRSyOUHNRUGXSU]H]Z\NRU]\VWDQLHW]ZLQVWUXNFMLZL*FHM

with

with Katalog[120] do
begin
Tytul := 'Paragraf 22';
Autor := 'Heller Joseph';
Wypozyczajacy := 'Yossarian John';
Licznik := 1254;
end;

,QVWUXNFMDZL*FDZ\GDWQLHXSUDV]F]D]DGDQLDSRGREQHGRSRND]DQHJRZ\*HMPXVLV]

MHGQDN SDPLWDü R XMFLX ZV]\VWNLFK LQVWUXNFML RSHUXMF\FK QD SRODFK UHNRUGX Z LQ-

VWUXNFM ]áR*RQ

begin end

Z SU]HFLZQ\P SU]\SDGNX RSHUDFMD EG]LH GRW\F]\áD

W\ONRSLHUZV]HJRSRODDSUyEDVNRPSLORZDQLDNROHMQ\FKLQVWUXNFMLQDMSHZQLHMVNRF]\

VLEáGHP:]DPLDQ]DWRPR*HV]Z\NRU]\VWDüLQVWUXNFM

with

do operowania na

NLONXUHNRUGDFKQDUD]-HOLQS]DGHNODURZDáHQDVWSXMFHVWUXNWXU\

DaneKlienta : array[1..1000] of record
nazwisko : string[30]; { nazwisko klienta }
SumaZakupow : real; { suma zakupów w danym roku }

6DOGRUHDO^ELH*FHVDOGRNOLHQWD`

end;
Zakup : array[1..1000] of record
IdKlienta : integer; { identyfikator klienta }
IdTowaru : integer; { identyfikator towaru }

1DOH]QRVFUHDO^QDOH*QRü]DWRZDU`

end;

to operacja

for i := 1 to LiczbaZakupow do
with DaneKlienta[50], Zakup[i] do
  if IdKlienta = 50 then
  begin
SumaZakupow := SumaZakupow + Naleznosc;
Saldo := Saldo – Naleznosc;
  end;

VSRZRGXMHSU]HV]XNDQLHWDEOLF\]DNXSyZLXVWDOHQLHVXP\MDNNOLHQWQXPHU]DSáD-

FLá]DZV]\VWNLHVZRMH]DNXS\RUD]SRPQLHMV]HQLHMHJRVDOGDRWVXP=DXZD**HRSLV
klienta nie zawiera pola identyfikatora, któ

U\ ]DVWSLRQ\ ]RVWDá LQGHNVHP Z WDEOLF\

rekordów.

$E\ VNRSLRZDü ZV]\VWNLH SROD UHNRUGX GR LQQHJR UHNRUGX WHJR VDPHJR W\SX QLH

PXVLV]ZRJyOHX*\ZDüRGZRáD]NURSNDQLLQVWUXNFML

with

7XUER3DVFDOXPR*OLZLD

FDáRciowe kopiowanie rekordów, np.

DaneKlienta[132] := DaneKlienta[1];

84 Turbo

Pascal

—

programowanie

1LHVWHW\RSHUDFMLWHJRW\SXQLHGDVLX*\üGRZSURZDG]HQLD]DZDUWRFLUHNRUGX]NOD-

ZLDWXU\DQLZ\SURZDG]HQLDMHMQDHNUDQ2SHUDFMHWHQDOH*\Z\NRQ\ZDüÄSROHSRSROX´

X*\WHF]QDMHVWWXLQVWUXNFMD

with

MDNZSRQL*V]\PSU]\NáDG]LH

writeln('Pozycja w katalogu: ', i);
with Katalog[i] do
begin

ZULWHOQ7\WXO7\WXO^Z\SLV]]DZDUWRü`

{ odpowiednich pól }
writeln('Autor: ', Autor);
writeln('Wypozyczajacy: ', Wypozyczajacy);
end;

:DQDORJLF]Q\VSRVyEPR*QDZSURZDG]DüGDQHGRUHNRUGX

:WHQVSRVyESU]HGVWDZLOLP\GZDQDMSRSXODUQLHMV]HW\S\VWUXNWXUDOQHGRVWSQHZ3DV-

FDOXL]DSURMHNWRZDOLP\SRGVWDZRZVWUXNWXUVáX*FGRSU]HFKRZ\ZDQLDLQIRUPDFML
w naszym programie. W kolejnych roz

G]LDáDFK]DMPLHP\VLPHWRGDPLSU]HWZDU]DQLD

LQIRUPDFMLF]\OLDOJRU\WPDPLLLFKUHDOL]DFMZSRVWDFLSURFHGXULIXQNFMLRUD]Z\QL-

NDMF\PL]W\FK]DJDGQLHSUREOHPDPL

=DSDPLWDM

•

'RSU]HFKRZ\ZDQLDZLNV]\FKLORFLGDQ\FKVáX*W\S\VWUXNWXUDOQH

•

'ZDQDMZD*QLHMV]HW\S\VWUXNWXUDOQHZ3DVFDOXWRWDEOLFHLUHNRUG\

•

7DEOLFHSR]ZDODMQDJUXSRZDQLHGDQ\FKWHJRVDPHJRW\SX=DZDUWHZWDEOLF\

GDQHVGRVWSQHSRSU]H]LQGHNV\

•

7DEOLFH PRJ E\ü MHGQR- lub wielowymiarowe. Zakres indeksów tablicy jest
dowolny, ale n

LHPR*HSU]HNUDF]Dü]DNUHVXGR]ZRORQHJRGODOLF]EFDáNRZLW\FK

•

'RREVáXJLWDEOLFZ\NRU]\VWXMHVLF]VWRSWOH

for

•

5HNRUG\ JUXSXM GDQH Uy*Q\FK W\SyZ =DZDUWH Z UHNRUG]LH GDQH V GRVWSQH
poprzez nazwy pól.

Struktura

programu

Struktura programu

:LHP\ MX* Z MDNLHM IRUPLH EG]LHP\ SU]HFKRZ\ZDü LQIRUPDFM NROHMQ\P NURNLHP

MHVW XVWDOHQLH VSRVREX MHM SU]HWZDU]DQLD RGSRZLHGQLHJR GR X*\ZDQ\FK Z SURJUDPLH

VWUXNWXU GDQ\FK 3U]HGH ZV]\VWNLP PXVLP\ ]DWHP XVWDOLü MDNLH RSHUDFMH QD GDQ\FK

SURJUDPSRZLQLHQZ\NRQ\ZDüDQDVWSQLH]DSURMHNWRZDüRGSRZLDGDMFHLPSURFHGXU\

OXE IXQNFMH MDNR *H SURJUDPXMHP\ SRU]GQLH F]\OL VWUXNWXUDOQLH — Z\NRU]\VWXMF

SURFHGXU\ L IXQNFMH 3R VNRQVXOWRZDQLX VL ] OLVW *\F]H ]REDF] VWURQD

VWZLHUG]DP\*HQDV]SURJUDPSRZLQLHQXPR*OLZLDü

•

ZSURZDG]HQLH]DZDUWRFLZ\EUDQHJRUHNRUGX]NODZLDWXU\

•

Z\SURZDG]HQLH]DZDUWRFLZ\EUDQHJRUHNRUGXQDHNUDQ

•

]EDGDQLHL]PLDQ]DZDUWRFLSROD

Wypozyczajacy

wybranego rekordu;

•

Z\V]XNDQLHUHNRUGX]DZLHUDMFHJR]DGDQ\FLJ]QDNyZZSROX

Tytul

;

•

posortowanie tablicy reko

UGyZZHGáXJ]DGDQHJRNU\WHULXPW\WXáOXEQD]ZLVNR

autora);

•

Z\V]XNDQLHUHNRUGXRQDMPQLHMV]HMLQDMZLNV]HM]DZDUWRFLSROD

Licznik

3RZ\*V]D OLVWD PR*H ]RVWDü EH]SRUHGQLR SU]HWáXPDF]RQD QD ]HVWDZ SRGVWDZRZ\FK

SURFHGXUWZRU]F\FKSURJUDPU]HF]MDVQDWU]HEDEG]LHMHV]F]HGRU]XFLüNLONDSURFH-

GXUSRPRFQLF]\FKQRLRF]\ZLFLHF]üRSHUDF\MQ=IRUPDOQHJRSXQNWXZLG]HQLD

Z\PDJDQ\MHVWMHV]F]HVFKHPDWEORNRZ\OXESU]\QDMPQLHMVáRZQ\]DSLVDOJRU\WPXDE\

MHGQDN XQLNQü SU]HURVWX IRUP\ QDG WUHFL RJUDQLF]\P\ VL GR RJyOQHJR VFKHPDWX

G]LDáDQLDSURJUDPX
Z\ZLHWOPHQXGRVWSQ\FKRSHUDFML
Z]DOH*QRFLRGZ\EUDQHMRSFML

ZSURZDG(QRZ\UHNRUGGRGDQLHNVL*NLGRNDWDORJXOXE
]PLH]DZDUWRüSROD

Wypozyczajacy

Z\SR*\F]HQLHNVL*NLOXE

Z\V]XNDMUHNRUG]DZLHUDMF\GDQ\W\WXáZ\V]XNLZDQLHNVL*NLOXE

86 Turbo

Pascal

—

programowanie

Z\ZLHWOZV]\VWNLHUHNRUG\XSRU]GNRZDQHZHGáXJW\WXáyZOXEQD]ZLVNDXWRUyZ
lub
]DNRF]SUDFSURJUDPX

ZUyüGRSXQNWX

-DNZLGDüF]üRSHUDF\MQDVSURZDG]DVLZ]DVDG]LHGRZ\ZRá\ZDQLDRGSRZiednich

SURFHGXU VWRVRZQLH GR Z\EUDQHM SU]H] X*\WNRZQLND IXQNFML GRVNRQDáH PLHMVFH GOD
instrukcji

case

3RQLHZD*SU]HGVWDZLDQLHVFKHPDWyZSRV]F]HJyOQ\FKSURFHGXU]DMáR-

E\]E\WGX*RPLHMVFDSRSU]HVWDQLHP\QD]DSUH]HQWRZDQLXLFK]DSLVXZ3DVFDOX0HWR-

GD NWyU Z\NRU]\VWDP\ GR WZRU]HQLD QDV]HJR SURJUDPX MHVW W\SRZ\P SU]\NáDGHP

SURMHNWRZDQLD ZVWSXMFHJR QDMSLHUZ XWZRU]\P\ ]HVWDZ RGSRZLHGQLFK SURFHGXU

UHDOL]XMF\FK SRV]F]HJyOQH ]DGDQLD SRGU]GQH D QDVWSQLH SRZL*HP\ MH Z FDáRü

F]\OLG]LDáDMF\SURJram.

=DQLP MHGQDN GR WHJR GRMG]LH ]DVWDQyZP\ VL SU]H] FKZLO QDG SU]HND]\ZDQLHP

GDQ\FKGRL]RGSRZLHGQLFKSURFHGXULIXQNFML:P\OGREUHMSUDNW\NLQLHEG]LHP\

GRWHJRFHOXZ\NRU]\VW\ZDüHIHNWyZXERF]Q\FKOHF]VWRVRZQLH]DSURMHNWRZDQHOLVW\

SDUDPHWUyZ 5R]ZD*P\ MDNR SU]\NáDG SURFHGXU ZSURZDG]DQLD ]DZDUWRFL UHNRUGX
z

NODZLDWXU\3RZLQQDRQDSU]\MPRZDüMDNRDUJXPHQWÄSXVW\´UHNRUGL]ZUDFDüWHQ*H

UHNRUGZ\SHáQLRQ\ZSLVDQ\PLSU]H]X*\WNRZQLNDGDQ\PL0XVLP\ZLFZ\NRU]\VWDü
mechanizm przekazywania para

PHWUX SU]H] QD]Z $OH MDN ]DGHNODURZDü VDP SDUD-

PHWU"1DJáyZHNZSRVWDFL

procedure Wprowadz(var r : record
Tytul : string[30];
Autor : string[25];
Wypozyczajacy : string[25];
Licznik : word);

Z\JOGDFRQDMPQLHMSRGHMU]DQLH,VWRWQLHSUyEDVNRPSLORZDQLDSRGREQHMNRQVWUXNFML

VNRF]\VLZ\ZLHWOHQLHPNRPXQLNDWX

Type identifier expected

(spodziewany

identyfikator typu).

5R]ZL]DQLHPWHJRSUREOHPX]DMPLHP\VLZQDVWSQ\PUR]G]LDOH=QDMG]LHVLZQLP

UyZQLH*NLONDVáyZRWDN]ZDQ\FKVWDá\FKV\PEROicznych.

7\S\LVWDáH

=DMPLHP\VLREHFQLHGZRPDVSRNUHZQLRQ\PL]HVRE]DJDGQLHQLDPLGHILQLRZDQLHP

ZáDVQ\FKW\SyZRUD]VWDá\PLV\PEROLF]Q\PL*áyZQ\REV]DU]DVWRVRZDVWDá\FKLW\-

SyZ ]ZL]DQ\ MHVW ] Z\NRU]\VWDQLHP W\SyZ VWUXNWXUDOQ\FK GODWHJR PyZLP\ R QLFK

ZáDQLH WHUD] Z\NRU]\VWDQLH GHILQLFML W\SyZ SR]ZDOD QD RPLQLFLH SHZQ\FK RJUD-

QLF]H Z SU]HND]\ZDQLX SDUDPHWUyZ ]REDF] NRQLHF SRSU]HGQLHJR UR]G]LDáX 3R]D

W\P X*\ZDQLH ZáDFLZLH GREUDQ\FK GHILQLFML W\SyZ L VWDá\FK SROHSV]D F]\WHOQRü L

HVWHW\NSURJUDPXRUD]]PQLHMV]DU\]\NREáGyZ

3RND]DQ\ QD NRFX SRSU]HGQLHJR UR]G]LDáX SU]\NáDG LOXVWUXMH QLH]UF]Q SUyE
przekazania do procedury parametru typu strukturalnego. Niestety, nasz zapis stanowi

SUyE SU]HP\FHQLD RSLVX GHILQLFML W\SX Z PLHMVFX GR WHJR QLH SU]H]QDF]RQ\P QD

OLFLH SDUDPHWUyZ IRUPDOQ\FK SURFHGXU\ OXE IXQNFML PRJ ]QDMGRZDü VL Z\áF]QLH

LGHQW\ILNDWRU\ SDUDPHWUyZ L RGSRZLDGDMFH LP identyfikatory (nie definicje!) typów.

'RSyNL SRVáXJLZDOLP\ VL SDUDPHWUDPL W\SX SURVWHJR SUREOHP QLH LVWQLDá JG\* QD

OLFLH SDUDPHWUyZ XPLHV]F]DáH SR SURVWX QD]Z RGSRZLHGQLHJR W\SX : SU]\SDGNX

W\SyZ VWUXNWXUDOQ\FK VSUDZD VL NRPSOLNXMH 1LH GRü *H QD OLFLH SDUDPHWUyZ QLH

ZROQRXPLHFLüGHILQLFMLW\SXMDNZLF]GHILQLRZDüSDUDPHWUVWUXNWXUDOQ\"WRMHV]F]H

LGHQW\F]QLHZ\JOGDMFHGHNODUDFMHWDEOLF

var
t1 : array[1..100] of real;
t2 : array[1..100] of real;

ZFDOHQLHWZRU]RELHNWyZLGHQW\F]QHJRW\SX—ND*GD]QLFKLQWHUSUHWRZDQDMHVWMDNR
definicja nowego typu, co utrudnia niektóre operacje (nie

PR*QDQSGRNRQDüSU]\SL-

VDQLDFDáHMWDEOLF\

1DGRELWNRND]XMHVL*H]JRGQRüW\SyZZ\PDJDQD

MHVWUyZQLH*ZSU]\SDGNXSU]HND]\ZDQLDSDUDPHWUyZFRE\áR]UHV]WáDWZHGRSU]HZL-
dzenia).

:\MFLHP ] WHJR LPSDVX MHVW ]GHILQLRZDQLH identyfikatora typu F]\OL QD]Z\ EGFHM

V\QRQLPHPGDQHJRW\SXVWUXNWXUDOQHJR,GHQW\ILNDWRUWDNLZ\NRU]\VWDP\QDVWSQLHGR

GHNODURZDQLD]PLHQQ\FKLSDUDPHWUyZGRNáDGQLHWDNVDPRMDNF]\QLOLE\P\WR]LGHQ-

W\ILNDWRUHP W\SX SURVWHJR $E\ ]GHILQLRZDü LGHQW\ILNDWRU W\SX PXVLV] X*\ü VáRZD
kluczowego

type

W\SZQDVWSXMFHMNRQVWUXNFML

type
nazwa-typu = opis-typu

88 Turbo

Pascal

—

programowanie

]ZUyüXZDJ*HZGHILQLFMLW\SXZ\NRU]\VWXMHVL]QDNUyZQRFLDQLHGZXNURSHN

Nazwa-typu

RNUHOD GHILQLRZDQ\ LGHQW\ILNDWRU L SRGOHJD ZV]\VWNLP UHJXáRP GRW\-

F]F\P LGHQW\ILNDWRUyZ ]D

opis-typu

jest takim samym opisem, jaki stosowany

MHVWZGHNODUDFMDFK]PLHQQ\FK5y*QLFDSROHJDW\ONRQDW\P*HZSU]\SDGNXGHNODUDFML

]PLHQQHMNRPSLODWRUWZRU]\RGSRZLHGQLVWUXNWXUGDQ\FKLUH]HUZXMHGODQLHMPLHMVFH
w

SDPLFL QDWRPLDVW ]GHILQLRZDQLH W\SX SRZRGXMH MHG\QLH XWZRU]HQLH V]DEORQX QLH

MHVW WZRU]RQ\ *DGHQ IL]\F]Q\ RELHNW NWyU\ EG]LH Z\NRU]\VW\ZDQ\ Z GHNODUDFMDFK

GRSLHURZWHG\NRPSLODWRUEG]LHUH]HUZRZDáPLHMVFHQDGDQH

3U]\NáDGRZDGHILQLFMDW\SXUHNRUGRZHJRRSLVXMFHJRNVL*NLGHNODUDFMDRGSRwied-

QLHMWDEOLF\UHNRUGyZEG]LHZLFPLDáDSRVWDü

type
Ksiazka = record { tak samo, jak w deklaracji zmiennej }
Tytul : string[30];
Autor : string[25];
Wypozyczajacy : string[25];
Licznik : word);
end;

var
Katalog : array[1..750] of Ksiazka;

-X*QDSLHUZV]\U]XWRNDZ\JOGDWRáDGQLHM

Katalog

zawiera

Ksiazki

DQLHMDNLH

UHNRUG\NWyU\FKSU]H]QDF]HQLDQDOH*\VLGRSLHURGRP\ODüQRDSR]DW\PPR*OLZH
jest wreszcie zadeklarowanie odpowiednich parametrów:

procedure Wprowadz(var r : Ksiazka);

'HILQLRZDQLHQRZ\FKLGHQW\ILNDWRUyZW\SyZPD]DVWRVRZDQLHJáyZQLHZSURJUDPDFK

SRVáXJXMF\FK VL VWUXNWXUDOQ\PL UHSUH]HQWDFMDPL GDQ\FK FKRFLD* PR*OLZH MHVW

UyZQLH* GHILQLRZDQLH QRZ\FK W\SyZ SURVW\ch (a nawet przedefiniowywanie typów
standar

GRZ\FK2WRSU]\NáDG

type

IORDW H[WHQGHG^UHDOMHOLQLHPDV]NRSURFHVRUD`

3RZ\*V]D GHILQLFMD WZRU]\ QRZ\ W\S ]PLHQQRSU]HFLQNRZ\

float

WR*VDP\ ] W\SHP

extended

GDMF\P QDMZLNV] PR*OLZ SUHF\]M L ]DNUHV ZDUWRFL -HOL SURJUDP

SU]H]QDF]RQ\MHVWGODNRPSXWHUDSR]EDZLRQHJRNRSURFHVRUDLQLHPDHPXORZDüWHJR
ostatniego), wystarczy w miejsce typu

extended

ZSLVDü

real

'HNODUXMFZV]\VWNLH

liczby rzeczywiste w programie jako

float

uzyskasz w ten sposób

PR*OLZRüáDWZHM

DGDSWDFMLSURJUDPXGRZDUXQNyZVSU]WRZ\FK

=DXZD**HZGHNODUDFML]PLHQQHM

Katalog

Z\PLDUWDEOLF\RNUHORQ\MHVWMDZQLHOLF]E

Z\QLND RQD ] SRG]LHOHQLD ZLHONRFL GRVWSQHM SDPLFL SU]H] ZLHONRü UHNRUGX

-HVW GRü SUDZGRSRGREQH *H GR ZDUWRFL WHM EG]LHV] VL Z SURJUDPLH RGZRá\ZDá

MHV]F]H NLONDNURWQLH FKRüE\ SRGF]DV SU]HV]XNLZDQLD NDWDORJX OXE XVXZDQLD MHJR

HOHPHQWyZ:\REUD(VRELHWHUD]*HSRVWDQRZLáHGRGDüGRUHNRUGXNUyWNLRSLVNVL*NL

ZSRVWDFLáDFXFKD]QDNyZ:Sá\QLHWRU]HF]MDVQDQDZLHONRüUHNRUGXD]DWHP
i

QD GRSXV]F]DOQ ZLHONRü WDEOLF\ NWyUD ]PDOHMH WHUD] GR RNRáR SR]\FML 3R

Typy i stale

GRNRQDQLX]PLDQ\EG]LHV]PXVLDáZ\V]XNDüZSURJUDPLHZV]\VWNLHPLHMVFDZNWy-

U\FK Z\VWSRZDáD OLF]ED L ]DVWSLü M OLF]E — MHOL R NWyU\P ]DSRPQLV]

NRQVHNZHQFMH PRJ E\ü QLH]E\W SU]\MHPQH GR ]DZLHV]HQLD NRPSXWHUD ZáF]QLH

'UXJLSUREOHP]ZL]DQ\]X*\FLHPOLF]E\OXESRMDZLDVLZNLONDPLHVLF\

SRQDSLVDQLXSURJUDPXLVSURZDG]DVLGRIDNWX*H]Z\NOHWUXGQRVRELHSU]\SRPQLHü
co to za 750 i dlaczego akurat tyle.

(OHJDQFNLP VSRVREHP QD SRUDG]HQLH VRELH ] RSLVDQ\P SUREOHPHP V VWDáH V\PER-
liczne

3RGREQLH MDN GHILQLFMD W\SX SR]ZDOD QD XWZRU]HQLH LGHQW\ILNDWRUD EGFHJR

synonimem definicji typu, tak definicj

D VWDáHM V\PEROLF]QHM XPR*OLZLD XWZRU]HQLH

LGHQW\ILNDWRUD EGFHJR V\QRQLPHP RNUHORQHM ZDUWRFL VWDáHM QLHNRQLHF]QLH OLF]-

ERZHM'RGHILQLRZDQLDVWDá\FKX*\ZDQHMHVWVáRZRNOXF]RZH

const

(ang. constant

—

VWDáD]DVNáDGQLDGHILQLFMLZ\JOGDQDVWSXMFo:

const
nawa-

VWDáHM ZDUWRü

.D*GHZ\VWSLHQLH

nazwy-

VWDáHM

ZSURJUDPLH]RVWDQLHSRGF]DVNRPSLODFML]DVWpio-

ZDUWRFL

3RGREQLHMDNZSU]\SDGNXW\SyZ]GHILQLRZDQLHVWDáHMQLHSRZRGXMH

]DUH]HUZRZDQLDPLHMVFDZSDPLFLZ]ZL]NX]W\PPXVLV]SDPLWDü*HVWDáDV\PER-
liczna nie jest l-

ZDUWRFLLQLHPR*HVLZSURJUDPLH]QDOH(üSROHZHMVWURQLHRSHUDWRUD

SU]\SLVDQLD DQL Z PLHMVFX SDUDPHWUX SU]HND]\ZDQHJR SU]H] QD]Z SRPLMDMF RF]\-

ZLVWKHUH]MMDNMHVWSUyED]PLDQ\ZDUWRFLVWDáHM

Definicja s

WDáHM RNUHODMFHM PDNV\PDOQ SRMHPQRü WDEOLF\ L VWRVRZQLH ]PRG\fiko-

ZDQDGHNODUDFMDWDEOLF\UHNRUGyZEG]LHZLFZ\JOGDáDQDVWSXMFR

const
POJEMNOSC_KATALOGU = 750;
var
Katalog : array[1..POJEMNOSC_KATALOGU] of Ksiazka;

=DXZD**HLGHQW\ILNDWRUVWDáHM]DSLVDQ\MHVWGX*\PLOLWHUDPLMHVWWRLVWRWQHW\ONRGOD
programisty —

7XUER3DVFDOQLHRGUy*QLDGX*\FKOLWHURGPDá\FK.RQZHQFMDWD—

SR]ZDODMFD áDWZR RGUy*QLü 67$à( od zmiennych MHVW GRü SRZV]HFKQLH VWRVRZDQD

SU]H]SURJUDPLVWyZLZDUWRMVRELHSU]\VZRLü

-HOL QLH FKFH &L VL SU]HOLF]Dü ZDUWRFL QDV]HM VWDáHM SR ND*GHM ]PLDQLH VWUXNWXU\

UHNRUGXF]HJR]GUXJLHMVWURQ\QLHSRZLQLHQHURELü]E\WF]VWRERGRZRG]LWR]áHJR

]DSURMHNWRZDQLDSURJUDPXPR*HV]X*\üQDVWSXMFHMGHILQLFML

const
MAX_PAMIEC = 63000; { maksymalna wielkosc katalogu }
{ w bajtach }
POJEMNOSC_KATALOGU = MAX_PAMIEC div SizeOf(Ksiazka);

-DNQLHWUXGQRVLGRP\OLüUD]]GHILQLRZDQHMVWDáHMPR*QDX*\üZNROHMQ\FKGHILnic-
jach. Co jednak znacznie ci

HNDZV]HVWDáDPR*H]RVWDü]GHILQLRZDQD]DSRPRFZ\UD-

*HQLD ]DZLHUDMFHJR LQQH VWDáH L QLHNWyUH RSHUDWRU\ Z\UD*HQLH PXVL GDü VL REOLF]\ü
w

WUDNFLH NRPSLODFML QLH PR*H ZLF ]DZLHUDü LGHQW\ILNDWRUyZ ]PLHQQ\FK L IXQNFML

90 Turbo

Pascal

—

programowanie

ELEOLRWHF]Q\FKGRNáDGQLHMV]HLQIRUPDFMHQDWHQWHPDW]QDMG]LHV]ZV\VWHPLHSRPRF\

:QDV]\PSU]\SDGNXZDUWRüVWDáHM]GHILQLRZDQDMHVWMDNRZ\QLNFDáNRZLW\SRG]LH-

OHQLD ZLHONRFL GRVWSQHM SDPLFL ]GHILQLRZDQHM LQQ VWDá SU]H] UR]PLDU UHNRUGX

RSLVXMFHJRNVL*N:W\PPRPHQFLHPR*HV]SU]HVWDüSU]HMPRZDüVLMDNLPLNROZLHN
liczbami.

6WRVRZDQLHVWDá\FKV\PEROLF]Q\FKLGHILQLFMLW\SyZVWDQRZLMHGQ]SRGVWDZ

GREUHMSUDNW\NLSURJUDPRZDQLD2GSRZLHGQLRX*\WHPHFKDQL]P\WH]QDF]QLH

SRSUDZLDMF]\WHOQRüSURJUDPXL]PQLHMV]DMMHJRSRGDWQRüQDEáG\
w trakcie pisania i poprawiania.

&R SUDZGD SU]HG FKZLO SRZLHG]LDQR *H VWDáD ]GHILQLRZDQD VáRZHP NOXF]RZ\P

const

nie jest l-

ZDUWRFLRND]XMHVLMHGQDN*HVáRZDWHJRPR*QDX*\üUyZQLH*GR

definiowania... zmiennych. Chodzi tu o tzw. zmienne z

ZDUWRFLSRF]WNRZ (zmienne

predefiniowane, ang. typed constant

=PLHQQDWDNDMHVWQRUPDOQ]PLHQQ—W\OH*H

X]\VNXMH ZDUWRü MX* Z PRPHQFLH GHNODUDFML GHILQLFML 6NáDGQLD GHILQLFML ]PLHQQHM
z

ZDUWRFLSRF]WNRZMHVWQDVWSXMFD

const
nazwa-

]PLHQQHMW\S ZDUWRü

SRF]WNRZD

=PLHQQHSUHGHILQLRZDQHSR]ZDODMQDáDWZHLQLFMDOL]RZDQLHGDQ\FKZSURJUDPLH2WR

SU]\NáDG\

const

/LF]EDBNVLD]HNZRUG ^QDSRF]WNX`

{ katalog jest pusty }
Liczniki : array[1..4] of word = (0, 0, 0, 0);
{ inicjalizacja tablicy }

:LDGRPRFLSU]HGVWDZLRQHZW\PUR]G]LDOHSRZLQQ\SR]ZROLüQDPQDQDSLVDQLHSRG-

VWDZRZHM ZHUVML QDV]HJR SURJUDPX 7\P MHGQDN ]DMPLHP\ VL MX* Z QDVWSQ\P
rozdziale.

=DSDPLWDM

•

'HNODURZDQLH SDUDPHWUyZ W\SX VWUXNWXUDOQHJR PR*OLZH MHVW Z\áF]QLH SU]\

X*\FLXLGHQW\ILNDWRUyZW\SyZ

•

'R]GHILQLRZDQLDLGHQW\ILNDWRUDW\SXX*\ZDQHMHVWVáRZRNOXF]RZH

type

•

'HILQLRZDQLH VWDá\FK V\PEROLF]Q\FK F]\OL LGHQW\ILNDWRUyZ SU]HFKRZXMF\FK

ZDUWRFLVWDáHXPR*OLZLDVáRZRNOXF]RZH

const

•

6áRZR

const

SR]ZDODUyZQLH*QDGHNODURZDQLH]PLHQQ\FKSRáF]RQH]QDGD-

ZDQLHPLPZDUWRFLSRF]WNRZ\FK

•

8*\ZDQLH GHILQLFML W\SyZ L VWDá\FK V\PEROLF]Q\FK SRSUDZLD F]\WHOQRü

SURJUDPXMHJRXQLZHUVDOQRüLRGSRUQRüQDEáG\

'RG]LHáD

3R W\P QLHFR SU]\GáXJLP WHRUHW\]RZDQLX ZLNV]Rü &]\WHOQLNyZ ]DSHZQH ZLHU]EL

MX*UFH*HE\Z]LüVLGRSURJUDPRZDQLD:QLQLHMV]\PUR]G]LDOHVSUyEXMHP\SU]HG-

VWDZLü SRGVWDZRZH HOHPHQW\ VNáDGRZH QDV]HJR SURJUDPX L SRZL]DüMHZG]LDáDMF

FDáRü =DF]QLHP\ RG U]HF]\ SRGVWDZRZ\FK F]\OL ]GHILQLRZDQLD VWUXNWXU GDQ\FK QD

NWyU\FKSURJUDPEG]LHRSHURZDá

program Biblioteka;

^3URVW\SURJUDPGRREVáXJLELEOLRWHNL`

uses

&UW^PRGXáREVáXJXMF\NODZLDWXULPRQLWRU`

type
string30 = string[30]; { potrzebne do przekazywania }
{ parametrów }
string25 = string

>@^W\SXáDFXFKRZHJRGRSURFHGXU`

Ksiazka = record

^UHNRUGRSLVXMF\NVL*N`

Tytul : string30;
Autor : string25;
Wypozyczajacy : string25;
Licznik : word;
end;

const

0$;B3$0,(& ^PDNV\PDOQDZLHONRüNDWDORJX`

{ w bajtach }
POJEMNOSC = MAX_PAMIEC div SizeOf(Ksiazka);

var
Katalog : array[1..Pojemnosc] of

.VLD]ND^ZáDFLZ\`

{ katalog }
LbPoz : integer; { liczba pozycji w katalogu }

3RGVWDZRZ\P ZDUXQNLHP X*\WHF]QRFL NDWDORJX MHVW PR*OLZRü ZSURZDG]DQLD GR

QLHJR LQIRUPDFML ] NODZLDWXU\ L Z\SURZDG]DQLD MHM QD HNUDQGUXNDUN 3RQLHZD*
podstawo

Z MHGQRVWN RUJDQL]DF\MQ NDWDORJX MHVW UHNRUG SRZLQQLP\ ]GHILQLRZDü

SURFHGXU\ SR]ZDODMFH QD ZSURZDG]HQLH L Z\SURZDG]HQLH MHJR ]DZDUWRFL : P\O

WHJR FR SRZLHG]LHOLP\ SRSU]HGQLR SURFHGXU\ WH SRZLQQ\ RSHURZDü QD SDUDPHWU]H
odpowiedniego typu rekordowego:

92 Turbo

Pascal

—

programowanie

procedure WprowadzDane(var r : Ksiazka);
{ wprowadza pojedynczy rekord z klawiatury }

begin
with r do

^ZSURZDG(SRV]F]HJyOQHSRODUHNRUGX`

begin
write('Tytul: '); readln(Tytul);
write('Autor: '); readln(Autor);
write('Wypozyczajacy: '); readln(Wypozyczajacy);
end;
end;

procedure WypiszDane(r : Ksiazka);

^Z\SURZDG]D]DZDUWRüUHNRUGXQDHNUDQ`

begin
with r do

^Z\SURZDG(SRV]F]HJyOQHSRODUHNRUGX`

begin
write('Tytul: '); writeln(Tytul);
write('Autor: '); writeln(Autor);
if Wypozyczajacy = '' then

^QLNWQLHZ\SR*\F]\á`

writeln('Ksiazka znajduje sie na polce.')
else

^SROH]DZLHUDQD]ZLVNRZ\SR*\F]DMFHJR`

write('Wypozyczajacy: '); writeln(Wypozyczajacy);
end;
writeln;
end;

0LPRFKRGHPSU]\MOLP\NRQZHQFMZP\ONWyUHMNVL*FHQLHZ\SR*\F]RQHMRGSR-
wiada puste pole

Wypozyczajacy

FRMHVWGRüQDWXUDOQH3RZ\*V]HGHILQLFMHZ\NR-

U]\VWDP\GRXWZRU]HQLDNLONXGRGDWNRZ\FKSURFHGXUSR]ZDODMF\FKQDZSURZDG]HQLH

RSLVX QRZHM NVL*NL GR NDWDORJX RUD] Z\SURZDG]HQLH FDáHM ]DZDUWRFL NDWDORJX QD

HNUDQ FR Z SU]\SDGNX ZLNV]HM OLF]E\ NVL*HN MHVW UDF]HM PDáR VHQVRZQH FK\ED *H

]DPLDVW HNUDQX X*\MH VL GUXNDUNL 3U]\ RND]ML ZDUWR WH* ]GHILQLRZDü SURFHGXU

SR]ZDODMF QD XVXQLFLH NVL*NL ] NDWDORJX FR QDMSURFLHM ]URELü SU]H] SU]HSLVDQLH
ostatniego elementu katalogu w miejsce elementu usuwanego.

procedure DodajKsiazke;

^GRGDMHQRZNVL*NGRNDWDORJX`

begin

,QF/E3R]^GRGDMHP\QRZNVL*N`

writeln('Nowa pozycja w katalogu: ', LbPoz);

:SURZDG]'DQH.DWDORJ>/E3R]@^ZSURZDG(GDQH`

^QRZHMNVL*NL`

.DWDORJ>/E3R]@/LF]QLN ^NVL*NDQLHE\áD`

^Z\SR*\F]DQD`

end;

'RG]LHáD

procedure UsunKsiazke(Numer : integer);

^XVXZDNVL*N]NDWDORJX`

begin

.DWDORJ>1XPHU@ .DWDORJ>/E3R]@^]DPD]XMHGDQSR]\FM`

'HF/E3R]^XVXQLWRNVL*N`

end;

procedure WypiszKatalog;

^Z\SLVXMHFDá]DZDUWRüNDWDORJXQDHNUDQ`

var
i : integer;

begin
  for i := 1 to LbPoz do
  begin
writeln('Pozycja katalogu nr ', i,':');
WypiszDane(Katalog[i]);
  end;
end;

3RU]GQ\SURJUDPSRZLQLHQUyZQLH*]DSHZQLDüPR*OLZRü]PLDQ\RSLVXNVL*NLNRQ-

VWUXNFMRGSRZLHGQLHMSURFHGXU\SR]RVWDZLDP&LMDNRüZLF]HQLH]REDF]WH*SRQL*HM

.ROHMQ VSUDZ MHVW REVáXJD Z\SR*\F]HQLD L ]ZURWX NVL*NL : W\P FHOX QDOH*\ SR

SLHUZV]HRGV]XNDüZ\EUDQNVL*NZHGOHZF]HQLHMV]\FK]DáR*H—ZHGáXJW\WXáX

D QDVWSQLH Z ]DOH*QRFL RG SRWU]HE ZSURZDG]Lü VSUDZG]Lü OXE XVXQü QD]ZLVNR

Z\SR*\F]DMFHJR -HOL FKRG]L R Z\V]XNLZDQLH NVL*NL WR VHQVRZQ\P Z\GDMH VL

]DSURMHNWRZDQLHIXQNFMLNWyUHMDUJXPHQWHPEG]LH]DGDQ\IUDJPHQWW\WXáXDZDUWRFL

]ZUDFDQ — QXPHU NVL*NL Z NDWDORJX OXE – MHOL NVL*NL QLH ]QDOH]Lono (numery

NVL*HNV]DZV]HGRGDWQLHDZLFOLF]ED–QLJG\QLHEG]LHRSLV\ZDáDU]HF]\ZLFLH

LVWQLHMFHM Z NDWDORJXNVL*NL3RQLHZD*NDWDORJPR*H]DZLHUDüNLONDNVL*HNRW\P

VDP\PW\WXOHPXVLP\]DSURMHNWRZDüIXQNFMZ\V]XNXMFWDNE\XPR*OLZLDáD]QDOH-

]LHQLHZV]\VWNLFKÄSRGHMU]DQ\FK´:W\PFHOXZ\SRVD*\P\MZPR*OLZRüV]XNDQLD
od zadanej pozycji:

function Szukaj(Tekst : string; Pozycja : integer) : integer;

^Z\V]XNXMHNVL*NRW\WXOH]DZLHUDMF\P7HNVW`

{ szuka od zadanej pozycji katalogu }

var
i : integer;

begin
i := Pozycja; { szukaj od zadanej pozycji }

^VSUDZG(F]\W\WXá]DZLHUDWHNVW`

^LF]\SU]HV]XNDQRFDá\NDWDORJ`

94 Turbo

Pascal

—

programowanie

while (Pos(Tekst, Katalog[i].Tytul) = 0) and (i <= LbPoz) do
Inc(i);
if i <= LbPoz then

^]QDOH]LRQRRGSRZLHGQL`

^SR]\FMNDWDORJX`

Szukaj := i
else { nie znaleziono pozycji w katalogu }
Szukaj := –1;
end;

=DXZD* *H LVWRWD SU]HV]XNXMFHM WDEOLF SWOL

while

VNXSLD VL Z ZDUXQNX ]D MHM

tre

FL MHVW MHG\QLH ]ZLNV]HQLH LQGHNVX WDEOLF\ 'R VSUDZG]HQLD F]\ W\WXá ]DZLHUD

GDQ\ FLJ ]QDNyZ X*\OLP\ IXQNFML

Pos

]ZUDFDMFHM SR]\FM QD NWyUHM FLJ ]RVWDá

znale

]LRQ\ Z ]DGDQ\P áDFXFKX OXE ]HUR MHOL JR QLH ]QDOH]LRQR 3U]HV]XNLZDQLH

NRF]\VLZPRPHQFLHJG\LQGHNVWDEOLF\]UyZQDVL]QXPHUHPRVWDWQLHMNVL*NLZ
katalogu.

:\V]XNDQLH ZV]\VWNLFK NVL*HN R ]DGDQ\P W\WXOH L Z\ZLHWOHQLH LQIRUPDFML R QLFK

MHVWMX*SURVWH

procedure SprawdzKsiazki(Tytul : string);

^Z\SURZDG]DGDQHNVL*HNR]DGD

nym tytule }

var
i : integer;
Tytul : string;

begin
write('Podaj tytul szukanej ksiazki: ');
readln(Tytul);
i := 1;
repeat

L 6]XNDM7\WXOL^]QDMG(NROHMQH`

^Z\VWSLHQLHW\WXáX`

if i <> -1 then

^]QDOH]LRQRNVL*N`

begin
writeln('Pozycja katalogu nr ', i,':');
WypiszDane(Katalog[i]);

,QFL^SU]HMG(GRQDVWSQHMSR]\FML`

end;
until i = –

^QLH]QDOH]LRQRZLFHMNVL*HN`

end;

3RZ\*V]D SURFHGXUD F\NOLF]QLH Z\ZRáXMH IXQNFM

Szukaj

QDND]XMF MHM ]D ND*G\P

UD]HPUR]SRF]FLHSU]HV]XNLZDQLDRGRVWDWQLR]QDOH]LRQHMNVL*NLGODF]HJR"LZ\SL-

VXMFGDQH]QDOH]LRQ\FKSR]\FML]DSRPRFSURFHGXU\

WypiszDane

. W tym momencie

áDWZRMX*XVWDOLüF]\NVL*ND]RVWDáDZ\SR*\F]RQDDMHOLWDN— to komu (w ramach

üZLF]H VXJHUXM &L QDSLVDQLH SRGREQ\FK IXQNFML XPR*OLZLDMF\FK XVWDOHQLH NWyUH

NVL*NL]RVWDá\Z\SR*\F]RQHRVRELHRSRGDQ\PQD]ZLVNX

:áDFLZ REVáXJ Z\SR*\F]HQLD OXE ]ZURWX ]DMPXMH VL SU]HGVWDZLRQD SRQL*HM
procedura

Wypozycz

=D]QDF]HQLHNVL*NLMDNRZ\SR*\F]RQHMRGE\ZDVLSU]H]ZSL-

'RG]LHáD

VDQLH QD]ZLVND Z\SR*\F]DMFHJR GR RGSRZLHGQLHJR SROD UHNRUGX L ]ZLNV]HQLH

OLF]QLNDZ\SR*\F]H:FKZLOL]ZURWXSROH

Wypozyczajacy

jest zerowane.

procedure Wypozycz(var r : Ksiazka);

^REVáXJXMHZ\SR*\F]HQLH]ZURWNVL*NL`

begin
writeln;
writeln('Biezace dane ksiazki:');

:\SLV]'DQHU^Z\SLV]LQIRUPDFMHRNVL*FHGODNRQWUROL`

writeln;
writeln('Wprowadz nazwisko wypozyczajacego.');
writeln('W przypadku zwrotu ksiazki nacisnij Enter.');
with r do

^ZSURZDG(QD]ZLVNROXEZ\F]\üSROHUHNRUGX`

begin
readln(Wypozyczajacy);
if Wypozyczajacy <> '' then

,QF/E3R]^SU]\Z\SR*\F]HQLX`

^]ZLNV]OLF]QLNZ\SR*\F]H`

end;
end;

3RZ\*V] SURFHGXU PR*QD Z\ZRáDü QS SRGF]DV VSUDZG]DQLD GDQ\FK NVL*HN F]\OL
z procedury

SprawdzKsiazki

. Wymaga to niewielkiej modyfikacji tej ostatniej:

{ ... }
writeln('Pozycja katalogu nr ', i,':');
WypiszDane(Katalog[i]);
writeln('Obsluga wypozyczen: nacisnij "W"');
writeln('Nastepna pozycja: nacisnij dowolny klawisz.');
if UpCase(ReadKey) = 'W' then
Wypozycz(Katalog[i]);
Inc(i); { przejdz do nastepnej pozycji }
{ ... }

-HOLSRGF]DVSU]HJOGDQLDZ\EUDQ\FKSR]\FMLELEOLRWHNDU]]HFKFHZ\SR*\F]\üNVL*N

OXESU]\MüMHM]ZURWSRZLQLHQQDFLVQüNODZLV]

FRZ\ZRáDSURFHGXU

Wypozycz

2EVáXJ QDFLQLFLD NODZLV]D ]DMPXMH VL ÄLPSRUWRZDQD´ ] PRGXáX

Crt

(zobacz str.

121) funkcja

ReadKey

]D IXQNFMD

UpCase

XQLH]DOH*QLD SURJUDP RG ZLHONRFL OLWHU

(w lub W).

6WDW\VW\NZ\SR*\F]HREVáXJXMHGRüREV]HUQDFKRFLD*EDUG]RSURVWDSURFHGXUD

Sta-

tystyka

2EOLF]DRQDQDMPQLHMV]QDMZLNV]LUHGQLZDUWRüOLF]QLNDZ\SR*\F]H

GOD FDáHJR NDWDORJX :\NRU]\VWDQD Z QLHM PHWRGD Z\V]XNLZDQLD QDMPQLHMV]HM L QDM-

ZLNV]HMZDUWRFLZWDEOLF\MHVWEDUG]RW\SRZDLV]HURNRVWRVRZDQDDSROHJDQDED-

GDQLXF]\NROHMQ\HOHPHQWWDEOLF\QLHMHVWPQLHMV]\ZLNV]\RGDNWXDOQHJRPLQLPXP

PDNVLPXPMHOLWDNMHVWRQSU]\MPRZDQ\Mako nowe minimum (maksimum).

96 Turbo

Pascal

—

programowanie

procedure Statystyka;

var

LLQWHJHU^OLF]QLNSWOL`

min, max, sum : longint; { minimum, maksimum i suma }
poz_min, poz_max : integer; { pozycje minimum i maksimum }

begin

PLQ ^LQLFMDOL]XMPLQLPXPPDNVLPXPLVXP`

max := 0;
sum := 0;
  for i := 1 to LbPoz do
  with Katalog[i] do
  begin
  if Licznik > max then { znaleziono nowe maksimum }
  begin

PD[ /LF]QLN^]DSDPLWDMQRZHPDNVLPXP`

poz_max := i; { i numer odpowiedniej pozycji }
  end;
  if Licznik < min then { to samo dla minimum }
  begin
min := Licznik;
poz_min := i;
  end;

VXP VXP/LF]QLN^]ZLNV]OLF]QLNZ\SR]\F]H`

end;

ZULWHOQ6WDW\VW\NDZ\SR]\F]HQ^Z\SLV]ZDUWRFL`

{ statystyk }
writeln('Srednia wypozyczen na jedna ksiazke: ',
sum/Licznik:6:0);
writeln('Ksiazka najczesciej wypozyczana (', max,
' wypozyczen):');
WypiszDane(Katalog[poz_max]);
writeln('Ksiazka najrzadziej wypozyczana (', min,
' wypozyczen):');
WypiszDane(Katalog[poz_min]);
end;

3R]RVWDáDQDPGRUR]ZL]DQLDVSUDZDDOIDEHW\F]QHJRXSRU]GNRZDQLD]DZDUWRFLNDWD-

ORJX =DGDQLH WR EGFH MHGQ\P ] NODV\F]Q\FK ]DGD SURJUDPRZDQLD QRVL QD]Z
sortowania

/LF]ED ]QDQ\FK REHFQLH DOJRU\WPyZ VRUWRZDQLD MHVW GRü VSRUD P\]DM-

PLHP\ VL MHGQ\P ] QDMSURVWV]\FK — tak zwanym sortowaniem przez proste
wybieranie (ang. selection sort), które, chocia

* QLH]E\W HIHNW\ZQH MHVW áDWZH GR

zrozumienia i interpretacji.

=Dáy*P\*HPXVLP\XSRU]GNRZDüRGZDUWRFLQDMPQLHMV]HMGRQDMZLNV]HMWDEOLF

]DZLHUDMF SLü OLF]E FDáNRZLW\FK : SLHUZV]\P NURNX Z\V]XNXMHP\ QDMPQLHMV]

OLF]EZWDEOLF\L]DPLHQLDP\MPLHMVFDPL]OLF]E]QDMGXMFVLQDSLHUZV]HMSR]\FML

:W\PPRPHQFLHQDMPQLHMV]DZDUWRüZWDEOLF\MHVWMX*]ORNDOL]RZDQDLXVWDZLRQDQD

ZáDFLZ\PPLHMVFXÄRGFLQDP\´ZLFSLHUZV]SR]\FMWDEOLF\LSRZWDU]DP\Z\V]XNL-

ZDQLH PLQLPXP GOD SR]RVWDá\FK SR]\Fji (od 2 do 5). Po znalezieniu minimum

]DPLHQLDP\ MH PLHMVFDPL ] OLF]E QD SR]\FML GUXJLHM F]HJR HIHNWHP MHVW XVWDOHQLH

'RG]LHáD

GZyFK SLHUZV]\FK SR]\FML XSRU]GNRZDQHM WDEHOL 3R ÄRGFLFLX´ SLHUZV]\FK GZyFK

SR]\FMLMX*XSRU]GNRZDQ\FKSRZWDU]DP\VRUWRZDQLHGODSR]\FMLGRLWDNGDOHM

D* GR FKZLOL NLHG\ SR]RVWDQLH QDP GR SU]HV]XNDQLD RVWDWQLD SR]\FMD WDEOLF\ RF]\-

ZLFLH]DZLHUDMFDQDMZLNV]OLF]EÄ]HSFKQLW´QDVDPNRQLHF$RWRSU]\NáDG

Przed sortowaniem

W trakcie sortowania

(krok 0)

krok 1

krok 2

krok 3

krok 4

1 (4)

4 (1)

2 (4)

3 (3)

4 (5)

4 (2)

5 (4)

.RORUHPF]DUQ\P]D]QDF]RQR]DNUHVSU]HV]XNLZDQLDWDEOLF\MDNZLGDüZNROHMQ\FK

NURNDFK]PQLHMV]DVLRQR]DZQDZLDVDFKXPLHV]F]RQRZDUWRFLNWyUH]QDMGRwa-

á\VLQDGDQHMSR]\FMLSU]HG]DPLDQWMR]QDF]D*HQDGDQHMSR]\FML]QDMGRZDáD

VLOLF]ED]DPLHQLRQDQDVWSQLH]OLF]E

-DNZLGDüQDV]DOJRU\WPMHVWFDáNLHPSURVW\FKRüRNXSLRQHMHVWWRHIHNW\ZQRFLEDU-
dziej ambitnym Czytelnikom polecam przestudiowanie innych algorytmów sortowania,

]NWyU\FKQDMF]FLHMVWRVRZDQ\PLFK\EDQDMHIHNW\ZQLHMV]\PMHVWW]Zszybkie sorto-
wanie (ang. quicksort), zilustrowane m.in. dostarczanym wraz z Turbo Pascalem prog-
ramem

QSORT

PAS

1LHVWHW\ VSUDZ NRPSOLNXMH QLHFR Z\PDJDQLH VRUWRZDQLD ZHGáXJ

W\WXáyZ OXE QD]ZLVN DXWRUyZ -DN MX* VL ]DSHZQH ]RULHQWRZDáH Z\NRU]\VW\ZDQH
w

DOJRU\WPLHZ\V]XNLZDQLHQDMPQLHMV]HMZDUWRFLSROHJDQDSRUyZQ\ZDQLX]DZDUWRFL

RGSRZLHGQLHMNRPyUNLWDEOLF\]ELH*FZDUWRFLPLQLPXP$E\SRVRUWRZDüNDWDORJ

ZHGáXJW\WXáyZQDOH*\SRUyZQ\ZDüSROD

Tytul

odpowiednich rekordów; sortowanie

ZHGáXJ QD]ZLVN DXWRUyZ Z\PDJD SRUyZQ\ZDQLD SyO

Autor

&]\*E\ ZLF QDOH*DáR

QDSLVDü GZLH RGG]LHOQH SURFHGXU\ VRUWXMFH" 1D V]F]FLH QLH FKRFLD* EDUG]R ZLHOX

SRF]WNXMF\FKSURJUDPLVWyZUDG]LVRELHZáDQLHZWHQVSRVyEF]HJRDEVROXWQLHQLH

QDOH*\ SROHFDü =DXZD* *H Z REX SU]\SDGNDFK PHFKDQL]P VRUWRZDQLD MHVW LGHQ-

W\F]Q\]DUy*QLFDVSURZDG]DVLZ\áF]QLHGRSRUyZQ\ZDQLDUy*Q\FKSyOUHNRUGyZ.

:\VWDUF]\]DWHPQDSLVDüRGSRZLHGQLHIXQNFMHSRUyZQXMFHGZDUHNRUG\ZHGáXJSyO

Autor

Tytul

D QDVWSQLH Z\ZRá\ZDü MH Z ]DOH*QRFL RG DNWXDOQHJR NU\WHULXP

VRUWRZDQLD =Z\F]DMRZR IXQNFMH WDNLH ]ZUDFDM ZDUWRü –1, 0 lub 1 odpowiednio do

WHJR F]\ SLHUZV]\ ] SRUyZQ\ZDQ\FK RELHNWyZ MHVW PQLHMV]\ UyZQ\ OXE ZLNV]\ RG
drugiego. W naszym przypadku —

SRQLHZD*VRUWXMHP\RELHNW\URVQFR— wystarczy

LQIRUPDFMDF]\SLHUZV]\UHNRUGMHVWPQLHMV]\RGGUXJLHJRF]\WH*QLH2WRSU]\NáDG

IXQNFML SRUyZQXMFHM UHNRUG\ ZHGáXJ ]DZDUWRFL SROD

Tytul

GUXJ IXQNFM QDSLV]

sam):

function PorownajTytul(r1, r2 : Ksiazka) : integer;

^SRUyZQXMHUHNRUG\ZHGáXJSROD7\WXO`

begin
if r1.Tytul < r2.Tytul then PorownajTytul := -1
else PorownajTytul := 1;

98 Turbo

Pascal

—

programowanie

end;

6DPDSURFHGXUDVRUWXMFDSRZLQQDZ\NRQ\ZDüDOJRU\WPRSLVDQ\SRZ\*HMZ\ZRáXMF

RGSRZLHGQLIXQNFMSRUyZQXMFZ]DOH*QRFLRG]DGDQHJRSU]H]X*\WNRZQLNDNU\te-

ULXP 1D REHFQ\P HWDSLH ]QDMRPRFL 3DVFDOD MHVWHP\ Z VWDQLH ]UHDOL]RZDü WDNLH
wywo

áDQLH Z RSDUFLX R LQVWUXNFM ZDUXQNRZ MHGQDN ÄSUDZG]LZH´ SURJUDP\ Z\NR-

U]\VWXMQLHFRLQQHUR]ZL]DQLHRSDUWHRWDN]ZDQHparametry proceduralne. Omawia-

QLHWHJR]DJDGQLHQLDZ\NUDF]DSR]DUDP\QLQLHMV]HMNVL*NLMHGQDNZVNUyFLHPHWRGDWD

SROHJDQDSU]HND]DQLXSURFHGXU]HVRUWXMFHMZVND(QLNDRSLVXMFHJRSRáR*HQLHIXQNFML
porównu

MFHMMHMDGUHVX3RGVWDZLDMFSRGSDUDPHWUDGUHV\Uy*Q\FKIXQNFMLMHVWHP\

VWDQLHHOHJDQFNR]PLHQLDüNU\WHULDVRUWRZDQLD

$RWRWUHüSURFHGXU\

procedure Sortuj(Kryterium : integer);
{ sortuje zawart

RüNDWDORJXZHGáXJ]DGDQHJRNU\WHULXP`

var
i, j : integer;
CzyWiekszy : integer;
Pomoc : Ksiazka;

begin
  for i := 1 to LbPoz-1 do { wykonaj LbPoz-1 przebiegów }
  for j := i to LbPoz do
  begin
  if Kryterium = 1 then

^SRUyZQDQLHZJW\WXáXDXWRUD`

CzyWiekszy := PorownajTytul(Katalog[i], Katalog[j])
else
CzyWiekszy := PorownajAutor(Katalog[i], Katalog[j]);
if CzyWiekszy = 1 then

^WU]HED]DPLHQLüHOHPHQW\`

  begin
Pomoc := Katalog[i]; { zachowaj pierwszy rekord }
Katalog[i] := Katalog[j]; { wstaw drugi }
{ do pierwszego }
Katalog[j] := Pomoc; { wstaw zachowany }
{ do drugiego }
  end;
  end;
end;

-DNZLGDüSURFHGXUDZ\NRQXMHF\NOLF]QHSRUyZQDQLDLHZHQWXDOQH]DPLDQ\ZGZyFK

]DJQLH*G*RQ\FKSWODFK]NWyU\FK]HZQWU]QDZ\]QDF]DNROHMQHNURNLDOJRU\WPX]D

ZHZQWU]QDREVáXJXMHSU]HJOGDQLHSR]RVWDá\FKMHV]F]HGRXSRU]GNRZDQLDUHNRUGyZ

6DPD ]DPLDQD HOHPHQWyZ Z\NRU]\VWXMH W\SRZ\ VFKHPDW ÄSRGSLHUDMF\ VL´ SRPRF-

QLF]\PUHNRUGHPVáX*F\PGRW\PF]DVRZHJRSU]HFKRZDQLDGDQ\FK=DXZD*ZUHV]FLH

*HDE\SRVRUWRZDüUHNRUG\PDOHMFRZ\VWDUF]\]PRG\ILNRZDüZDUXQHN

if CzyWiekszy = 1

]DVWSXMFZDUWRüZDUWRFL–1.

'RG]LHáD

-DN QLHWUXGQR VL GRP\OLü RSHUDFMD VRUWRZDQLD SRZLQQD SRSU]HG]Dü Z\SURZDG]HQLH

]DZDUWRFLNDWDORJXQDHNUDQOXEGUXNDUN3URFHGXUDNRMDU]FDRE\GZLHRSHUDFMHPR*H

Z\JOGDüQDVWSXMFR

procedure WypiszKatalog;

var
Kryterium : integer;

begin
write('Sortowanie wedlug tytulow (1)',
' lub nazwisk autorow (2)');
readln(Kryterium);
Sortuj(Kryterium–

^SDUDPHWUSRZLQLHQE\üOXE`

Wypisz; { wypisz posortowany katalog }

UHDGOQ^LSR]ZyOJRSU]HF]\WDü`

end;

:WHQVSRVyE]DNRF]\OLP\EXGRZ]DVDGQLF]\FKNORFNyZ]NWyU\FKVNáDGDüVLPD

QDV]SURJUDP3R]RVWDMHMHV]F]HQDSLVDQLHáDGQHJRPHQX

function Menu : integer;

var
c : char;

begin

&OU6FU^Z\F]\üHNUDQ

Z\PDJDZáF]HQLDPRGXáX

Crt }

writeln('Program biblioteczny KATALOG, wersja 1.0, 1996');
writeln;
writeln('Wybierz funkcje:');
writeln('1: Wyszukiwanie pozycji wg tytulu',
' i obsluga wypozyczen');
writeln('2: Wyswietlenie wszystkich pozycji');
writeln('3: Dodanie ksiazki do katalogu');
writeln('5: Statystyka wypozyczen');
writeln('0: Koniec pracy');
writeln;
writeln;
repeat

^F]\WDMNODZLDWXU`

F 5HDG.H\^UyZQLH*Z\PDJDZáF]HQLDPRGXáX&UW`

until c in ['0'..'5']; { ignoruj po

]RVWDáH]QDNL`

Menu := ord(c)-ord('0');
end;

6DPDF]üRSHUDF\MQDSURJUDPXMHVWUyZQLH*EDUG]RW\SRZD:\NRU]\VWXMHRQDSWO

repeat

F\NOLF]QLH Z\ZLHWODMF PHQX GRVWSQ\FK RSHUDFML .RG ]ZUyFRQ\ SU]H]

IXQNFM

MHVW Z\NRU]\VW\ZDQ\ GR Z\ZRáDQLD RGSRZLHGQLHM RSHUDFML Z LQVWUXNFML

case

=ZUyFHQLHSU]H]IXQNFM

ZDUWRFLSRZRGXMH]DNRF]HQLHG]LDáDQLDSWOL

DW\PVDP\PFDáHJRSURJUDPX

begin

^F]üRSHUDF\MQD`

repeat

100 Turbo

Pascal

—

programowanie

:\ERU 0HQX^Z\ELHU]RSFM]PHQX`

  case Wybor of
1 : SprawdzKsiazki;
2 : begin
WypiszKatalog;
readln;
  end;
3 : DodajKsiazke;
5 : Statystyka;
  end;
  until Wybor = 0; { opcja 0 = koniec pracy }
end. { program Biblioteka }

-DN]G*\áH]DSHZQH]DXZD*\üSURJUDPQLHXPR*OLZLDXVXQLFLDNVL*NL]NDWDORJX

3U]H]QDF]RQD MHVW GR WHJR EUDNXMFD F]ZDUWD SR]\FMD PHQX NWyUHM ]DSURJUDPRZDQLH

SURSRQXM&LZUDPDFKüZLF]H

3R SRVNáDGDQLX RSLVDQ\FK Z W\P UR]G]LDOH IUDJPHQWyZ Z MHGQ FDáRü QDMOHSLHM
w kole

MQRFL Z MDNLHM E\á\ F\WRZDQH X]\VNXMHV] JRWRZ\ SURJUDP 1LHVWHW\ SHáQL

V]F]FLD ]DNáyFDM GZD PDQNDPHQW\ ] NWyU\FK FR QDMPQLHM MHGHQ MHVW EDUG]R

SRZD*Q\2ND]XMHVLPLDQRZLFLH*HQDV]NDWDORJLVWQLHMHGRSyW\GRSyNLX*\WNRZQLN
nie wybierze opcji „Koniec pracy” —

NROHMQH XUXFKRPLHQLH SURJUDPX ZL*H VL ]

koniecz

QRFLZSLVDQLDZV]\VWNLFKNVL*HNRGQRZDFRMHVWQLHGRSXV]F]DOQH1RL

VDPDSRMHPQRüNDWDORJXWH*PRJáDE\E\üZLNV]D

5R]ZL]DQLHP QDV]\FK SUREOHPyZ ]DMPLHP\ VL MX* ]D FKZLO Z Gwóch kolejnych

UR]G]LDáDFKWUDNWXMF\FKRSOLNDFKRUD]]PLHQQ\FKG\QDPLF]Q\FK

3OLNLF]\OLMDNXFKURQLüGDQHSU]HG]JXE

101

3OLNLF]\OLMDNXFKURQLü

GDQHSU]HG]JXE

3DPLüRSHUDF\MQDZ\NRU]\VW\ZDQDGRSU]HFKRZ\ZDQLDGDQ\FKSU]HWZDU]DQ\FKSU]H]

SURJUDP PD GZLH ]DVDGQLF]H ZDG\ RJUDQLF]RQ SRMHPQRü L XORWQRü WR SRHW\FNLH

VáRZRR]QDF]DSRSURVWX*H]DZDUWRüSDPLFLMHVWWUDFRQDZFKZLOLZ\áF]HQLD]DVL-

ODQLD.RPSXWHUXPR*OLZLDMF\SU]HFKRZ\ZDQLHGDQ\FKZ\áF]QLHSRGF]DVZáF]HQLD

GRVLHFLE\áE\UDF]HMPDáRX*\WHF]Q\GODWHJRWH*SURMHNWDQFLVSU]WXRSUDFRZDOLV]HUHJ

XU]G]H — tzw. SDPLFL PDVRZ\FK — SR]ZDODMF\FK QD WUZDáH SU]HFKRZ\ZDQLH

GDQ\FK 5RO SDPLFL PDVRZHM Z NRPSXWHU]H RVRELVW\P SHáQL G\VNLHWNL RUD] G\VNL

WZDUGHREDUR]ZL]DQLDZ\NRU]\VWXMLGHQW\F]QPHWRG]DSLVXLUy*QLVLUR]ZLza-
niami technologicznymi). Z logicznego punktu widzenia, dane zapisywane na dyskach

RUJDQL]RZDQH V Z pliki D WH ] NROHL SU]HFKRZ\ZDQH V Z katalogach &DáRFL

]DU]G]DV\VWHPRSHUDF\MQ\]NWyUHJRXVáXJNRU]\VWDMSURJUDP\X*\WNRZH

Rzecz jasna,

UyZQLH* L 7XUER 3DVFDO G\VSRQXMH PR*OLZRFL NRU]\VWDQLD ] SOLNyZ

WU]HFK GRVWSQ\FK Z 3DVFDOX URG]DMyZ SOLNyZ — elementowych (jednorodnych),

tekstowych i amorficznych —

RPyZLP\ GZD SLHUZV]H PDMFH QDMZLNV]H ]DVWRVR-

wanie w praktyce.

1D SRF]WHN QLHFR WHRULL 6DP SOLN MHVW SHZQ VWUXNWXU GDQ\FK ]DSLVDQ QD G\VNX
i

LGHQW\ILNRZDQ]DSRPRFQD]Z\FLOHM—FLH*NLGRVWSX'DQHSU]HFKRZ\ZDQH

Z SOLNX PRJ PLHü UHSUH]HQWDFM ELQDUQ WDN VDP MDN Z SDPLFL NRPSXWHUD OXE

WHNVWRZWDNMDNDX*\ZDQDMHst do wprowadzania informacji z klawiatury i wyprowa-

G]DQLDMHMQDHNUDQPRQLWRUDOXEGUXNDUN5HSUH]HQWDFMRPW\PRGSRZLDGDMZ3DV-
calu pliki elementowe oraz tekstowe.

•

3OLNL HOHPHQWRZH SU]HFKRZXM GDQH Z SRVWDFL ELQDUQHM ]D SOLNL WHNVWRZH —
w

SRVWDFL ZLHUV]\ WHNVWX ]DNRF]RQ\FK ]QDNDPL NRFD ZLHUV]D =DZDUWRü

SOLNyZHOHPHQWRZ\FKMHVWQDRJyáQLHF]\WHOQDGODX*\WNRZQLNDQDWRPLDVWWUHü

SOLNX WHNVWRZHJR GDMH VL áDWZR RGF]\WDü L ]LQWHUSUHWRZDü = GUXJLHM VWURQ\
binarna reprezentacja danych jest bardzi

HM]ZDUWDLRV]F]GQD

102 Turbo

Pascal

—

programowanie

•

:V]\VWNLHGDQHSU]HFKRZ\ZDQHZSOLNDFKHOHPHQWRZ\FKPXV]E\üWHJRVDPH-

JRW\SXSURVWHJROXEVWUXNWXUDOQHJR3OLNLWHNVWRZHZ\NRU]\VWXMFH]QDNRZH

VIRUPDWRZDQH UHSUH]HQWDFMH GDQ\FK PRJ E\ü X*\WH GR SU]HFKRZ\ZDQLD

PLHV]DQ\FKW\SyZGDQ\FKQSWHNVWyZLOLF]EJG\*ZV]HONDLQIRUPDFMDSU]H-

FKRZ\ZDQDMHVWZQLFKZSRVWDFLWHNVWRZHM3OLNLWHNVWRZHXPR*OLZLDMUyZQLH*
formatowanie zapisu i korzystanie z procedur

readln

writeln

NWyUH V

QLHGRVWSQHGODSOLNyZHOHPHQWRZ\FK

•

Pliki

HOHPHQWRZHXPR*OLZLDMW]ZGRVWSVZRERGQ\— w dowolnym momencie

PR*QD RGZRáDü VL GR GRZROQHJR HOHPHQWX SOLNX 3OLNL WHNVWRZH V SOLNDPL
o

GRVWSLHVHNZHQF\MQ\PFRR]QDF]D*HDE\GRVWDüVLGRZ\EUDQHJRHOHPHQWX

SOLNXQDOH*\SU]HF]\WDüZV]\VWNLHHOHPHQW\]QDMGXMFHVLSU]HGQLP

2GZRáDQLDGRSOLNX]DSLV\RGF]\W\LLQQHRSHUDFMHUHDOL]RZDQHVSU]H]Z\ZRáDQLH

RGSRZLHGQLFK IXQNFML V\VWHPX RSHUDF\MQHJR NWyU\ ] NROHL SRVáXJXMH VL OLF]ERZ\PL

LGHQW\ILNDWRUDPL SOLNyZ NRU]\VWDQLH ] QD]Z E\áRE\ QLHZ\JRGQH 5yZQLH* SURJUDP

SDVFDORZ\QLHRGZRáXMHVLGRSOLNyZÄEH]SRUHGQLR´OHF]SRSU]H]WDN]ZDQHzmienne
plikowe

F]\OL ]áR*RQH VWUXNWXU\ GDQ\FK UHSUH]HQWXMFH IL]\F]QH SOLNL ]DSLVDQH QD

dysku. Ogólny schemat operacji plikowej w Pascalu obejmuje cztery etapy:

•

VNRMDU]HQLH ]PLHQQHM SOLNRZHM ] RGSRZLHGQLP SOLNLHP ]QDMGXMF\P VL QD
dysku lub nowo tworzonym);

•

RWZDUFLHSOLNXSU]\JRWRZXMFHJRGR]DSLV\ZDQLDOXERGF]\W\ZDQLDLQIRUPDFML

•

MHGQDOXEZLFHMRSHUDFML]DSLVXOXERGF]\WXGDQ\FK

•

]DPNQLFLHSOLNXLSU]HUZDQLHVNRMDU]HQLDSRPLG]\]PLHQQSOLNRZLSOLNLHP

6DP]PLHQQSOLNRZGHNODUXMHVLZVSRVyEQDVWSXMF\

nazwa : file of typ { dla pliku elementowego }
nazwa : text { dla pliku tekstowego }

gdzie

typ

RNUHOD W\S HOHPHQWX VNáDGRZHJR SOLNX L PR*H E\ü GRZROQ\P LGHQW\fika-

WRUHPW\SXSURVWHJROXEVWUXNWXUDOQHJR]Z\MWNLHPW\SXSOLNRZHJRLRELHNWRZHJR

=DXZD* *H SRMHG\QF]\P HOHPHQWHP SOLNX HOHPHQWRZHJR MHVW QLH EDMW OHF] ZáDQLH

RELHNW ]DGDQHJR W\SX FR MHVW GRü ORJLF]QH 'ODWHJR WH* GR SOLNX UHNRrdów (drugi

SU]\NáDGSRQL*HMPR*HV]ZSLV\ZDüZ\áF]QLHFDáHUHNRUG\]DSLV\ZDQLHOXERGF]\W\-

ZDQLH SRMHG\QF]\FK SyO MHVW QLHZ\NRQDOQH D MHJR GáXJRü EG]LH ]DZV]H UyZQD
wielo

NURWQRFL UR]PLDUX SRMHG\QF]HJR UHNRUGX 3RGREQLH GHNODUDFMD SOLNX NWyUHJR

elemen

WDPL VNáDGRZ\PL V WDEOLFH OLF]E FDáNRZLW\FK ]PXVL &L GR ]DSLV\ZDQLD L

odczyty

ZDQLD FDá\FK WDEOLF JG\* RGZRáDQLH VL GR SRMHG\QF]HJR HOHPHQWX WDEOLF\

EG]LH QLHPR*OLZH 7HQ VDP SOLN PR*QD RF]\ZLFLH RWZRU]\ü MDNR SOLN OLF]E

FDáNRZLW\FKFRSR]ZROLQDPQDRGF]\W\ZDQLHSRMHG\QF]\FKZDUWRFL:SU]\SDGNX
gdy plik przechowuje jednorodne dane, deklaracja zmiennej plikowej wykorzystuje na

RJyá HOHPHQW\ VNáDGRZH RGSRZLHGQLHJR W\SX SURVWHJR 'OD ED] GDQ\FK ]áR*RQ\FK ]
rekordów (przechowu

MF\FK GDQH Uy*Q\FK W\SyZ MHG\Q\P Z\MFLHP MHVW GHNODUDFMD

pliku rekordów.

3OLNLF]\OLMDNXFKURQLüGDQHSU]HG]JXE

103

2WRNLONDSU]\NáDGRZ\FKGHNODUDFML

var
Probki : file of real; { plik liczb rzeczywistych }
KatalogNaDysku : file of Ksiazka; { plik rekordów }
KatalogTekstowy : text; { plik tekstowy }

'OD SRWU]HE QDV]HJR SURJUDPX ELEOLRWHF]QHJR PR*HP\ Z\NRU]\VWDü GUXJL OXE WU]HFL
z

SRZ\*V]\FKSU]\NáDGyZ1DMSRSXODUQLHMV]\PUR]ZL]DQLHPGODED]GDQ\FKDQDV]

SURJUDPMHVWZáDQLHSURVWED]GDQ\FKV—MDNMX*SRZLHG]LDQR— pliki rekordów,

XPR*OLZLDMFH VZRERGQ\ GRVWS GR GDQ\FK L OHSV]H ]DJRVSRGDURZDQLH G\VNX -HOL

MHGQDN ]DOH*\ &L QD F]\WHOQRFL SOLNX ] GDQ\PL PR*HV] Z\NRU]\VWDü UHSUH]HQWDFM
w postaci pliku tekstowego.

3R]DGHNODURZDQLXRGSRZLHGQLHM]PLHQQHMSOLNRZHMPR*QDSU]\VWSLüGRZáDFLZ\FK

RSHUDFML]ZL]DQ\FK]]DSLV\ZDQLHPLRGF]\W\ZDQLHPGDQ\FK3U]HGHZV]\VWNLPPX-

VLP\VNRMDU]\ü]PLHQQSOLNRZ]IL]\F]Q\PSOLNLHP]QDMGXMF\PVLQDG\VNX6áX*\
do tego procedura

assign

assign(zmienna-plikowa, nazwa-pliku)

Nazwa-pliku

RNUHODWXSOLNGRNWyUHJRFKFHP\VLRGZRá\ZDüáF]QLH]HZHQWXDOQ

FLH*NGRVWSXF]\OLQD]ZG\VNXNDWDORJXLHZHQWXDOQ\FKSRGNDWDORJyZ]DZLHUDM-
cych plik). Po wykonaniu procedury

assign

ZV]HONLHRGZRáDQLDGR]PLHQQHMSOLNRZHM

EGGRW\F]\á\VNRMDU]RQHJR]QLSOLNXRQD]ZLHNWyUHJRPR*HP\]DSRPQLHü-HVWWR

GRü LVWRWQH JG\* MHGQ\P ] EáGyZ F]VWR SRSHáQLDQ\FK SU]H] SRF]WNXMF\FK

SURJUDPLVWyZMHVWSUyEDRGZRá\ZDQLDVLGRSOLNXSU]H]SRGDQLHMHJRQD]Z\FRMHVW
rzecz jasna nielegalne.

3U]\NáDGRZHVNRMDU]HQLH]PLHQQHMSOLNRZHM]SOLNLHPPR*HPLHüSRVWDü

assign(KatalogNaDysku, 'c:\biblio\dane\katalog.dat')

lub (lepiej)

assign(KatalogNaDysku, NazwaPliku)

:GUXJLPSU]\SDGNXQD]ZDSOLNXSU]HND]\ZDQDMHVWMDNR]PLHQQDFRXPR*OLZLDQS

ZSURZDG]HQLH MHM ] ]HZQWU] Ä]DV]\FLH´ QD]Z\ ZHZQWU] SURJUDPX ]PQLHMV]D MHJR

XQLZHUVDOQRü

1DVWSQ\PNURNLHPMHVWRWZDUFLHSOLNXF]\OLSU]\JRWRZDQLHJRGRRGF]\WXOXE]DSLVX

.RQLHF]QRü RWZDUFLD L Sy(QLHMV]HJR ]DPNQLFLD SOLNX Z\QLND ] PHWRG REVáXJL

SOLNyZ SU]\MW\FK Z V\VWHPLH RSHUDF\MQ\P NWyUHJR IXQNFMH V ]UHV]W Z W\P FHOX
wykorzysty

ZDQH :\PLDQD LQIRUPDFML SRPLG]\ SOLNLHP D SURJUDPHP PR*OLZD MHVW

dopiero po otwarciu tego ostatniego.

104 Turbo

Pascal

—

programowanie

'ZLHPD SRGVWDZRZ\PL SURFHGXUDPL X*\ZDQ\PL Z 3DVFDOX GR RWZLHUDQLD SOLNyZ V

reset

rewrite

reset(zmienna-plikowa)
rewrite(zmienna-plikowa)

Procedura

reset

XPR*OLZLDRWZDUFLHMX*LVWQLHMFHJRSOLNXXVWDZLDMFW]ZZVND(QLN

plikowy

QD MHJR SRF]WNX : SU]\SDGNX JG\ RWZLHUDQ\ SOLN QLH LVWQLHMH Z\ZRáDQLH

SURFHGXU\ UHVHW NRF]\ VL EáGHP Z\NRQDQLD = NROHL

rewrite

XPR*OLZLD RWZDUFLH

SOLNXQLH]DOH*QLHRGWHJRF]\LVWQLDáRQSRSU]HGQLRMHOLQLH— tworzy ona nowy plik
o

GDQHM QD]ZLH ]D MHOL WDN — ]HUXMH GáXJRü LVWQLHMFHJR SOLNX L XVWDZLD ZVND(QLN

SOLNRZ\ QD MHJR SRF]WNX F]HJR HIHNWHP Mest utracenie wszystkich danych
zawartych w pliku

:DUWR SDPLWDü *H Z SU]\SDGNX SOLNyZ WHNVWRZ\FK SURFHGXUD

reset

otwie

UDSOLNZ\áF]QLHGRRGF]\WX]D

rewrite

—

Z\áF]QLHGR]DSLVXQLH

PD]DWHPPR*OLZRFLPLHV]DQLDRGF]\WyZL]DSLVyZZMHGQ\PF\NOXRWZDUFLD=DVDGD

WDQLHRERZL]XMHGODSOLNyZHOHPHQWRZ\FKNWyUHPR*QDRGF]\W\ZDüL]DSLV\ZDüEH]
ogra

QLF]HQLH]DOH*QLHRGWHJRF]\]RVWDá\RWZDUWH]DSRPRFSURFHGXU\

reset

, czy

rewrite

ZW\PRVWDWQLPSU]\SDGNXWU]HEDQDMSLHUZ]DSLVDüGRSOLNXMDNLHGDQH

6DPZVND(QLNSOLNRZ\MHVWSRSURVWXNROHMQ\PQXPHUHPHOHPHQWXQLHEDMWXZSOLNX

SU]\ F]\P QXPHUDFMD UR]SRF]\QD VL RG ]HUD .D*GD RSHUDFMD RGF]\WX OXE ]DSLVX

SRZRGXMHSU]HVXQLFLHZVND(QLNDRZDUWRüUyZQOLF]ELHRGF]\WDQ\FKOXE]DSLVDQ\FK

HOHPHQWyZSU]\F]\PGODSOLNyZRGRVWSLHVZRERGQ\PHOHPHQWRZ\FKPR*OLZHMHVW

UyZQLH*MHJRGRZROQHSU]HVWDZLDQLHQDZHWSR]DNRQLHFSOLNXFKRüPDWRPDá\VHQV
i

QDMF]FLHMSRZRGXMHEáG\Z\NRQDQLD

7U]HFL SURFHGXU RWZLHUDMF GRVWSQ Z\áF]QLH GOD plików tekstowych, jest

Append

3URFHGXUDWDRWZLHUDSOLNGRGRSLV\ZDQLDWMRWZLHUDJRGR]DSLVXQLHQLV]F]F

poprzed

QLHM ]DZDUWRFL L XVWDZLD ZVND(QLN SOLNRZ\ QD MHJR NRFX 8PR*OLZLD WR

dodawanie danych do plików tekstowych, które —

MDNRSOLNLRGRVWSLHVHNZHQF\MQ\P

—

QLHXPR*OLZLDMSURJUDPRZHJRSU]HVWDZLDQLDZVND(QLNDSOLNRZHJR

'RZ\PLDQ\GDQ\FKSRPLG]\SURJUDPHPDSOLNLHPVáX*]QDQHQDPMX*SURFHGXU\

read

(odczyt) i

write

]DSLV3RQLHZD*ZÄVWDQGDUGRZHM´ZHUVMLREVáXJXMRQHHNUDQ

monitora i

NODZLDWXU QLH]EGQH MHVW SRGDQLH GRGDWNRZHJR DUJXPHQWX RNUHODMFHJR

SOLN ]GR NWyUHJR LQIRUPDFMD PD E\ü RGF]\WDQD OXE ]DSLVDQD $UJXPHQWHP W\P MHVW

ZáDQLHQD]ZDRGSRZLHGQLHM]PLHQQHMSOLNRZHM

read(zmienna-plikowa, lista-elementów)
write(zmienna-plikowa, lista-elementów)

3RZ\*V]H RSHUDFMH RGQRV] VL ]DUyZQR GR SOLNyZ HOHPHQWRZ\FK MDN L WHNVWRZ\FK

'ODW\FKRVWDWQLFKPR*OLZHMHVWSRQDGWRX*\FLHSURFHGXU

readln

writeln

, odczytu-

MF\FKOXE]DSLVXMF\FKGDQHZUD]]H]QDNDPLNRFDZLHUV]D3RQLHZD*SOLNi elemen-

WRZHSU]HFKRZXMZ\áF]QLHGDQHRNUHORQHJRW\SXLQLHPRJ]DZLHUDü]QDNyZNRFD

ZLHUV]DX*\FLHSURFHGXU

readln

writeln

MHVWZLFKSU]\SDGNXQLHOHJDOQH'UXJ

LVWRWQ Uy*QLF MHVW ]DZDUWRü

listy-elementów

. W przypadku plików tekstowych

OLVWDWDPR*H]DZLHUDüGRZROQH]PLHQQHVWDáHLZ\UD*HQLDJG\*ZV]\VWNLH]DSLV\ZDQH

VZ SOLNXZSRVWDFLWHNVWXQDWRPLDVWGODSOLNyZHOHPHQWRZ\FKMHMVNáDGQLNDPLPRJ

3OLNLF]\OLMDNXFKURQLüGDQHSU]HG]JXE

105

E\üZ\áF]QLH]PLHQQHRGSRZLHGQLHJRW\SX']LHMHVLWDNGODWHJR*HSOLNHOHPHQWRZ\

PR*H]DZLHUDüZ\áF]QLHGDQHMHGQHJRW\SX]DSRV]F]HJyOQHHOHPHQW\OLVW\SU]HND]\-

ZDQHVSU]H]QD]Z

3RZ\NRQDQLX*GDQ\FKRSHUDFML]DSLVXLRGF]\WXGDQ\FKSOLNQDOH*\]DPNQü. Ta bar-

G]RZD*QDRSHUDFMDMHVWLJQRURZDQDSU]H]ZLHOXSURJUDPLVWyZFRZHIHNFLHSURZDG]L

GRSU]\NU\FKQLHVSRG]LDQHNZSRVWDFL]JXELRQ\FKGDQ\FK8SRGáR*DFDáHJRSUREOHPX

OH*\WDN]ZDQHbuforowanie operacji dyskowychF]\OLWHFKQLNDSROHJDMFDQDRGF]\W\-

ZDQLXL]DSLV\ZDQLXGDQ\FKQLHSRMHG\QF]ROHF]FDá\PLSDF]NDPL]DSRUHGQLFWZHP

VSHFMDOQHJRREV]DUXSDPLFL— tzw. bufora dyskowego. Wykorzystanie bufora pozwala
na zredukowanie liczby fizycznych odczytów i zapisów na dysku, a przez to zmniej-

V]HQLH MHJR PHFKDQLF]QHJR REFL*HQLD L SRSUDZ Z\GDMQRFL RSHUDFML G\VNRZ\FK

3RQLHZD* MHGQDN SRGF]DV ]DSLVX ]DZDUWRü EXIRUD Z\V\áDQD MHVW QD G\VN GRSLHUR SR

MHJR]DSHáQLHQLXOXEZFKZLOL]DPNQLFLDSOLNXSU]HUZDQLHZ\NRQ\ZDQLDSURJUDPX

PR*HVSRZRGRZDüXWUDWGDQ\FK5yZQLH*SRSUDZQH]DNRF]HQLHSURJUDPXSRZRGXMH
co prawda automatyczne zamkni

FLH RWZDUW\FK SOLNyZ QLH RSUy*QLD MHGQDN EXIRUyZ

SU]HFKRZXMF\FKQLH]DSLVDQHMHV]F]HGDQHFRPR*HVSRZRGRZDüLFKXWUDW:SU]\-

SDGNXJG\SOLNZ\NRU]\VW\ZDQ\MHVWZ\áF]QLHGRRGF]\WXGDQ\FKQLH]DPNQLFLHQLH

SRZRGXMH XWUDW\ LQIRUPDFML FR QLH ]QDF]\ *H PR*QD MH VRELH RGSXFLü ERZLHP

OHQLVWZRWDNLH]Z\NOHPFLVLZQDMPQLHMVWRVRZQ\FKRNROLF]QRFLDFK

3DPLWDM]DPNQLFLHSOLNXMHVWSUDNW\F]QLHjedynym sposobem na bezpieczne
zapisanie w nim wszystkich danych.

1DV]F]FLH]DPNQLFLHSOLNXMHVWEardzo proste. Realizuje je procedura

close(zmienna-plikowa)

-HMZ\ZRáDQLHPDWVDPIRUPGODZV]\VWNLFKURG]DMyZSOLNyZ
7\OHWHRULL$E\ZSURZDG]LüMZ*\FLHVSUyEXMP\QDSLVDü]HVWDZSURFHGXUSR]ZDOD-

MF\FK QD ]DSLVDQLH QDV]HJR NDWDORJX Z SOLNX G\VNRZ\P L RGF]\WDQLH JR ] SOLNX

=JRGQLH]W\PFRSRZLHG]LHOLP\ZF]HQLHMGRSU]HFKRZ\ZDQLD]DZDUWRFLNDWDORJX
wykorzystamy plik elementowy typu

file of record

procedure ZapiszNaDysku(NazwaPliku : string);

var
f : file of Ksiazka;
i : integer;

begin

DVVLJQI1D]ZD3OLNX^VNRMDU]SOLN]H]PLHQQSOLNRZ`

rewrite(f); { otwórz (utwórz) plik }
for i := 1 to LbPoz do { zapisz kolejne rekordy }
write(f, Katalog[i]);
close(f); { zamknij plik }
end;

106 Turbo

Pascal

—

programowanie

3RZ\*V]D SURFHGXUD LOXVWUXMH W\SRZ PHWRG ]DSLV\ZDQLD Z SOLNX ]DZDUWRFL ED]\

GDQ\FK3RVNRMDU]HQLXSOLNX]RGSRZLHGQL]PLHQQLRWZDUFLXJR]DSLVXMHP\NROHMQH

UHNRUG\ ]QDMGXMFH VL Z WDEOLF\ ]ZUyü XZDJ *H UHNRUG\ ]DSLV\ZDQH V Z FDáRFL
a nie polami). Po zapis

DQLXZáDFLZHMOLF]E\UHNRUGyZ]DP\NDP\SOLNLWRZV]\VWNR

0XVLV] MHV]F]H ]GDZDü VRELH VSUDZ *H ND*GH RWZDUFLH EG]LH SRZRGRZDáR XWUDW

SRSU]HGQLHM ]DZDUWRFL SOLNX

rewrite

DOH SRQLHZD* SU]HG FKZLO QLHMDZQLH

]DáR*\OLP\*HND*GRUD]RZR]DSLVXMHP\FDá\NDWDORJMHVWWRGRSU]\MFLD

2GF]\WDQLH ]DZDUWRFL NDWDORJX ] SOLNX SU]HELHJD ZHGáXJ QLHFR LQQHJR VFKHPDWX

3RQLHZD*QLHZLHP\LOHUHNRUGyZPDP\ZáDFLZLHRGF]\WDüQLHPR*HP\]DVWRVRZDü

SWOL

for

1DMSRSXODUQLHMV]\P UR]ZL]DQLHP MHVW F]\WDQLH Nolejnych rekordów do

PRPHQWXQDSRWNDQLDNRFDSOLNXFRZ\NU\ZDQHMHVWSU]H]SURFHGXU

eof

(ang. end-of-

file —

NRQLHFSOLNX-DNQLHWUXGQRVLGRP\OLüW\PUD]HP]DVWRVXMHP\SWO

while

(lub

repeat

procedure OdczytajZDysku(NazwaPliku : string);

var
f : file of Ksiazka;
i : integer;

begin

DVVLJQI1D]ZD3OLNX^VNRMDU]SOLN]H]PLHQQSOLNRZ`

UHVHWI^RWZyU]SOLNPXVLLVWQLHü`

i := 0; { wyzeruj licznik rekordów }
while not eof(f) do

^F]\WDMD*GRNRFDSOLNX`

begin
Inc(i); { kolejny rekord }
read(f, Katalog[i]);
end;
LbPoz := i; { wczytano tyle rekordów }
close(f);
end;

3R]RVWDáH RSHUDFMH Z\NRQ\ZDQH Z SURFHGXU]H V SUDNW\F]QLH WDNLH VDPH MHG\QLH GR

RWZDUFLDSOLNXZ\NRU]\VWXMHP\W\PUD]HPSURFHGXU

reset

=DXZD**HNRQVWUXNFMD

procedur

ZapiszNaDysku

OdczytajZDysku

przewiduje przekazanie nazwy pliku

MDNR SDUDPHWUX FR ] NROHL SR]ZDOD QD LFK X*\FLH EH] NRQLHF]QRFL ND*GRUD]RZHJR

NRPXQLNRZDQLDVL]X*\WNRZQLNLHPQD]ZPR*QDÄ]DV]\ü´ZSURJUDPLHMDNRVWDá

-HGQ\P]PR*OLZ\FKLF]VWRVWRVRZDQ\FKUR]ZL]DNZHVWLL]DSDPLW\ZDQLDGDQ\FK

MHVW ND*GRUD]RZH ]DSLV\ZDQLH FDáHM ED]\ Z FKZLOL ]DNRF]HQLD SURJUDPX L RGF]\W\-

ZDQLHMHM]DUD]SRXUXFKRPLHQLX:W\PFHOXZ\VWDUF]\QDSRF]WNXF]FLRSHUDF\MQHM

SU]HGZ\ZRáDQLHPPHQXZVWDZLüLQVWUXNFM

OdczytajZDysku(PLIK_KATALOGU);

]DSU]HGVDP\PNRFHPSURJUDPXGRSLVDü

ZapiszNaDysku(PLIK_KATALOGU);

SU]\F]\PVWDá

PLIK_KATALOGU

QDOH*\ZF]HQLHM]GHILQLRZDüMDko np.

PLIK_KATALOGU = 'Katalog.dat'

3OLNLF]\OLMDNXFKURQLüGDQHSU]HG]JXE

107

0HWRGD WD SR]ZDOD QD ND*GRUD]RZH ]DSDPLW\ZDQLH WUHFL NDWDORJX SR ]DNRF]HQLX

SURJUDPX L MHM RGWZDU]DQLH QD SRF]WNX NROHMQHM VHVML EH] NRQLHF]QRFL SRGDZDQLD

QD]Z\ SOLNX XZDJD SU]HG SLHUZV]\P XUXFKRPLHQLHP SURJUDPX PXVLV] XWZRU]\ü
pusty plik o nazwie

KATALOG

DAT

, w przeciwnym przypadku próba otwarcia nie

SRZLHG]LHVL,QQ\PVSRVREHPMHVWX]XSHáQLHQLHPHQXRSROHFHQLD]DSLVXLRGF]\WX

GDQ\FKFRMHGQDNZL*HVL]NRQLHF]QRFLZ\ZRá\ZDQLDRGSRZLHGQLFKSROHFH-HOi

ZUHV]FLHFKFHV]GDüX*\WNRZQLNRZLPR*OLZRü]PLDQ\QD]Z\SOLNX]GDQ\PLPXVLV]

X]XSHáQLüSURJUDPRRGSRZLHGQLHLQVWUXNFMHZF]\WXMFHM]NODZLDWXU\

'R SU]HFKRZ\ZDQLD GDQ\FK PR*QD UyZQLH* Z\NRU]\VWDü SOLN WHNVWRZ\ MHGQDN RSH-

UDFMHRGF]\WXL]DSLVXEGQLHFREDUG]LHMVNRPSOLNRZDQH:\PLDQDGDQ\FK]SOLNLHP

WHNVWRZ\P RGE\ZD VL WDN VDPR MDN ] PRQLWRUHP L NODZLDWXU D ZLF SRV]F]HJyOQH

SRODUHNRUGyZQDOH*\]DSLV\ZDüLRGF]\W\ZDüLQG\ZLGXDOQLH:]DPLDQ]DWRX]\VNX-

MHP\ PR*OLZRü áDWZHJR REHMU]HQLD WUHFL SOLNX JG\* ]DZLHUD RQ Z\áF]QLH WHNVW
a

WDN*HVNLHURZDQLDOXERGF]\WDQLDGDQ\FKGR]MHGQHJR]HVWDQGDUGRZ\FKXU]G]H

Z\MFLDZHMFLDREVáXJLZDQ\FKSU]H]V\VWHPRSHUDF\MQ\QSGUXNDUNL2WRSU]\NáDG

SURFHGXU\ ]DSLVXMFHM NDWDORJ GR SOLNX WHNVWRZHJR RSHUDFM RGF]\WX PR*HV] ]UHDOL-

]RZDüZUDPDFKüZLF]H

procedure ZapiszNaDysku(NazwaPliku : string);

var
f : text; { tym razem plik tekstowy }
i : integer;

begin

DVVLJQI1D]ZD3OLNX^VNRMDU]SOLN]H]PLHQQSOLNRZ`

rewrite(f); { utwórz plik }
for i := 1 to LbPoz do { zapisz kolejne rekordy }
with Katalog[i] do

^Z\SURZDG(SRV]F]HJyOQHSRODUHNRUGX`

begin
writeln(f, 'Pozycja katalogu: ', i);
writeln(f, 'Tytul: ', Tytul);
writeln(f, 'Autor: ', Autor);
if Wypozyczajacy = '' then

^QLNWQLHZ\SR*\F]\á`

writeln(f, 'Ksiazka znajduje sie na polce.')
else

^SROH]DZLHUDQD]ZLVNRZ\SR*\F]DMFHJR`

writeln(f, 'Wypozyczajacy: ', Wypozyczajacy);
writeln(f);
end;
close(f); { zamknij plik }
end;

6SRVyE]DSLVDQLDWUHFLUHNRUGXGRSOLNXSU]\SRPLQDSURFHGXU

WypiszDane

(zobacz

SRSU]HGQLUR]G]LDá]W\P*HND*GDLQVWUXNFMD

write

(

X]XSHáQLRQDMHVWRVSHF\IL-

NDFM]PLHQQHMSOLNRZHMQS

writeln(f, 'Autor: ', Autor);

108 Turbo

Pascal

—

programowanie

2GF]\W\ZDQLHGDQ\FK]SOLNyZWHNVWRZ\FKQDVWUF]DQLHFRZLFHMNáRSRWyZ]ZáDV]F]D

JG\SOLN]DZLHUDLQIRUPDFMHPLHV]DQ\FKW\SyZWHNVWLOLF]E\&HQ]DÄOX(Q\´IRUPDW

]DSLVXMHVWQDMF]FLHMNRQLHF]QRüWZRU]HQLDVNRPSOLNRZDQ\FKSURFHGXUUHDOL]XMF\FK

NRQZHUVMHW\SyZLVSUDZG]DQLHSRSUDZQRFLGDQ\FK

1DV]F]FLHSOLNLWHNVWRZHSRVLDGDMUyZQLH*]DOHW\MHGQ]QLFKMHVWZáDQLHF]\WHOQ\

IRUPDW3RQLHZD*VWDQGDUGRZHXU]G]HQLDZ\MFLRZHVZV\VWHPLH'26REVáXJLZDQH

WDNVDPRMDNSOLNLWHNVWRZHDE\Z\SURZDG]LüWUHüNDWDORJXQDHNUDQW]ZNRQVRO

RSHUDWRUVNZ\VWDUF]\QDVWSXMFHZ\ZRáDQLH

ZapiszNaDysku('con');

]DDE\Z\GUXNRZDüNDWDORJQDGUXNDUFHPXVLV]X*\üZ\ZRáDQLD

ZapiszNaDysku('prn');

gdzie

con

prn

VQD]ZDPLV\VWHPRZ\FKXU]G]HZ\MFLDNRQVROLLGUXNDUNL

1D NRQLHF ZUyFLP\ QD FKZLO GR SOLNyZ HOHPHQWRZ\FK E\ SRZLHG]LHü NLOND VáyZ
o

PHWRGDFK UHDOL]RZDQLD VZRERGQHJR GRVWSX GR GDQ\FK %LH*F\ HOHPHQW SOLNX WM

HOHPHQWNWyUHJRGRW\F]\áDEG]LHNROHMQDLQVWUXNFMD

read

lub

write

) wskazywany jest

SU]H]ZVSRPQLDQ\MX*ZVND(QLNSOLNRZ\:\ZRáDQLH

Seek(zmienna-plikowa, numer-elementu)

SRZRGXMHXVWDZLHQLHZVND(QLNDSOLNRZHJRWDNE\NROHMQDRSHUDFMDRGF]\WXOXE]DSLVX

UR]SRF]áDVLRGHOHPHQWXGDQHJR

numerem-elementu

(el

HPHQW\QXPHURZDQHVRG

]HUD 'RGDWNRZ\PL IXQNFMDPL Z\NRU]\VW\ZDQ\PL SRGF]DV PDQLSXORZDQLD ZVND(ni-

NLHPSOLNRZ\PV

FilePos

]ZUDFDMFDMHJRELH*FZDUWRüRUD]

FileSize

, zwraca-

MFDUR]PLDUSOLNX7DNZLF—]DNáDGDMF*H

jest plikiem typu

file of integer

—

Z\ZRáDQLH

Seek(f, FileSize(f));

XVWDZLZVND(QLNSOLNRZ\]DRVWDWQLPHOHPHQWHPSOLNXF]\OLSU]\JRWXMHSOLNGRGRSLV\-

ZDQLD]DNRQVWUXNFMD

for i := 1 to 10 do
begin
Seek(f, random(FileSize(f));
read(f, i);
writeln(i);
end;

odczy

WD ] SOLNX G]LHVLü ORVRZR Z\EUDQ\FK OLF]E IXQNFMD

random(k)

]ZUDFD OLF]E

SVHXGRSU]\SDGNRZ]]DNUHVXRG]HUDGR

LZ\ZLHWOLMHQDHNUDQLH

6ZRERGQ\GRVWSGRGDQ\FKFKRFLD*EDUG]RSU]\GDWQ\QLHSRZLQLHQE\üQDGX*\ZDQ\

:V]HONLHRSHUDFMHQDSOLNDFKV]QDF]QLHEDUG]LHMF]DVRFKáRQQHQL*RSHUDFMHQDGDQ\FK

XPLHV]F]RQ\FKZSDPLFL]DRSHUDFMHZWU\ELHVHNZHQF\MQ\PV]QDF]QLHV]\EV]H

QL* Z WU\ELH GRVWSX VZRERGQHJR 1LH]DOH*QLH RG W\FK XZDJ PXVLV] SDPLWDü *H

ZV]HONLHPDQLSXODFMHQD]DZDUWRFLSOLNyZZL*VL]U\]\NLHPXWUDW\GDQ\FKZSU]\-

SDGNX DZDULL V\VWHPX QS Z\áF]HQLD ]DVLODQLD 'ODWHJR WH* SOLNL QDOH*\ ]DP\NDü

EH]SRUHGQLRSRZ\NRQDQLXQLH]EGQ\FKF]\QQRFL

3OLNLF]\OLMDNXFKURQLüGDQHSU]HG]JXE

109

=DSDPLWDM

•

'RWUZDáHJRSU]HFKRZ\ZDQLDLQIRUPDFMLZV\VWHPLHNRPSXWHURZ\PVáX*SOLNL

•

7XUER3DVFDOXPR*OLZLDREVáXJSOLNyZHOHPHQWRZ\FKWHNVWRZ\FKRUD]DPRU-
ficznych.

•

3OLNL HOHPHQWRZH VNáDGDM VL ] HOHPHQWyZ WHJR VDPHJR W\SX SURVWHJR OXE

VWUXNWXUDOQHJR/LF]EDHOHPHQWyZMHVW]DZV]HFDáNRZLWD

•

3OLNLWHNVWRZH]DZLHUDMGDQHUHSUH]HQWRZDQHZSRVWDFLZLHUV]\WHNVWX0R*QD

LFKX*\ZDüGRSU]HFKRZ\ZDQLDGDQ\FKUy*Q\FKW\SyZ

•

3OLNL HOHPHQWRZH XPR*OLZLDM GRVWS VZRERGQ\ QDWRPLDVW SOLNL WHNVWRZH

SR]ZDODMZ\áF]QLHQDGRVWSVHNZHQF\MQ\

•

3OLN UHSUH]HQWRZDQ\ MHVW Z SURJUDPLH SU]H] ]PLHQQ SOLNRZ NWyU QDOH*\

VNRMDU]\ü]IL]\F]Q\PSOLNLHP]DSRPRFSURFHGXU\

assign

•

2SHUDFMH QD ]DZDUWRFL SOLNX PXV] E\ü SRSU]HG]RQH MHJR RWZDUFLHP

reset

lub

rewrite

) i

]DNRF]RQH]DPNQLFLHP (

•

6ZRERGQ\GRVWSGRHOHPHQWyZSOLNXXPR*OLZLDSURFHGXUD

Seek

XVWDZLDMFD

ZVND(QLNSOLNRZ\QD]DGDQHMSR]\FML

•

0HFKDQL]P\ REVáXJL SOLNyZ WHNVWRZ\FK XPR*OLZLDM SU]HV\áDQLH GDQ\FK QLH

W\ONR QD G\VN OHF] UyZQLH* ] L GR VWDQGDUGRZ\FK XU]G]H ZHMFLD-Z\MFLD
systemu operacyjnego.

110 Turbo

Pascal

—

programowanie

àDFXFK\

'DQH WHNVWRZH PDM — obok grafiki — QDMZLNV]\ XG]LDá Z REMWRFL LQIRUPDFML

SU]HWZDU]DQHMLSU]HFKRZ\ZDQHMZHZVSyáF]HVQ\FKV\VWHPDFKNRPSXWHURZ\FK=WHJR

WH*Z]JOGXND*G\V]DQXMF\VLM]\NZ\VRNLHJRSR]LRPXMHVWZ\SRVD*RQ\ZPHFKD-
niz

P\ SR]ZDODMFH QD UHSUH]HQWRZDQLH SU]Hchowywanie i przetwarzanie tekstów.

7XUER3DVFDOXVáX*\GRWHJRW\SáDFXFKRZ\

string

NWyU\P]DMPLHP\VLZW\P

UR]G]LDOH 'RZROQ\ WHNVW áDFXFK DQJ string) przechowywany jest w programie
w

SRVWDFLFLJX]QDNyZNWyU\PR*HE\üLQWHUSUHWRZDQ\MDNRVSHF\ILF]QDWDEOLFD

array[0..255] of char

3U]\NáDGRZDGHNODUDFMD]PLHQQHMáDFXFKRZHMPDSRVWDü

var
Napis : string;

6WDáHáDFXFKRZH]DSLVXMHVLQDWRPLDVWZSRVWDFLFLJyZ]QDNyZXMW\FKZDSRVWURI\

SRGREQLHMDNVWDáH]QDNRZH

const
STALY_NAPIS = 'Turbo Pascal';

=HURZ\ HOHPHQW áDFXFKD SU]HFKRZXMH MHJR DNWXDOQ GáXJRü W]Z GáXJRü G\QD-

PLF]Q EGF W\SX ]QDNRZHJR PR*H RQ SU]\MPRZDü ZDUWRFL RG GR 6WG

ZáDQLH Z\QLND RJUDQLF]HQLH GáXJRFL áDFXFKD GR ]QDNyZ FR ]UHV]W Z

ZLNV]RFLSU]\SDGNyZZ\VWDUF]DD*QDGWR$E\ÄVNUyFLü´áDFXFKGDQDW\SX

string

]DMPXMH ]DZV]H EDMWyZ QLH]DOH*QLH RG U]HF]\ZLVWHM GáXJRFL WHNVWX PR*QD

Z\NRU]\VWDüGHNODUDFM

nazwa-zmiennej : string

>GáXJRü@

0R*OLZRü WD MHVW V]F]HJyOQLH FHQQD MHOL Z SURJUDPLH Z\NRU]\VWXMHV] QS WDEOLF

áDFXFKyZ GHNODUXMF HOHPHQW VNáDGRZ\ WDEOLF\ MDNR

string[20]

RV]F]G]DV]

EDMWyZ FR SU]\ VWX HOHPHQWDFK GDMH ]\VN SRQDG N% :DUWR ]DXZD*\ü *H SUyED

]DSLVDQLD GR ÄVNUyFRQHJR´ áDFXFKD WHNVWX GáX*V]HJR QL* SR]ZDOD GHNODUDFMD QLH

VSRZRGXMHEáGXDMHG\QLHREFLFLHQDGPLDURZ\FK]QDNyZ

àDFXFK\

111

2SHUDFMH QD áDFXFKDFK Z ]DVDG]LH QLH Uy*QL VL ]DSLVHP RG RSHUDFML QD ]PLHQQ\FK

W\SXSURVWHJRLQLHZ\PDJDMVWRVRZDQLD*DGQ\FKVSHFMDOQ\FKV]WXF]HN'RZSURZD-
dzania, wyprowadzania i przyp

LV\ZDQLDáDFXFKyZZ\NRU]\VWXMHVL— podobnie jak

dla zmiennych typów prostych — procedury

read

(

write

(

) oraz operator

SU]\SLVDQLD5yZQLH*SRUyZQDQLHGZyFKáDFXFKyZ]DSLV\ZDQHMHVWLGHQW\F]QLHSU]\

F]\PÄZHZQWU]QLH´RGE\ZDVLRQRSU]H]SRUyZQDQLHNRGyZRGSRZLDGDMF\FKVRELH

]QDNyZ7DNZLF

'C' < 'Pascal'

(kod ASCII znaku 'C' jest mniejszy od kodu 'P')

'c' > 'Pascal'

NRG$6&,,]QDNXFMHVWZLNV]\RGNRGX3

'C' > ''

GRZROQ\áDFXFKMHVWZLNV]\RGáDFXFKDSXVWHJR

Z rzeczy prostych poz

RVWDáRMHV]F]HGRGDZDQLHáDFXFKyZSROHJDMFHQDLFK]Z\Ná\P

ÄVNOHMDQLX´ QLHVWHW\ áDFXFKyZ QLH GD VL RGHMPRZDü PQR*\ü DQL G]LHOLü -H*HOL
zmienna

lancuch1

zawiera tekst

'Turbo'

lancuch2

— tekst

'Pascal'

, to

wynikiem sklejenia obu zmiennych:

wynik := lancuch1 + lancuch2;

EG]LHRF]\ZLFLHWHNVW

'TurboPascal'

5yZQLH* RGZRáDQLD GR SRV]F]HJyOQ\FK ]QDNyZ áDFXFKD UHDOL]XMH VL Z VSRVyE HOH-

PHQWDUQ\3RQLHZD*PR*HRQE\üWUDNWRZDQ\MDNRWDEOLFD]QDNyZLQVWUXNFMD

s[5] := 'x'

wstawi znak

QDSLWSR]\FMZáDFXFKX

%DUG]LHM Z\P\OQH RSHUDFMH QD áDFXFKDFK Z\PDJDM X*\FLD VSHFMDOQLH GR WHJR FHOX

SU]H]QDF]RQ\FKIXQNFML]NWyU\FKQDMZD*QLHMV]HRSLVDQRSRQL*HM

Length(s)

— z

ZUDFDELH*FGáXJRüáDFXFKD

;

Concat(s1, s2

) — s

NOHMDáDFXFK\

(podobnie, jak operator

)

Copy(s, m, n)

— z

ZUDFDSRGáDFXFKRGáXJRFL

]QDNyZZ\FLW\]áD-

cucha

SRF]\QDMFRGSR]\FML

;

Pos(ch, s)

— z

ZUDFDQXPHUSR]\FMLQDNWyUHMZáDFXFKX

znajduje

VL]QDN

;

Delete(s, m, n)

— usuwa

]QDNyZ]áDFXFKD

poc

]\QDMFRGSR]\FML

-DN SRZLHG]LDQR Z\*HM DNWXDOQ GáXJRü áDFXFKD PR*QD RGF]\WDü IXQNFM

Length

OXE SU]H] EH]SRUHGQLH RGZRáDQLH GR ]HURZHM NRPyUNL áDFXFKD $E\ ]PLHQLü

GáXJRüG\QDPLF]QáDFXFKDPXVLV]X*\üNRQVWUXNFML

s[0] := chr[n]

gdzie

MHVW *GDQ GáXJRFL SRQLHZD* áDFXFK VNáDGD VL ]H ]QDNyZ PXVLP\

SU]HNV]WDáFLü OLF]E

QD RGSRZLDGDMF\ MHM ]QDN IXQNFM

chr

3RQLHZD*RSHUDFMDWD

F]DVHPSU]\QRVLQLH]E\WSR*GDQHHIHNW\OHSLHMMHMXQLNDü

112 Turbo

Pascal

—

programowanie

3U]\WRF]RQ\ SRQL*HM SURJUDP

Lancuchy

demonstru

MH QLHNWyUH PR*OLZRFL REUyENL

áDFXFKyZ L Z ]DVDG]LH QLH Z\PDJD GRGDWNRZHJR NRPHQWDU]D 3R]D Z\ZRáDQLDPL

RSLVDQ\FK Z\*HM SURFHGXU ]QDOD]áD VL Z QLP UyZQLH* IXQNFMD

UpCase

SU]HNV]WDáFDMFD PDá OLWHU DOIDEHWX QD GX* 2SHUXMH RQD FR SUDZGD QD W\SLH

]QDNRZ\P MHGQDN W\SRZH MHM ]DVWRVRZDQLH VSURZDG]D VL GR NRQZHUVML FDá\FK

áDFXFKyZMDNSRND]DQRQL*HM

program Lancuchy;

^'HPRQVWUDFMDRSHUDFMLQDáDFXFKDFK`

const
TP = 'Turbo Pascal to bomba';

var
s1, s2 : string;
i : integer;

begin
s1 := TP; { przypisanie }

V ^MZáDFXFKSXVW\`

for i := 1 to Length(s1) do

V V^GRGDZDQLHáDFXFKyZ]QDNyZ`

writeln(s1);

i := Pos('a', s1); { wyszukanie znaku }
s2[i] := '^'; { wstawienie znaku }

ZULWHOQV^LFR]WHJRZ\QLNáR"`

'HOHWHV^XVXQLFLHF]FLáDFXFKD`

writeln(s1);

for i := Length(s1) downto 1 do

^Z\SLVDQLHáDFXFKD`

^RGW\áX`

write(s1[i]);
writeln;

for i := 1 to Length(s1) do { zamiana na

GX*H]QDNL`

write(UpCase(s1[i]));
writeln;

V &RS\73^Z\FLFLHSRGáDFXFKD`

  for i := Length(s1) downto 1 do
  begin
writeln(s1);

'HFV>@^VNUDFDQLHáDFXFKD`

end;
end.

1D]DNRF]HQLHWHJRUR]G]LDáXZVSRPQLP\RDOWHUQDW\ZQHMPHWRG]LHUHSUH]HQWRZDQLD
danych tekstowych — tak zwanych

áDFXFKDFK ]DNRF]RQ\FK ]HUHP (ang. null-

terminated string

]ZDQ\FKWH*$6&,,=àDFXFK$6&,,=SRGREQLHMDN

string

) jest

]Z\NáWDEOLF]QDNyZMHGQDNQLHSRVLDGDSRODSU]HFKRZXMFHJRGáXJRüZ]DPLDQ]D

àDFXFK\

113

WR MHJR NRQLHF V\JQDOL]RZDQ\ MHVW ]QDNLHP R NRG]LH QLH P\OLü ]H ]QDNLHP Ä´

(IHNW\ZQDSRMHPQRüáDFXFKD$6&,,=RJUDQLF]RQDMHVWZLHONRFLGRVWSQHMSDPLFL

ZSUDNW\FHGRN%DZLFMHVW]QDF]QLHZLNV]DQL*GODW\SX

string

àDFXFK\$6&,,=GRVWSQHSRF]ZV]\RGZHUVML7XUER3DVFDODGHNODURZDQHV

MDNR]Z\NáHWDEOLFH]QDNyZLQGHNVRZDQHRG]HUDQS

var
BardzoDlugiLancuch : array[0..10000] of char;

(OHPHQWDUQD REVáXJD áDFXFKyZ $6&,,= ZF]\W\ZDQLHZ\SURZDG]DQLe, przypisywa-

QLHUHDOL]RZDQDMHVWWDNVDPRMDNGOD]Z\Ná\FKáDFXFKyZSRGZDUXQNLHPZáF]HQLD

W]ZUR]V]HU]RQHMVNáDGQLG\UHNW\ZNRPSLODWRUD

{$X+}

(Options-Compiler-Extended

Syntax

%DUG]LHM ]áR*RQH RSHUDFMH QD áDFXFKDFK $6&,,= NRSLRZDQLH

porównywanie, przeszukiwanie, konwersja do typu

string

LYLFHYHUVDUHDOL]RZDQHV

przez procedury zawarte w module bibliotecznym

Strings

RPRGXáDFKZNUyWFHLQLH

EG WX RPDZLDQH :DUWR ZUHV]FLH ZVSRPQLHü R W\SLH ZVND(QLNRZ\P

PChar

XPR*OLZLDMF\PPDQLSXORZDQLHQDG\QDPLF]QLHWZRU]RQ\FKLXVXZDQ\FKáDFXFKDFK
ASCIIZ.

3RQLHZD* Z ZLNV]RFL SU]\SDGNyZ W\S

string

]QDNRPLFLH VSHáQLD VZRMH ]DGDQLH

SRSU]HVWDQLHP\QDSRZ\*V]\FKZ]PLDQNDFKRGV\áDMF]DLQWHUHVRZDQ\FK&]\WHOQLNyZ

GRV\VWHPXSRPRF\LOLWHUDWXU\>@:QDVWSQ\PUR]G]LDOH]DMPLHP\VLSUREOHPHP

EUDNX SDPLFL F]\OL ZVSRPQLDQ\P SU]HG FKZLO G\QDPLF]Q\PWZRU]HQLHPLXVXwa-
niem zmiennych.

=DSDPLWDM

•

'R SU]HFKRZ\ZDQLD GDQ\FK WHNVWRZ\FK QDSLVyZ VáX*\ Z 7XUER 3DVFDOX W\S

string

•

àDFXFK W\SX

string

jes

W VSHF\ILF]Q WDEOLF R SRMHPQRFL GR ]QDNyZ

SU]\ F]\P ELH*FD GáXJRü áDFXFKD SU]HFKRZ\ZDQD MHVW Z ]HURZHM NRPyUFH
tablicy.

•

=DNUHVSRGVWDZRZ\FKRSHUDFMLQDáDFXFKDFKREHMPXMHZSURZDG]DQLHZ\SUR-
wa

G]DQLH SU]\SLV\ZDQLH L SRUyZQ\ZDQLH UHDOL]RZDQH ]D SRPRF ÄVWDQdar-

dowych” procedur i operatorów).

•

%DUG]LHM]DDZDQVRZDQHRSHUDFMHQDáDFXFKDFKWRNRSLRZDQLHSU]HV]XNLZDQLH

Z\FLQDQLHLVNUDFDQLH2SHUDFMHWHUHDOL]RZDQHV]DSRPRFVSHFMDOQ\FKIXQNFML
i procedur.

•

7XUER 3DVFDO XPR*OLZLD UyZQLH* NRU]\VWDQLH ] áDFXFKyZ ]DNRF]RQ\FK
zerem (ASCIIZ).

114 Turbo

Pascal

—

programowanie

:LFHMSDPLFL

-DNE\üPR*HMHV]F]HSDPLWDV]SU]\VWSXMFGRSLVDQLDQDV]HJRSURJUDPXELEOLRWHF]-

QHJRRNUHOLOLP\PDNV\PDOQOLF]ESR]\FMLUHNRUGyZQDRNRáR2JUDQLF]HQLHWR

Z\QLNDáR]ZLHONRFLGRVWSQHMSDPLFLNWyU]NROHLRV]DFRZDOLP\QD]JUXEV]D

N% 'ODF]HJR MHGQDN W\ONR W\OH" : FKZLOL REHFQHM WUXGQR MHVW ]QDOH(ü NRPSXWHU 3&

SRVLDGDMF\ PQLHM QL* 0% SDPLFL ]D VWDQGDUGHP MHVW OXE 0% &R SUDZGD
system operacyjny DOS, pod nad

]RUHP NWyUHJR SUDFXM SURJUDP\ SDVFDORZH XPR*-

OLZLDGRVWSW\ONRGRN%DOHLWDNSURJUDP

program IlePamieci;

begin
writeln('Masz w tej chwili ', MemAvail, ' bajtow wolnej
pamieci.');
end.

SRND*H]DSHZQHOLF]EZLNV]RGN%-DN]DWHPGREUDüVLGRSR]RVWDáHMSDPLFL"

=DF]QLHP\RGPDáHMGDZNLWHRULL:V]\VWNLH]PLHQQHNWyU\PLSRVáXJLZDáHVLGRWHM

SRU\ QDOH*Dá\ GR NODV\ ]PLHQQ\FK JOREDOQ\FK MHOL ]GHILQLRZDáH MH QD SRF]WNX

SURJUDPX OXE ORNDOQ\FK MH*HOL ]RVWDá\ ]GHILQLRZDQH Z SURFHGXUDFK). Zmienne glo-

EDOQHXPLHV]F]DQHVZW]Zsegmencie danychNWyUHJRZLHONRüZ\QRVLN%LMHVW

VWDáD]PLHQQHORNDOQHSU]HFKRZ\ZDQHVZsegmencie stosuNWyUHJRZLHONRüPR*QD

]PLHQLDüZJUDQLFDFKRGGRN%=PLHQQHJOREDOQHVstatyczneWMLVWQLHMSU]H]

FDá\F]DVZ\NRQ\ZDQLDSURJUDPXQDWRPLDVW]PLHQQHORNDOQHÄ*\M´W\ONRWDNGáXJR

MDN GáXJR Z\NRQXM VL SRVLDGDMFH MH SURFHGXU\ OXE IXQNFMH .RQLHF NRFyZ QD

]PLHQQHPR*HP\SU]H]QDF]\üFRQDMZ\*HMNLOREDMWyZ]F]HJRN%GRVWSQHMHVW
„warunkowo”. Skoro jednak program

IlePamieci

SRND]Dá PDP QDG]LHM *H

SDPLFLPDV]QLHFRZLFHMPXVLP\]QDOH(üVSRVyEQDMHMZ\NRU]\VWDQLH

6SRVREHP W\P V WDN ]ZDQH zmienne wskazywane : RGUy*QLHQLX RG Ä]Z\Ná\FK´

]PLHQQ\FK ]PLHQQH ZVND]\ZDQH PRJ E\ü XPLHV]F]DQH Z GRZROQ\P PLHMVFX SD-

PLFL]F]\PZL*HVLQLHFRLQQ\VSRVyERGZRá\ZDQLDGRQLFKZ\NRU]\VWXMF\W]Z

ZVND(QLNL.

Wiecej

pamieci!

115

ND(QLNGR]PLHQQHMMHVWSRSURVWXMHMDGUHVHPF]\OLOLF]ERSLVXMFMHMSRáR*HQLH

SDPLFL 5y*QLF SRPLG]\ ]PLHQQ VWDW\F]Q D ZVND]\ZDQ LOXVWUXMH SRQL*V]\

rysunek:

Rysunek 12.

6SRVyEREVáXJL]PLHQQ\FKVWDW\F]Q\FKDLZVND]\ZDQ\FKE

-DN ZLGDü GRVWS GR ]PLHQQHM ZVND]\ZDQHM RGE\ZD VL GZXHWDSRZR ]D SRUHGnic-

WZHPZVND(QLNDSURJUDPRGF]\WXMHZDUWRüWHJRRVWDWQLHJRF]\OLDGUHV]PLHQQHMLQD

MHMSRGVWDZLHRGZRáXMHVLGRZáDFLZHM]PLHQQHMSRáR*RQHMZSDPLFLZPLHMVFXRSL-
sanym adresem (w naszym przypadku 3CA6F szesnastkowo). Metoda ta powoduje

QLH]QDF]QHZ\GáX*HQLHF]DVXGRVWSXGR]PLHQQHMDOHSR]ZDOD]DWRXPLHFLüMSUDN-

W\F]QLHZGRZROQ\PPLHMVFXSDPLFLGRNáDGQLH]PLHQQHZVND]\ZDQHXPLHV]F]DQHV
na tzw. stercie (ang. heap) — wydzi

HORQ\P REV]DU]H SDPLFL ]DU]G]DQ\P SU]H]

specjalne procedury).

'HNODUDFMDZVND(QLNDGR]PLHQQHMRNUHORQHJRW\SXMHVWEDUG]RSRGREQDGRÄ]Z\NáHM´

GHNODUDFML]PLHQQHMLUy*QLVLRGQLHMMHG\QLHV\PEROHPZVND(QLND

zmienna : ^typ

przy czym

typ

PXVLE\üLGHQW\ILNDWRUHPW\SXSURVWHJROXE]GHILQLRZDQHJRZF]HQLHM

w sekcji

type

2GZRáDQLHGRVDPHJRZVND(QLNDZ\JOGDGRNáDGQLHWDNVDPRMDNGOD

ND*GHM LQQHM ]PLHQQHM QDWRPLDVW RGZRáDQLH GR ZVND]\ZDQHM SU]H] QLHJR ]PLHQQHM
zawiera dodatkowo znaczek

, tym raz

HPSRáR*RQ\]DQD]ZZVND(QLND

zmienna^

$RWRNLONDSU]\NáDGyZ

type
TabReal = array[1..200] of real; { tablica 100 liczb real }

37DE5HDO A7DE5HDO^ZVND(QLNGRWDEOLF\`

string100 = string

>@^VNUyFRQ\áDFXFK`

var
TabTabReal : array[1..200] of

37DE5HDO^WDEOLFDZVND(QLNyZ`

3VWULQJAVWULQJ^ZVND(QLNGRáDFXFKD`

SLALQWHJHU^ZVND(QLNGROLF]E\LQWHJHU`

116 Turbo

Pascal

—

programowanie

{ ... }

TabTabReal[10]^[30] := 12.345;
Pstring100^ := 'Lancuch dynamiczny';
writeln(PString100^);

1DV]F]HJyOQXZDJ]DVáXJXMHWX]PLHQQD

TabTabReal

EGFDWDEOLFZVND(QLNyZ

do tablic liczb rzeczywistych. Struktura tego typu pozwala na efektywne przechowanie

GZXZ\PLDURZHM WDEOLF\ VNáDGDMFHM VL ] ZLHUV]\ ZVND]\ZDQ\FK ZVND(QLNDPL

]DZLHUDMF\FKSROLF]END*G\F]\OLZVXPLHW\VLF\OLF]ERREMWRFLRNRáR

N%8PLHV]F]RQQLHFRQL*HMLQVWUXNFM

TabTabReal[10]^[30] := 12.345

PR*QD

Z\WáXPDF]\ü MDNR RGZRáDQLH GR WU]\G]LHVWHM NRPyUNL Z G]LHVLW\P ZLHUV]X F]\OL

WDEOLF\ ZVND]\ZDQHM SU]H] G]LHVLW\ ZVND(QLN Z WDEOLF\

TabTabReal

. Jak nietrudno

VL MX* GRP\OLü JáyZQ\P ]DVWRVRZDQLHP ZVND(QLNyZ MHVW REVáXJD GX*\FK VWUXNWXU

GDQ\FK QS WDEOLF UHNRUGyZ F]\OL NDWDORJyZ ELEOLRWHF]Q\FK = WHJR WH* Z]JOGX

PDá\VHQVPDGHNODUDFMD]PLHQQHM

JG\*OLF]EDW\SX

integer

zajmuje dwa bajty,

]DZVND(QLN— cztery.

:DUWR WX MHV]F]H ZVSRPQLHü *H RSUyF] ZVND(QLNyZ GR RELHNWyZ NRQNUHWQHJR W\pu

7XUER 3DVFDO XGRVWSQLD UyZQLH* ZVND(QLNLDPRUILF]QHWMZVND]XMFHQDREV]DUSD-

PLFL L QLH ]ZL]DQH ] *DGQ\P NRQNUHWQ\P W\SHP :VND(QLN WDNL GHNODURZDQ\ MHVW

VáRZHP

pointer

(

ZVND(QLNLMHVW]JRGQ\SRGZ]JOGHPSU]\SLVDQLD]LQQ\PLW\SDPL

ZVND(QLNRZ\PL 7\S

pointer

L ]ZL]DQH ] QLP RSHUDFMH Z\NRU]\VW\ZDQH V SU]H]

EDUG]LHM ]DDZDQVRZDQ\FK SURJUDPLVWyZ GR EH]SRUHGQLHJR ÄQLVNRSR]LRPRZHJR´

PDQLSXORZDQLD]DZDUWRFLSDPLFL

'UXJEDUG]RZD*QLSR*\WHF]QFHFK]PLHQQ\FKZVND]\ZDQ\FKMHVWPR*OLZRüLFK

WZRU]HQLD L QLV]F]HQLD Z ]DOH*QRFL RG SRWU]HE :\PDJD WR FR SUDZGD X*\FLD VSHF-

MDOQ\FKSURFHGXUSR]ZDODMHGQDNQD]QDF]QLHEDUG]LHMHIHNW\ZQJRVSRGDUNSDPLFL

: RGUy*QLHQLX RG VWDW\F]Q\FK ]PLHQQ\FK JOREDOQ\FK LVWQLHMF\FK SU]H] FDá\ F]DV

Z\NRQ\ZDQLDSURJUDPX]PLHQQHZVND]\ZDQHQDOH*GRNODV\]PLHQQ\FKdynamicz-
nych

F]\OL LVWQLHM GRNáDGQLH ZWHG\ JG\ *\F]\ VRELH WHJR SURJUDPLVWD 6DP SURFHV

utworzenia zmiennej dynamicznej polega na zarezerwowaniu odpowiedniego obszaru

SDPLFLL]DSDPLWDQLXDGUHVXWHJRREV]DUXZHZVND(QLNXZVND]XMF\PQD]PLHQQ
Z

NROHL XVXQLFLH ]PLHQQHM SRZRGXMH Ä]ZROQLHQLH UH]HUZDFML´ ]DZDUWRFL ]PLHQQHM

RUD]ZVND(QLNDQLHVIL]\F]QLHQLV]F]RQHDOHOHSLHMVLMX*GRQLFKQLHRGZRá\ZDü

&HQ ]D PR*OLZRü VZRERGQHJR SU]\G]LHODQLD L ]ZDOQLDQLD SDPLFL MHVW NRQLHF]QRü

EH]Z]JOGQHJR LQLFMDOL]RZDQLD ZVND(QLNyZ NWyUH SU]HG XWZRU]HQLHP ZVND]\ZDQHM

]PLHQQHMPDMZDUWRüQLHRNUHORQ]Z\NOH]HURFRRGSRZLDGDZVND(QLNRZL

nil

, nie

wskazu

MFHPXQD*DGHQRELHNW3UyEDRGF]\WX]Piennej wskazywanej przez taki wska-

(QLN GRVWDUF]\ ÄW\ONR´ EH]VHQVRZQHJR Z\QLNX QDWRPLDVW SUyED ]DSLVX Z

SU]\SDGNRZH PLHMVFH SDPLFL PR*H VNRF]\ü VL ]DZLHV]HQLHP NRPSXWHUD OXE

]XSHáQLHQLHSU]HZLdzianym jego zachowaniem.

3DPLWDMRLQLFMDOL]DFMLZVND(QLNyZ

:LFHMSDPLFL

117

Turbo Pascal oferuje kilka metod tworzenia i usuwania zmiennych dynamicznych,
z

NWyU\FKQDMSRSXODUQLHMV]UHDOL]XMHSDUDSURFHGXU

new

dispose

QHZZVND(QLN

-do-zmiennej)

GLVSRVHZVND(QLN

-do-zmiennej)

Procedura

new

Z\NRQXMH F]\QQRFL ]ZL]DQH ] utworzeniem zmiennej wskazywanej,

natomiast

dispose

—

RSHUDFMH ]ZL]DQH ] MHM XVXQLFLHP 'UXJ SDU ]DU]G]DMF

G\QDPLF]Q\PSU]\G]LDáHPSDPLFLWZRU]SURFHGXU\

GetMem

FreeMem

*HW0HPZVND(QLNUR]PLDU

-bloku)

)UHH0HPZVND(QLNUR]PLDU

-bloku)

: RGUy*QLHQLX RG SDU\

new

dispose

SURFHGXU\ WH Z\NRU]\VWXM ZVND(QLNL

amorficzne (typu

pointer

L VáX* GR EDUG]LHM ÄZHZQWU]QHJR´ PDQLSXORZDQLD

SDPLFLWMSU]\G]LHODQLDL]ZDOQLDQLDEORNyZEDMWyZDQLH]PLHQQ\FKZVND]\ZDQ\FK

MDNLHJR NRQNUHWQHJR W\SX :LHONRü SU]\G]LHODQHJR OXE ]ZDOQLDQHJR EORNX Z

EDMWDFK RNUHOD SDUDPHWU

rozmiar-bloku

.RU]\VWDMF ] REX JUXS SURFHGXU PXVLV]

SDPLWDü *H SDPLü SU]\G]LHORQD SU]H]

GetMem

QLH PR*H E\ü ]ZROQLRQD SURFHGXU

dispose

i odwrotnie.

2VWDWQLFK\EDQDMU]DG]LHMVWRVRZDQSDUWZRU]SURFHGXU\

mark

release

PDUNZVND(QLN

UHOHDVHZVND(QLN

Wykonanie procedury

mark

QLHSRZRGXMHSU]\G]LHOHQLDSDPLFLDQLXWZRU]HQLD]PLHQ-

QHMDMHG\QLH]DSDPLWDQLHELH*FHMÄZ\VRNRFL´VWHUW\Z]PLHQQHM

ZVND(QLN

. Zwol-

QLHQLD FDáHJR REV]DUX VWHUW\ OH*FHJR SRZ\*HM

ZVND(QLND

GRNRQXMH VL ]D SRPRF

procedury

release

2E\GZLH SURFHGXU\ VWRVRZDQH V — podobnie jak

GetMem

FreeMem

—

JáyZQLH Z SURJUDPRZDQLX QLVNLHJR SR]LRPX GR ÄPDVRZHJR´

]ZDOQLDQLDSDPLFLSU]\G]LHORQHMQDVWHUFLH

.RU]\VWDMF ]H ]PLHQQ\FK G\QDPLF]Q\FK PXVLV] SDPLWDü *H VWHUWD QLH MHVW DXWRPD-

W\F]QLHSRU]GNRZDQDWRWH*NROHMQHRSHUDFMHSU]\G]LHOHQLDL]ZROQLHQLDEORNyZSDPL-

FLGRZROQPHWRGPRJGRSURZDG]LüGRW]Zfragmentacji, czyli rozbicia wolnego
jeszcze obszaru

SDPLFL QD PQLHMV]H UR]áF]QH EORNL 3RQLHZD* UR]PLDU WZRU]RQHM

]PLHQQHMG\QDPLF]QHMQLHPR*HE\üZLNV]\RGUR]PLDUXQDMZLNV]HJRZROQHJREORNX

SDPLFLPR*HVLRND]Dü*HSUyEDXWZRU]HQLD]PLHQQHMVNRF]\VLQLHSRZRG]HQLHP

PLPRL*ZLHONRüGRVWSQHMSDPLFLEG]LHZ\VWDUF]DMFD'ODWHJRWH*ZáDFLZPLDU

PR*OLZRFLXWZRU]HQLDZLNV]HMVWUXNWXU\GDQ\FKQDVWHUFLHMHVWQLHIXQNFMD

MemAvail

]ZUDFDMFDVXPDU\F]Q\UR]PLDUZROQHMSDPLFLOHF]

MaxAvail

]ZUDFDMFDUR]PLDU

QDMZLNV]HJRZROQHJREORNX

UDQDSU]\NáDG\1DSRF]WHNSU]HGVWDZLP\Ä]ELRUF]´GHPRQVWUDFMPR*OLZRFLRE-

VáXJL]PLHQQ\FKG\QDPLF]Q\FK

program ZmienneDynamiczne;

type

118 Turbo

Pascal

—

programowanie

TabReal = array[1..5000] of real; { tablica liczb }
{ rzeczywistych }
PString = ^string

^ZVND(QLNGRáDFXFKD`

var

V36WULQJ^]PLHQQDW\SXZVND(QLNGRáDFXFKD`

TabTabReal : array[1..100] of ^TabReal; { tablica }

^ZVND(QLNyZ`

6WHUWDSRLQWHU^ZVND(QLNZ\VRNRFLVWHU

ty }

i : integer; { pomocniczy licznik }

procedure IlePamieci;

begin
writeln('Wolne: ', MemAvail, ' max. blok: ', MaxAvail,
' bajtow.');
end;

begin
writeln(s^); { zmienna nie utworzona }

QHZV^ZLFMWZRU]\P\`

writeln(s^); { utworzona, lecz nie zainicjalizowana }
s^ := 'No wreszcie!'; { inicjalizujemy }
writeln(s^); { teraz jest OK }
dispose(s); { usuwamy }

ZULWHOQVA^]PLHQQDQLH]RVWDáDFDáNRZLFLH]QLV]F]RQD`

mark(Sterta); { zaznaczamy 'poziom' sterty }

L ^WZRU]\P\WDEOLFWDEOLFG\QDPLF]Q\FK`

while MemAvail > SizeOf(TabReal) do { tyle wierszy )

^LOHVLGD`

begin

,OH3DPLHFL^LOHPDP\SDPLFL"`

new(TabTabReal[i]); { tworzymy nowy wiersz }

,QFL^]ZLNV]DP\LQGHNVZLHUV]D`

end;
dispose(TabTabReal[3]); { usuwamy jeden wiersz tablicy }
IlePamieci;

UHOHDVH6WHUWD^]ZDOQLDP\KXUWHPFDáSDPLü`

IlePamieci;
end.

3LHUZV]D F]ü SURJUDPX GHPRQVWUXMH HWDS\ WZRU]HQLD Z\NRU]\VWDQLD L XVXQLFLD

]PLHQQHM ZVND]\ZDQHM Z QDV]\P SU]\SDGNX áDFXFKD ]D SRPRF SURFHGXU

new

dispose

=DXZD**HXWZRU]HQLH]PLHQQHMZVND]\ZDQHMQLHMHVWUyZQR]QDF]QH]MHM

LQLFMDOL]DFM D SR Z\NRQDQLX SURFHGXU\

dispose

WUHü áDFXFKD QLH MHVW QLV]F]RQD

FKRFLD*PR*HE\üQLHNRPSOHWQD

'UXJD F]ü WZRU]\ W\SRZ VWUXNWXU ZLHONLHM WDEOLF\ SU]\G]LHODMF SDPLü GOD

SRV]F]HJyOQ\FK ZLHUV]\ GRSyNL WR MHVW PR*OLZH =DXZD* *H SR XVXQLFLX WU]HFLHJR

ZLHUV]D WDEOLF\ QD RJyá RND]XMH VL *H UR]PLDU QDMZLNV]HJR GRVWSQHJR EORNX MHVW

PQLHMV]\RGFDáNRZLWHJRUR]PLDUXZROQHJRREV]DUXVWHUW\FRXQLHPR*OLZLDWZRU]HQLH

:LFHMSDPLFL

119

ZLNV]\FK VWUXNWXU G\QDPLF]Q\FK :UHV]FLH LQVWUXNFMD

release

]ZDOQLD FDá VWHUW

ÄZ]Z\*´SRF]ZV]\RGPLHMVFD]DUHMHVWURZDQHJRZ]PLHQQHM

Sterta

1D]DNRF]HQLHWHJRUR]G]LDáXVSUyEXMHP\Z\NRU]\VWDüPHFKDQL]P\]PLHQQ\FKG\QD-

PLF]Q\FK GR OHSV]HJR ]DJRVSRGDURZDQLD SDPLFL Z SURJUDPLH REVáXJL ELEOLRWHNL

3RGDQH QL*HM LQIRUPDFMH EG PLDá\ ] NRQLHF]QRFL FKDUDNWHU ZVND]yZHN SRZLQQ\

MHGQDNXPR*OLZLüCi skuteczne wprowadzenie zmian do programu. Przede wszystkim

QDOH*\]DGHNODURZDüRGSRZLHGQLHVWUXNWXU\GDQ\FK

type
{ ... }
PKsiazka = ^Ksiazka;

var
Katalog : array[1..2000] of PKsiazka;

L XVXQü ]EGQH MX* GHILQLFMH VWDá\FK RNUHODMF\FK RJUDQLF]HQLD SDPLFLRZH /LF]ED
2000 w deklaracji tablicy

Katalog

]RVWDáDZ\EUDQDDUELWUDOQLHSR]\FMLWRRNRáR

N%.ROHMQ\PNURNLHPMHVW]PRG\ILNRZDQLHZV]\VWNLFKSURFHGXUNRU]\VWDMF\FK
z parametrów typu

Ksiazka

SU]H]]PLDQW\SXSDUDPHWUXQD

PKsiazka

, np.:

procedure WprowadzDane(var r : PKsiazka);

FR XPR*OLZL LP RSHURZDQLH QD ]PLHQQ\FK ZVND]\ZDQ\FK SDUDPHWUHP 2F]\ZLFLH
w

WUHFL WDN ]PRG\ILNRZDQHM SURFHGXU\ QDOH*\ ZV]\VWNLH RGZRáDQLD GR Ä]Z\NáHJR´

SDUDPHWUX]DVWSLüRGZRáDQLDPLZ\NRU]\VWXMF\PLZVND(QLNQS

with r^ do {... }

0RG\ILNDFMDSURFHGXU\VRUWXMFHMMHVW]EGQDDQDZHWQLHSR*GDQD:QRZ\PSURJ-

UDPLH]DPLDQDUHNRUGyZSU]\MPLHIRUP]DPLDQ\ZVND(QLNyZFRRF]\ZLFLHEG]LH

V]\EV]HLEDUG]LHMHIHNW\ZQHQL*NRSLRZDQLHFDá\FKUHNRUGyZ

:V]HONLH Z\ZRáDQLD SURFHGXU SR]RVWDQ QLH]PLHQLRQH FKRFLD* IDNW\F]QLH ]DPLDVW

UHNRUGX ]DZV]H SU]HND]\ZDQ\ EG]LH ZVND(QLN GR UHNRUGX 1DWRPLDVW ZV]\VWNLH

EH]SRUHGQLH RGZRáDQLD GR SyO UHNRUGyZ ]DSLVDQ\FK Z WDEOLF\

Katalog

QDOH*\ ]DV-

WSLüRGZRáDQLDPLZ\NRU]\VWXMF\PLZVND(QLNL

Katalog[LbPoz]^.Licznik := 0;

1LH ZROQR UyZQLH* ]DSRPQLHü R X]XSHáQLHQLX SURFHGXU WZRU]F\FK L XVXZDMF\FK

UHNRUG\ R Z\ZRáDQLD SURFHGXU

new

dispose

, których brak spowoduje najpewniej

Eá\VNDZLF]QH]DZLHV]HQLHNRPSXWHUD

procedure DodajKsiazke;
{ ... }
writeln('Nowa pozycja w katalogu: ', Licznik);
new(Katalog[Licznik]); { utwórz nowy rekord w katalogu }
{ ... }

120 Turbo

Pascal

—

programowanie

procedure UsunKsiazke(Numer : integer);
begin
dispose(Katalog[Numer]);
{ ... }

3RGREQLH PXVLV] SRVWSLü ] SURFHGXU

OdczytajZDysku

(w procedurze zapisu usu-

ZDQLHUHNRUGyZQLHMHVWNRQLHF]QHDOHSU]\G]LHORQDSDPLüSRZLQQD]RVWDü]ZROQLRQD

SU]HG]DNRF]HQLHPG]LDáDQLDSURJUDPX

3RZ\*V]HZVND]yZNLQLHREHMPXMRSHUDFMLSRPRFQLF]\FKMDNQSVSUDZG]DQLHPR*OL-

ZRFL XWZRU]HQLD NROHMQHJR UHNRUGX 3RZLQQ\ RQH MHGQDN Z\VWDUF]\ü &L GR VNXWHF]-
nego zmodyfikowania programu.

=DSDPLWDM

•

'R SU]HFKRZ\ZDQLD ZLNV]\FK LORFL GDQ\FK PR*HV] Z 3DVFDOX Z\NRU]\VWDü
zmienne wskazywane (dynamiczne).

•

=PLHQQHZVND]\ZDQHVXPLHV]F]DQHQDW]ZVWHUFLHWHRUHW\F]QLHZGRZROQ\P

PLHMVFX SDPLFL 0RJ RQH E\ü WZRU]RQH L QLV]F]RQH G\QDPLF]QLH Z ]DOH*-

QRFLRGSRWU]HE

•

=PLHQQDZVND]\ZDQDORNDOL]RZDQDMHVW]DSRPRFZVND(QLNDNWyU\]DZLHUDMHM

DGUHV PLHMVFH Z SDPLFL :VND(QLNL PRJ ZVND]\ZDü QD ]PLHQQH
konkre

WQHJRW\SXPRJWH*E\üZVND(QLNDPLDPRUILF]Q\PL

pointer

•

3U]HG Z\NRU]\VWDQLHP ]PLHQQHM G\QDPLF]QHM QDOH*\ M XWZRU]\ü SURFHGXU
new), a po wykorzystaniu —

XVXQüSURFHGXU

dispose

•

'R SU]\G]LHODQLD L ]ZDOQLDQLD EORNyZ SDPLFL QD VWHUFLH VáX* UyZQLH* SURFH-
dury

GetMem

FreeMem

mark

release

Pozyteczne drobiazgi, czyli moduly biblioteczne

121

3R*

yteczne drobiazgi,

czyli

PRGXá\

biblioteczne

,OHUD]\]DVWDQDZLDáHVLMDNZ\F]\FLüHNUDQ]PLHQLüNRORUWHNVWXF]\ZSURZDG]Lü
znak z klawiatury bez naciskania klawisza

NTER

" :\NRQDQLH W\FK F]\QQRFL QLH

Z\PDJD ]DFKRGX Z\VWDUF]\ Z\ZRáDü RGSRZLHGQLSURFHGXUELEOLRWHF]Q-DNVDPD

QD]ZD ZVND]XMH SURFHGXUD WDND QLH MHVW QD VWDáH ÄZEXGRZDQD´ Z M]\N

SURJUDPRZDQLD OHF] SRELHUDQD ] RGG]LHOQHJR SOLNX ELEOLRWHNL L GRáF]DQD GR

SURJUDPXZWUDNFLHW]ZNRQVROLGDFMLQDVWSXMFHMSRNRPSLODFML

3DVFDORZH SOLNL ELEOLRWHF]QH QRV] QD]Z PRGXáyZ DQJ unit). Wersja 7.0 oferuje

SURJUDPLFLHG]LHVLüPRGXáyZVWDQGDUGRZ\FK

System

— wszystkie procedury standardowe;

Crt

—

EVáXJDPRQLWRUDNODZLDWXU\LJáRQLND

Dos

—

EVáXJDIXQNFMLV\VWHPRZ\FKZ\ZRáDQLDIXQNFMLV\VWHPX06-

DOS);

Graph

—

EVáXJDJUDILNL

Strings

—

EVáXJDáDFXFKyZ$6&,,Z;

WinDos

—

GSRZLHGQLNPRGXáX'26Z\NRU]\VWXMF\áDFXFK\$6&,,=

Printer

—

EVáXJDGUXNDUNL

Overlay

—

EVáXJDW]ZQDNáDGHN

Turbo3

—

RGXáÄX]JDGQLDMF\´]7XUER3DVFDOHP

Graph3

—

EVáXJDW]ZJUDILNL*yáZLDX*\ZDQHMZ7XUER3DVFDOX

122 Turbo

Pascal

—

programowanie

2GG]LHOQDREV]HUQDJUXSDPRGXáyZWZRU]\ELEOLRWHN7XUER9LVLRQNWyUQLHEdzie-

P\VLWXWDM]DMPRZDü

-DN QLHWUXGQR ]DXZD*\ü ND*G\ PRGXá ÄVSHFMDOL]XMH VL´ Z RNUHORQ\FK RSHUDFMDFK

Z\MWNLHP MHVW PRGXá

System

]DZLHUDMF\ ZV]\VWNLH SURFHGXU\ L IXQNFMH VWDQGDU-

GRZH 1DMF]FLHM X*\ZDQH PRGXá\

System

Crt

Dos

Printer

Overlay

)

umieszczono w specjalnym pliku

TURBO

TPL

áDGRZDQ\PGRSDPLFLZUD]],'(7XUER

3DVFDOD G]LNL F]HPX LFK ]DZDUWRü GRVWSQD MHVW QDW\FKPLDVW .RG SR]RVWDá\FK

PRGXáyZ]DSLVDQ\MHVWZRGSRZLHGQLFKSOLNDFK]UR]V]HU]HQLHP

TPU

1LH]DOH*QLHRG

WHJRF]\NRGPRGXáX]QDMGXMHVLQDG\VNXF]\MHVWáDGRZDQ\GRSDPLFLDE\Z\NR-

U]\VWDüGRZROQ\MHJRHOHPHQW]DQDJáyZNLHPSURJUDPXPXVLV]XPLHFLüGHNODUDFM

uses nazwa-

PRGXáX

-HOLZ\NRU]\VWXMHV]NLONDUy*Q\FKPRGXáyZPXVLV]UR]G]LHOLüLFKQD]Z\SU]HFLQNDPL

&KRFLD* PRGXá\ WUDNWRZDQH V QDMF]FLHM MDNR ELEOLRWHNL SURFHGXU ]DZLHUDM RQH

UyZQLH*GDQHZSRVWDFLVWDá\FKQSGHILQLXMF\FKNRORU\MDN

Red=2

), zmiennych (np.

XVWDODMF\FK VSRVyE RWZLHUDQLD SOLNyZ —

FileMode

F]\ WH* REVáXJL PRQLWRUD —

DirectVideo

) i typów (np.

DateTime

— typ rekordowy przeznaczony do

przechowywania czasu i daty,

PointType

—

W\S RSLVXMF\ SXQNW QD SáDV]F]\(QLH

=DUyZQRSURFHGXU\MDNLGDQHPR*HV]Z\NRU]\VW\ZDüEH]RJUDQLF]HDWDN*HSU]\VáD-

QLDüZáDVQ\PLGHILQLFMDPL3DPLWDMMHGQDN*HFHQ]DGRVWSGR]DZDUW\FKZPRGXOH

RELHNWyZ MHVW SRZLNV]HQLH REMWRFL JRWRZHJR SURJUDPX Z\QLNDMFH ] GRáF]HQLD

ÄLPSRUWRZDQHJR´ NRGX L GDQ\FK -HOL ]DOH*\ &L QD PLQLPDOL]DFML ZLHONRFL NRGX

Z\QLNRZHJR]DVWDQyZVLF]\NRQLHF]QLHPXVLV]X*\ZDüQSPRGXáX

Crt

. Generalnie

MHGQDNQDOH*\]DOHFLüX*\ZDQLHPRGXáyZELEOLRWHF]Q\FKJG\*GDMRQHSURJUDPLFLH

PR*OLZRüVNRU]\VWDQLD]HVSUDZG]RQ\FKUR]ZL]DZLHOXSUREOHPyZ]ZDOQLDMFRG

NRQLHF]QRFLZ\P\ODQLDLFKQDZáDVQUN

6WRVXMPRGXá\ELEOLRWHF]QH

6SRUyGZ\PLHQLRQ\FKZ\*HMPRGXáyZQDMF]FLHMVWRVRZDQHV

Crt

XPR*OLZLDMF\

HIHNW\ZQ L HIHNWRZQ REVáXJ NRPXQLNDFML ] X*\WNRZQLNLHP

Graph

UHDOL]XMF\

operacje w trybie graficznym, oraz

Dos

XPR*OLZLDMF\Z\NRQ\ZDQLHIXQNFMLV\VWHmo-

Z\FK3RQLHZD*RPDZLDQLHWUHFLSRV]F]HJyOQ\FKPRGXáyZMHVWNZHVWLGUXJRU]GQ

QDV]DNVL*NDPDSU]HGHZV]\VWNLPXF]\üSURJUDPRZDQLDDQLHVáX*\üMDNROHNV\NRQ

M]\ND D WDN*H ]H Z]JOGX QD V]F]XSáRü PLHMVFD RJUDQLF]\P\ VL GR RPyZLHQLD

NLONX QDMSRSXODUQLHMV]\FK HOHPHQWyZ PRGXáyZ

Crt

Dos

wraz z prostymi

SU]\NáDGDPL = tych samych przyczyn zrezygnujemy z omawiania bardzo obszernej

]DZDUWRFLPRGXáX

Graph

RGV\áDMF]DLQWHUHVRZDQ\FK&]\WHOQLNyZGROLWHUDWXU\>@

=DF]QLHP\ RG PRGXáX

Crt

ZVSRPDJDMFHJR RSHUDFMH ZHMFLD L Z\MFLD ] X*\FLHP

konsoli. Z procedur

ÄXOHSV]DMF\FK´ REVáXJ HNUDQX L NODZLDWXU\ FK\ED QDMF]FLHM

wykorzystywana jest bezparametrowa procedura

ClrScr

SRZRGXMFD Z\F]\V]F]HQLH

HNUDQX 3U]\NáDG MHM X*\FLD ]QDMG]LHV] Z IXQNFML

naszego programu bibliotecz-

3R*\WHF]QHGURELD]JLF]\OLPRGXá\ELEOLRWHF]QH

123

QHJR -HOL GRGDWNRZR SU]\ RND]ML F]\V]F]HQLD HNUDQX FKFLDáE\ü ]PLHQLü NRORU\

PR*HV]Z\NRU]\VWDüSURFHGXU\

TextColor

TextBackground

TextColor(kolor-tekstu)

TextBackground(kolor-

WáD

]PLHQLDMFHRGSRZLHGQLRNRORU]QDNyZRUD]WáD2F]\ZLFLH]DPLDVWOLF]ERZ\FKZDU-

WRFLNRORUyZNWRE\MHSDPLWDáQDMOHSLHMVWRVRZDüVWDáHV\PEROLF]QHQS

Blue=1

GOD NRORUX QLHELHVNLHJR (IHNW G]LDáDQLD REX SURFHGXU ZLGRF]Q\ MHVW GRSLHUR SR

Z\NRQDQLX NROHMQ\FK RSHUDFML Z\MFLD OXE Z\F]\V]F]HQLD HNUDQX ]D ELH*FH

ZDUWRFLNRORUyZSU]HFKRZ\ZDQHVZ]PLHQQHM

TextAttr

Procedura

GotoXY

VáX*\GRZ\SURZDG]DQLDWHNVWXQD]DGDQ\FKZVSyáU]GQ\FKHNUDQ

WHNVWRZ\OLF]\VRELHZLHUV]\SR]QDNyZZLHUV]HL]QDNLQXPHURZDQHVRG

3U]\NáDGRZHZ\ZRáDQLH

for i := 1 to 24 do
begin
GotoXY(i,i);
write('*');
end;

Z\ZLHWOL QD HNUDQLH XNRQ OLQL ]áR*RQ ] JZLD]GHN =EOL*RQH ]DVWRVRZDQLH PD
procedura

Window

Window(x1, y1, x2, y2)

XPR*OLZLDMFD Z\]QDF]HQLH QD HNUDQLH RNLHQND RJUDQLF]DMFHJR REV]DU Z\SLV\ZDQLD

WHNVWXGRSURVWRNWDRZVSyáU]GQ\FK

(lewy górny róg) i

(prawy dolny

UyJ']LDáDQLHSURFHGXU\

Window

QDMOHSLHMLOXVWUXMHSRQL*V]\SU]\NáDG

Window(10, 10, 20, 20); { okienko 10x10 }
write('W tym okienku wypisuje sie bardzo dlugi tekst');

2E\GZLHSURFHGXU\XPR*OLZLDMVNXWHF]QHWZRU]HQLHáDGQ\FKPHQXF]\ÄIRUPXODU]\´

QLHZLHONLPQDNáDGHPNRV]WyZFKRFLD*F]VWRRND]XMHVL*HOHSLHMZW\PFHOXZ\NR-

U]\VWDüQSELEOLRWHN7XUER9LVLRQ

$E\ZSURZDG]Lü]NODZLDWXU\SRMHG\QF]\]QDNEH]QDFLVNDQLDklawisza

NTER

warto

Z\NRU]\VWDüIXQNFM

ReadKey

=ZUDFDRQDNRG$6&,,]QDNXRGSRZLDGDMFHJRNODZL-

szowi albo —

ZSU]\SDGNXQDFLQLFLDNODZLV]DIXQNF\MQHJROXEVSHFMDOQHJR— tzw.

rozszerzony kod klawisza poprzedzony znakiem o kodzie 0 (w tym przypadku koniecz-

QH V GZD Z\ZRáDQLD )XQNFja

ReadKey

MHVW VWRVRZDQD JáyZQLH GR UHDOL]DFML PHQX

(vide program

Katalog

L LQQ\FK Z\P\OQLHMV]\FK RSHUDFML Z\NRU]\VWXMF\FK NOD-

ZLDWXU 6SRNUHZQLRQD ] QL IXQNFMD

KeyPressed

VáX*\ GR EDGDQLD VWDQX EXIRUD

klawia

WXU\ MHOL SU]HG MHM Z\ZRáDQLHP QDFLQLWR MDNL NODZLV] ]ZUyFL RQD ZDUWRü

true

:DUWR SDPLWDü *H

KeyPressed

QLH RSUy*QLD EXIRUD NODZLDWXU\ WRWH* NROHMQH

Z\ZRáDQLD EG ]ZUDFDá\ true D* GR FKZLOL NLHG\ ]QDN ]RVWDQLH RGF]\WDQ\ QS
w

\ZRáDQLHPIXQNFML

ReadKey

=WHJRWH*Z]JOGXIXQNFML

KeyPressed

QDOH*\X*\ZDü

EDUG]RRVWUR*QLH]DVWSXMFMZPLDUPR*OLZRFLZ\ZRáDQLHP

ReadKey

124 Turbo

Pascal

—

programowanie

5HDOL]DFM HIHNWyZ G(ZLNRZ\FK XPR*OLZLDM SURFHGXU\

Sound

NoSound

Delay

3LHUZV]H GZLH RGSRZLHGQLR ZáF]DM L Z\áF]DM ZHZQWU]Q\ JáRQLF]HN NRPSXWHUD

SRZRGXMF JHQHURZDQLH G(ZLNX R F]VWRWOLZRFL RNUHORQHM SDUDPHWUHP 3URFHGXUD

Delay

XPR*OLZLDXVWDOHQLHGáXJRFLWUZDQLDG(ZLNX3RQLHZD*JáRQLNNRPSXWHUD3&

REVáXJLZDQ\ MHVW VSU]WRZR PXVLV] SDPLWDü R Z\áF]HQLX G(ZLNX SURFHGXU

Sound

, w przeciwnym przy

SDGNX PR*H RQ E\ü JHQHURZDQ\ QDZHW SR ]DNRF]HQLX

SURJUDPX.UyWNGHPRQVWUDFMHIHNWyZG(ZLNRZ\FKSRND]DQRSRQL*HM

for i := 1 to 8 do
begin

6RXQG^G(ZLNRF]VWRWOLZRFLN+]`

'HOD\^RSy(QLHQLHPLOLVHNXQG`

1R6RXQG^Z\áF]G(ZLN`

'HOD\^MHV]F]HMHGQRRSy(QLHQLH`

end;

Procedury i dane zawarte w module

Dos

Z\NRU]\VW\ZDQHV]QDF]QLHU]DG]LHMJáyZQLH

SU]H]EDUG]LHMGRZLDGF]RQ\FKSURJUDPLVWyZ3R]ZDODMRQHQDZ\NRQ\ZDQLHRSHUDFML
na systemie plików, o

EVáXJ ]HJDUD V\VWHPRZHJR RUD] ]DU]G]DQLH SURFHVDPL

SURJUDPDPLLW]ZSU]HUZDQLDPLFRMHVW]DEDZQLH]DZV]HEH]SLHF]Q

(OHPHQWDUQHLQIRUPDFMHRV\VWHPLHSOLNyZPR*HV]X]\VNDü]DSRPRFIXQNFMLSURce-
dur)

DiskSize

DiskFree

GetDir

FindFirst

FindNext

. Pierwsze dwie funkcje

]ZUDFDMFDáNRZLWSRMHPQRüRUD]LORüZROQHJRPLHMVFDGOD]DGDQHJRG\VNXZEDM-

WDFK]DSURFHGXUD

GetDir

XPR*OLZLDRNUHOHQLHQD]Z\ELH*FHJRNDWDORJX

*HW'LUV^R]QDF]DG\VNELH*F\`

writeln('Biezacy katalog: ', s); { s jest typu string }
writeln('Pojemnosc dysku: ', DiskSize(0), ' bajtow.');
writeln('Wolne miejsce: ', DiskFree(0), ' bajtow.');

:DUWRZLHG]LHü*HG\VNLZV\VWHPLH'26QXPHURZDQHVRGMHG\QNLNWyUDRGSRZLDGD

G\VNRZL$]DZDUWRüR]QDF]D]DZV]HG\VNELH*F\

Procedury

FindFirst

FindNext

Z\NRU]\VW\ZDQHVQDRJyáGRVSUDZG]DQLDREHF-

QRFL SOLNX QD G\VNX L RGF]\WX OLVW\ SOLNyZ ]DZDUW\FK Z NDWDORJX 3RQL*HM SU]HGVWD-

ZLRQRW\SRZNRQVWUXNFMZ\ZLHWODMFOLVWSOLNyZ]DZDUW\FKZNDWDORJXJáywnym
dysku C:

FindFirst('c:\

$Q\)LOH2SLV3OLNX^]QDMG(SLHUZV]\`

{ plik }
while DosError = 0 do

^V]XNDMD*GRZ\F]HUSDQLDSOLNyZ`

begin

)LQG1H[W2SLV3OLNX^]QDMG(NROHMQ\SOLN`

writeln(OpisPliku.Name);
end;

Procedura

FindFirst

znajduje pierwszy plik o nazwie zadanej pierwszym parametrem

i tworzy tzw. rekord opisu pliku (zmienna

OpisPliku

typu

SearchRec

), wyko-

U]\VW\ZDQ\ QDVWSQLH SU]H]

FindNext

do wyszukiwania kolejnych plików. Zmienna

DosError

przechowuje wynik ostatnio wykonanej funkcji systemu operacyjnego

3R*\WHF]QHGURELD]JLF]\OLPRGXá\ELEOLRWHF]QH

125

(w naszym przypadku —

IXQNFMLZ\V]XNDQLDSOLNXSU]\F]\PZDUWRüRGSRZLDGD

Z\NRQDQLX EH]EáGQHPX QDWRPLDVW SR]RVWDáH ZDUWRFL V NRGDPL RGSRZLHGQLFK Eá-
dów zwracanymi przez DOS.

1D W\P ]DNRF]\P\ QDV]H NUyWNLH VSRWNDQLH ] PRGXáDPL ELEOLRWHF]Q\PL = NRQLHF]-

QRFLRPyZLOLP\ZQLP]DJDGQLHQLDQDMEDUG]LHMSRGVWDZRZHSRPLMDMFV]F]HJyáRZ\

RSLV ]DZDUWRFL PRGXáyZ -HOL RND*H VL *H MHVW &L SRWU]HEQD MDND IXQNFMD OXE
struktura danyc

KQDMOHSLHM]URELV]SU]HJOGDMFRGSRZLHGQLHWHPDW\V\VWHPXSRPRF\

HZHQWXDOQLHRGZRáXMFVLGROLWHUDWXU\

: NROHMQ\P UR]G]LDOH SRND*HP\ MDN WZRU]\ü ZáDVQH PRGXá\ L MDNLH ] WHJR Sá\Q

NRU]\FL

=DSDPLWDM

•

3DVFDORZHPRGXá\ELEOLRWHF]QH]DZLHUDMZLHOHX*\WHF]Q\FKSURFHGXULVWUXNWXU
danych.

•

$E\RGZRáDüVLGR]DZDUWRFLPRGXáXPXVLV]XPLHFLüQDSRF]WNXSURJUDPX

GHNODUDFM

uses

•

:\NRU]\VWDQLH PRGXáyZ SRZRGXMH SRZLNV]HQLH REMWRFL VNRPSLORZDQHJR
programu.

•

1DMF]FLHM Z\NRU]\VW\ZDQ\PL PRGXáDPL V

Crt

REVáXJD PRQLWRUD L NODZLD-

tury),

Graph

REVáXJD JUDILNL RUD]

Dos

REVáXJD Z\ZRáD IXQNFML V\VWHmo-

wych).

126 Turbo

Pascal

—

programowanie

0RGXá\ZáDVQH

: PLDU UR]ZRMX 7ZRLFK XPLHMWQRFL EG]LHV] UR]ZL]\ZDá FRUD] EDUG]LHM ]áR*RQH

SUREOHP\ L SLVDá FRUD] EDUG]LHM ]áR*RQH SURJUDP\ 3UG]HM F]\ Sy(QLHM VWDQLHV] WH*

SU]HGNRQLHF]QRFLUR]ELFLDSURJUDPXQDNLONDSURVWV]\FKIUDJPHQWyZF]\OLSRG]LH-
lenia go na

PRGXá\0RGXáRZRüEGFDMHGQ]SRGVWDZRZ\FK]DVDGGREUHJRSURJ-

UDPRZDQLDMHVWUR]V]HU]HQLHPSRGHMFLDSURFHGXUDOQHJR6WUXNWXUDPRGXODUQD]DNáDGD

Z\G]LHOHQLH IXQNFML ]DMPXMF\FK VL GDQ G]LHG]LQ QS RSHUDFMDPL ZHMFLD-Z\MFLD
i

]JUXSRZDQLH LFK Z RGG]LHOQ\FK SOLNDFK 5y*QLF SRPLG]\ SURJUDPHP ÄOLQLRZ\P´

SURJUDPHPPRGXáRZ\PUHDOL]XMF\PWRVDPR]DGDQLHSU]HGVWDZLDSRQL*V]\U\VXQHN

Dane, struktury i funkcje globalne,

procedury przetwarzania danych,

procedury wejœcia-wyjœcia,

interfejs u¿ytkownika, program g³ówny

Dane i struktury globalne

Funkcje globalne

Procedury

przetwarzania

danych

Procedury wejœcia-wyjœcia

i interfejs u¿ytkownika

PROGRAM

Otoczenie

Rysunek 13.

6WUXNWXUDSURJUDPXÄOLQLRZHJR´DLPRGXáRZHJRE

&R GDMH ]DVWRVRZDQLH VWUXNWXU\ PRGXáRZHM" -DN QLHWUXGQR ]DXZD*\ü SURJUDP ÄOLQL-

RZ\´JUXSXMHZV]\VWNLHHOHPHQW\ZMHGQ\PSOLNX(UyGáRZ\P3U]\ZLNV]\FKSrog-

UDPDFKOLF]EDZLHUV]\NRGX(UyGáRZHJRLG]LHZW\VLFHFR]NROHLGUDVW\F]QLHZ\GáX*D

F]DVSRWU]HEQ\QD]QDOH]LHQLH*GDQHJRIUDJPHQWXSURJUDPXSRJDUV]DMHJRF]\WHOQRü

0RGXá\ZáDVQH

127

XWUXGQLD LQWHUSUHWDFM L XUXFKDPLDQLH 2GSRZLHGQL SURJUDP R VWUXNWXU]H PRGXáRZHM

VNáDGD VL ] NLONX NUyWV]\FK D ZLF áDWZLHMV]\FK GR F]\WDQLD SOLNyZ ]DZLHUDMF\FK

IXQNFMH SRJUXSRZDQH WHPDW\F]QLH FR ] NROHL XáDWZLD Z\V]XNLZDQLH RGSRZLHGQLFK
fragmentów programu i jego uruchamianie).

3LHUZV]NRU]\FL]]DVWRVRZDQLDVWUXNWXU\PRGXáRZHMMHVWSRSUDZD

F]\WHOQRFLNRGX(UyGáRZHJRRUD]XáDWZLHQLHLQWHUSUHWDFMLLXUXFKDPLDQLD
programu.

1LHGRüWHJRUD]QDSLVDQHLSU]HWHVWRZDQHIXQNFMHLVWUXNWXU\GDQ\FKPRJSU]\GDü&L

VLZSU]\V]áRFL2F]\ZLFLHSRGF]DVSLVDQLDNROHMQHJRSURJUDPXPR*HV]ZUyFLüGR

RGSRZLHGQLHJRWHNVWX(UyGáRZHJRLÄSRWUDNWRZDüJR´HG\WRUHPNRSLXMFRGSRZLHGQLH

IUDJPHQW\MHGQDN]QDF]QLHOHSLHMMHVW]DPNQüUD]QDSLVDQ\NRGZPRGXOH'ODF]HJR"

3RSLHUZV]HXQLNDV]ZWHQVSRVyEÄSU]HNRS\ZDQLDVL´SU]H]VWDUHSURJUDP\, wyszuki-

ZDQLDRGSRZLHGQLFKIUDJPHQWyZL]áR*RQ\FKQLHUD]RSHUDFMLZHG\WRU]H]DVWSXMFWR

ZV]\VWNR]Z\Ná\PGRáF]HQLHPPRGXáX3RGUXJLHSURJUDPRZDQLH]X*\FLHPELEOLR-

WHNSU]\SRPLQDXNáDGDQLHNORFNyZEH]NRQLHF]QRFL]DVWDQDZLDQLDVL]F]HJR]RVWDá\

RQH]URELRQHLMDNG]LDáDM—IDFKRZRQD]\ZDVLWRXNU\ZDQLHPV]F]HJyáyZLPSOH-
mentacyjnych

3RWU]HFLHZ\NRU]\VWDQLHZF]HQLHMQDSLVDQ\FKLSU]HWHVWRZDQ\FKSUR-

FHGXULIXQNFMLXáDWZLDXUXFKDPLDQLHSURJUDPX]DNáDGDMF*HNORFNL]RVWDá\]URELRQH
sol

LGQLH3RGHMFLHPRGXáRZHZ\PXV]DUyZQLH*QDSURJUDPLFLHSRSUDZQHSURMHNWR-

ZDQLHHOHPHQWyZSURJUDPXFREH]ZWSLHQLDSU]\QLHVLHSURILW\ZSU]\V]áRFL1LHEH]

]QDF]HQLDMHVWWH*NZHVWLDF]DVRZDUD]VNRPSLORZDQ\PRGXáQLHNRPSLOXMHVLSRQRZ-

QLH :\NRU]\VWDQLH PRGXáyZ GDMH ZUHV]FLH SURJUDPLVWRP PR*OLZRü UR]SRZV]H-

FKQLDQLD NRGX Z SRVWDFL VNRPSLORZDQ\FK ELEOLRWHN EH] NRQLHF]QRFL XMDZQLDQLD

WHNVWyZ(UyGáRZ\FK

'UXJNRU]\FL]]DVWRVRZDQLDVWUXNWXU\PRGXáRZHMMHVWPR*OLZRüáDWZHJR
wykorzystania wcze

QLHMVWZRU]RQ\FKLSU]HWHVWRZDQ\FKIXQNFMLLVWUXNWXU

GDQ\FKDQJUHXVDELOLW\RUD]XáDWZLHQLHLFKG\VWU\EXFML

-DNMX*SRZLHG]LHOLP\NRQLHF]QRüSURJUDPRZDQLDPRGXáRZHJRSU]\MG]LH]F]DVHP
—

SURJUDP\ SLVDQH SU]H] &LHELH REHFQLH V QLHFR ]D NUyWNLH 'ODWHJR WH* QD UD]LH

RJUDQLF]\P\VLGRSU]HGVWDZLHQLDRJyOQ\FKUHJXáWZRU]HQLDPRGXáyZLLFKZ\NRU]\V-

WDQLD=DSU]\NáDGSRVáX*\QDPNUyWNLPRGXá

Test

unit Test;

interface { sekcja publiczna }

type
float = real;

function Pow(x, y : float) : float;
{

SRGQRVLOLF]E[GRSRWJL\`

function IleWywolan : word;

^]ZUDFDOLF]EZ\ZRáDIXQNFML3RZ`

128 Turbo

Pascal

—

programowanie

implementation { sekcja prywatna }

var

/LF]QLNZRUG^OLF]QLNZ\ZRáDIXQNFML`

function Pow(x, y : float) : float;

begin
Inc(Licznik);
Pow := exp(y*ln(x));
end;

function IleWywolan : word;

begin
IleWywolan := Licznik;
end;

begin { sekcja inicjalizacji }
Licznik := 0;
end.

0RGXáWHQ]DZLHUDWU]\]DVDGQLF]HVHNFMHSXEOLF]Q

interface

SU\ZDWQ

imple

mentation

RUD]LQLFMDOL]DF\MQ

Sekc

MD SXEOLF]QD RWZLHUDQD VáRZHP

interface

GHILQLXMH RELHNW\ NWyUH EG ÄHNV-

porto

ZDQH´]PRGXáXQD]HZQWU]=DZLHUDRQGHILQLFMHVWDá\FKLW\SyZRUD]GHNODUDFMH

]PLHQQ\FKDWDN*HW]ZGHNODUDFMH]DSRZLDGDMFH procedur i funkcji (czyli po prostu

LFKQDJáyZNL6HNFMDSXEOLF]QDVWDQRZLMHG\QEUDPSU]H]NWyUSURJUDPNRU]\VWD-

MF\]PRGXáXPR*HGRVWDüVLGRMHJR]DZDUWRFLZV]HONLHRELHNW\]GHILQLRZDQHZHZ-

QWU] PRGXáX OHF] QLH ]DGHNODURZDQH Z VHNFML SXEOLF]QHM EG QLHZLGRF]QH QD ]HZ-

QWU] :DUWR UyZQLH* SDPLWDü *H NRPXQLNDFMD ] PRGXáHP MHVW Z\áF]QLH

MHGQRVWURQQDWMRELHNW\]GHILQLRZDQHZPRGXOHQLHPRJRGZRá\ZDüVLGRRELHNWyZ
wykorzystu

MFHJR JR SURJUDPX 0R*OLZH MHVW QDWRPLDVW Z\NRU]\VWDQLH Z PRGXOH

LQQHJR PRGXáX Z W\P FHOX SR QDJáyZNX PRGXáX QDOH*\ XPLHFLü RGSRZLHGQL

GHNODUDFM

uses

Definicje obiektów zapowiedzianych w sekcji publicznej zawiera sekcja prywatna,

RWZLHUDQDVáRZHP

implementation

-HM]DZDUWRüMHVWQLHZLGRF]QDQD]HZQWU]FR

SR]RVWDMH Z ]JRG]LH ] LGH XNU\ZDQLD V]F]HJyáyZ LPSOHPHQWDF\MQ\FK RELHNW\ SU\-

ZDWQHZ\NRU]\VW\ZDQHVQDMF]FLHMGRZHZQWU]Q\FKSRWU]HEPRGXáXWDNZLFQLH

PD VHQVX XMDZQLDQLH LFK QD ]HZQWU] 0R*OLZH MHVW FR SUDZGD RGZRá\ZDQLH VL GR
funkcji i procedur zadeklarowanych w sekcji

interface

DOHÄZLGRF]QRü´VSURZDG]D

VLWXWDMZ\áF]QLHGR]QDMRPRFLSRVáX*HQLDVLGDQIXQNFM—Z\ZRáXMF\SURJUDP

PXVL ]QDü MHM QDJáyZHN RNUHODMF\ VSRVyE SU]HND]DQLD SDUDPHWUyZ L RGHEUDQLD

Z\QLNXQDWRPLDVW]QDMRPRüWUHFLQLHMHVWPXGRQLF]HJRSRWU]HEQD

Ost

DWQL VHNFM PRGXáX MHVW QLHRERZL]NRZD VHNFMD LQLFMDOL]DFML UR]SRF]\QDMFD VL

SRGREQLHMDNZ]Z\Ná\PSURJUDPLHVáRZHPNOXF]RZ\P

begin

. Instrukcje zawarte

VHNFMLLQLFMDOL]DFMLVZ\NRQ\ZDQHZFKZLOLXUXFKRPLHQLDSURJUDPXL]Z\NOHZ\NR-

0RGXá\ZáDVQH

129

U]\VW\ZDQH V MDN VDPD QD]ZD ZVND]XMH GR DXWRPDW\F]QHJR XVWDODQLD MHJR VWDQX

SRF]WNRZHJR QS ]DSDPLW\ZDQLD NRORUyZ HNUDQX Z FHOX LFK Sy(QLHMV]HJR RGWZR-

U]HQLDLQLFMDOL]DFMLGUXNDUNLDXWRPDW\F]QHJRáDGRZDQLDSOLNyZNRQILJXUDF\MQ\FK

&DáRü PRGXáX UR]SRF]\QD VL QDJáyZNLHP R SRVWDFL

unit nazwa

(ang. unit —

PRGXá L NRF]\ VáRZHP NOXF]RZ\P

end

] NURSN 7X XZDJD WUHü PRGXáX NRG

(UyGáRZ\ L Z\QLNRZ\ ]DSDPLW\ZDQD MHVW Z RGG]LHOQ\FK SOLNDFK NWyU\FK QD]Z\

PXV] E\ü WDNLH VDPH MDN QD]ZD X*\WD Z QDJáyZNX Z QDV]\P SU]\SDGNX WHNVW

(UyGáRZ\ PRGXáX QDOH*\ XPLHFLü Z SOLNX

TEST

PAS

]D NRG Z\QLNRZ\ ]RVWDQLH

zapisany do pliku

TEST

TPU

:\PLHQLRQHZ\*HMVHNFMHSRZLQQ\Z\VWSRZDüZWDNLHM

NROHMQRFLZMDNLHM]RVWDá\RSLVDQHFKRFLD*ND*G]QLFKPR*QDSRPLQü3RVSROLWym
zjawiskiem jest po

PLQLFLH F]FL LQLFMDOL]DF\MQHM Z FKZLOL XUXFKRPLHQLD SURJUDPX

PRGXá QLH Z\NRQXMH *DGQ\FK RSHUDFML 3RPLQLFLH F]FL SU\ZDWQHM VSRW\NDQH MHVW

JáyZQLH Z PRGXáDFK GHNODUXMF\FK Z\áF]QLH VWDáH ]PLHQQH L W\S\ %UDN F]FL

SXEOLF]QHM DXWRPDW\F]QLH XQLHPR*OLZLD NRPXQLNDFM ] PRGXáHP WRWH* V\WXDFMD WDND
spotykana jest niezwykle rzadko.

:UyüP\ GR QDV]HJR SU]\NáDGX 0RGXá

Test

]DZLHUD Z F]FL SXEOLF]QHM GHNODUDFM

dwóch funkcji:

Pow

SRGQRV]FHM OLF]E U]HF]\ZLVW GR SRWJL U]HF]\ZLVWHj, oraz

]QDF]QLH PQLHM X*\WHF]QHM

IleWywolan

]ZUDFDMFHM OLF]E Z\ZRáD IXQNFML

Pow

6HNFMD SXEOLF]QD ]DZLHUD UyZQLH* GHILQLFM SURVWHJR W\SX ]PLHQQRSU]HFLQNRZHJR

float

6HNFMDSU\ZDWQD]DZLHUDRF]\ZLFLHGHILQLFMHIXQNFML]DSRZLHG]LDQ\FKZVHNFMLSXE-

OLF]QHMMDNUyZQLH*GHNODUDFMSU\ZDWQHM]PLHQQHM

Licznik

. Zmienna ta przechowuje

OLF]E Z\ZRáD IXQNFML

Pow

3RQLHZD*

Licznik

MHVW QLHGRVWSQ\ ] ]HZQWU]

VSUyEXM MHJR ZDUWRü ]ZUDFDQD MHVW SU]H] IXQNFM

IleWywolan

. Warto tu

ZVSRPQLHü *H ZV]HOkie gloEDOQH ]PLHQQH SU\ZDWQH PRGXáX V VWDW\F]QH WM

SU]HFKRZXMVZRMZDUWRüSU]H]FDá\F]DVZ\NRQ\ZDQLDSURJUDPX

&]ü LQLFMDOL]DF\MQD ]DZLHUD MHGQ LQVWUXNFM LQLFMDOL]XMF ZDUWRü ]PLHQQHM

Licz

nik

QD]HUR2VHQVRZQRFLWHJRUR]ZL]DQLDQLHWU]HEDFK\EDQLNRJRSU]HNRQ\ZDü

'R VSUDZG]HQLD G]LDáDQLD QDV]HJR PRGXáX Z\NRU]\VWDP\ NUyWNL SURJUDP

TestModulu

3URJUDPWHQMHVWQDW\OHEDQDOQ\*HQLHZ\PDJDNRPHQWDU]D

program TestModulu;

uses
Test;

var
x : float; { wykorzystanie zdefiniowanego typu }

begin
writeln('2 do potegi 8 = ', Pow(2,8):8:4);
x := 1.5;
writeln('Pi do potegi 1.5 = ', Pow(Pi, x):8:4);
writeln('Funkcje Pow wywolano ', IleWywolan, ' razy.');
end.

130 Turbo

Pascal

—

programowanie

-DNZLGDüZ\NRU]\VWDQLHZáDVQHJRPRGXáXRGE\ZDVLGRNáDGQLHWDNVDPRMDNVWDQ-

GDUGRZHJRPRGXáXELEOLRWHF]QHJR-HOLSU]\MU]\V]VLXZD*QLHUDSRUWRZL]NRPSLODFML

]DXZD*\V] *H SU]HG VNRPSLORZDQLHP VDPHJR SURJUDPX 7XUER 3DVFDO Z\ZLHWOL

LQIRUPDFM R NRPSLODFML PRGXáX 3R VNRPSLORZDQLX SURJUDPX QD G\VNX SRZLQLHQ

SRMDZLüVLSOLNRQD]Zie

TEST

TPU

]DZLHUDMF\VNRPSLORZDQ\NRGZ\QLNRZ\PRGXáX

2GSRZLHGQLHIUDJPHQW\NRGXVSRELHUDQH]SOLNXLGRáF]DQHGRNRGXZ\QLNRZHJR
programu w procesie konsolidacji. Po utworzeniu pliku

TPU

PRGXáQLHEG]LHNRPSLOR-

ZDQ\ SRQRZQLH R LOH QLH ZSURZDG]LV] ]PLDQ GR NRGX (UyGáRZHJR OXE QLH Z\GDV]
polecenia Build

Z\PXV]DMFHJREH]ZDUXQNRZHVNRPSLORZDQLHZV]\VWNLFKHOHPHQWyZ

VNáDGRZ\FKSURJUDPX

-DN SRZLHG]LHOLP\ QD SRF]WNX WHJR UR]G]LDáX ]DJDGQLHQLH PRGXáyZ MHVW UDF]HM

ÄSU]\V]áRFLRZH´ WRWH* QLH EG]LHP\ VL QLP V]HU]HM ]DMPRZDü 2G VDPHM VWURQ\

WHFKQLF]QHM NWyUHM RSLV PR*HV] ]QDOH(ü Z OLWHUDWXU]H ZD*QLHMV]D Z\GDMH VL LGHD

SURJUDPRZDQLD L SURMHNWRZDQLD PRGXáRZHJR SR]ZDODMFD QD V]\ENLH L VNXWHF]QH

WZRU]HQLHHIHNWRZQ\FKHIHNW\ZQ\FKLEH]EáGQ\FKSURJUDPyZ

=DSDPLWDM

•

=DVDGDPRGXODUQRFLMHVWMHGQ]SRGVWDZRZ\FK]DVDGGREUHJRSURJUDPRZDQLD

6WRVRZDQD MHVW RQD SU]HGH ZV]\VWNLP SRGF]DV UHDOL]DFML EDUG]LHM ]áR*RQ\FK

]DGD

•

5HDOL]DFMWHM]DVDG\XPR*OLZLDMZ7XUER3DVFDOXPRGXá\

•

0RGXá]DZLHUDGHILQLFje i deklaracje obiektów zawarte w trzech sekcjach. Sekcja
publiczna (

interface

RNUHODNWyUHRELHNW\EGZLGRF]QHQD]HZQWU]VHN-

cja prywatna (

implementation

GHILQLXMHLFKWUHüDWDN*HGHILQLXMHRELHNW\

SU\ZDWQH PRGXáX QDWRPLDVW VHNFMD LQLFMDOL]DF\MQD SU]H]QDF]RQD MHVW GR DXWR-

PDW\F]QHJRZ\NRQ\ZDQLD]DGDQ\FKF]\QQRFLZFKZLOLUR]SRF]FLDSURJUDPX

•

2ELHNW\]GHILQLRZDQHZVHNFMLSU\ZDWQHMVQLHZLGRF]QHQD]HZQWU]PRGXáX
o

LOHQLH]RVWDQ]DGHNODURZDQHZVHNFMLSXEOLF]QHM

•

6NRPSLORZDQD WUHü PRGXáyZ MHVW SU]HFKRZ\ZDQD Z SOLNDFK R UR]V]HU]HQLX

TPU

GRáF]DQDGRZáDFLZHJRSURJUDPXZSURFHVLHNRQVROLGDFML

•

3RG]LDá SURJUDPX QD PRGXá\ RUD] JUXSRZDQLH IXQNFML SURFHGXU L VWUXNWXU GD-
nych w

ELEOLRWHNLJRWRZ\FKHOHPHQWyZXPR*OLZLDV]\ENLHLVNXWHF]QHWZRU]HQLH

efektyw

Q\FKLEH]EáGQ\FKSURJUDPyZ

Jak

uruchamia

üRSRUQHSURJUDP\

131

-DNXUXFKDPLDü

oporne programy

,PEDUG]LHM]áR*RQ\SURJUDPW\PPQLHMV]DV]DQVD*HXGD&LVLRGUD]XQDSLVDüJR

EH]EáGQLH :\áDSDQLH ZV]\VWNLFK EáGyZ NRPSLODFML WR GRSLHUR SRF]WHN ]DZV]H

PR*H &L VL SU]\WUDILü G]LHOHQLH SU]H] ]HUR F]\ SUyED RWZDUFLD QLHLVWQLHMFHJR SOLNX

%áG\WH]ZDQHEáGDPLZ\NRQDQLDDQJruntime errorsV]QDF]QLHPQLHMSU]\MHPQH
i trudniejsze do

XVXQLFLDRGEáGyZNRPSLODFML,FKORNDOL]DFMDZ\PDJDQDRJyáX*\FLD

VSHFMDOQHJR QDU]G]LD XUXFKRPLHQLRZHJR ]ZDQHJR ] DQJLHOVND debuggerem (czyli

RGSOXVNZLDF]HP 6\VWHP XUXFKRPLHQLRZ\ 7XUER 3DVFDOD EG]LH WHPDWHP RVWDWQLHJR

MX*UR]G]LDáXSRZLFRQHJRWHmu kompilatorowi.

3ROHFHQLDV\VWHPXXUXFKRPLHQLRZHJR]JUXSRZDQHVZPHQXRun oraz Debug, przy

F]\P ZLNV]RFL ] QLFK RGSRZLDGDM NODZLV]H VNUyWX 'R HNVSHU\PHQWyZ ] GHEXJ-

JHUHPPR*QDZ\NRU]\VWDüSUDNW\F]QLHGRZROQ\SURJUDPFKRFLD*ZDUWRE\]DZLHUDá
on

GHILQLFMHSURFHGXUL]PLHQQ\FKORNDOQ\FK'ODQDV]\FKSRWU]HERGSRZLHGQLEG]LH

przedstawiony na stronie 62 program

Bisekcja

-DNMX*ZLHV]Z\VWSLHQLHEáGXZ\NRQDQLDSRZRGXMHSU]HUZDQLHG]LDáDQLDSURJUDPX
i

ZVND]DQLHNXUVRUHPLQVWUXNFMLNWyUDWHQEáGVSRZRGRZDáD1LHVWHW\QDRJyáLQIRU-

PDFMDWDNDMHVWQLHZ\VWDUF]DMFDJG\*GRVNXWHF]QHMORNDOL]DFMLEáGXZ\PDJDQHMHVW

SU]HOHG]HQLH]DFKRZDQLDSURJUDPXQDFRQDMPQLHMNLONDLQVWUXNFMLSU]HGMHJRZ\VW-

SLHQLHP 0R*OLZRü WDN GDMH Z QRZRF]HVQ\FK QDU]G]iach uruchomieniowych tzw.
tryb krokowy

SR]ZDODMF\QDZ\NRQ\ZDQLHSURJUDPXLQVWUXNFMDSRLQVWUXNFML

Turbo Pascal pozwala na krokowe wykonywanie programu na dwa sposoby, realizo-
wane odpowiednio poleceniami Trace Into i Step Over z menu Run (lub odpowiada-

MF\PLLPNODZLV]DPL

5y*QLFDSRPLG]\RE\GZRPDWU\EDPLVSURZDG]DVL

do innego sposobu traktowania procedur i funkcji: polecenie Trace Into pozwala na

ÄZHMFLH´ GR ZQWU]D SURFHGXU\ ]D Step Over Z\NRQXMH M MDNR MHGQ LQVWUXNFM
W obu przyp

DGNDFK DNWXDOQLH Z\NRQ\ZDQD LQVWUXNFMD ]RVWDMH Z\Uy*QLRQD Z WHNFLH

SURJUDPX NRORURZ\P SDVNLHP $E\ Z\SUyERZDü G]LDáDQLH WU\EX NURNRZHJR
skompiluj program

Bisekcja

(

L Z\NRQDM JR Z REX WU\EDFK =DXZD* WH* *H

132 Turbo

Pascal

—

programowanie

wydanie polecenia Program Reset (

TRL

-F2

) pozwala na zrestartowanie programu, co

PR*HVLSU]\GDüJG\VLRND*H*HGDOV]HMHJRZ\NRQ\ZDQLHQLHPDVHQVX

3RZ\*V]D ZSUDZND QLH SU]\QLRVáD FK\ED *DGQ\FK QLHVSRG]LDQHN L QLHZLHOH LQIRU-

PDFML 7U\E NURNRZ\ SR]ZDODMF\ QD XVWDOHQLH GURJL MDN ÄSU]HE\wa” wykonanie

SURJUDPX QLH GDMH *DGQ\FK ZVND]yZHN QD WHPDW ZDUWRFL SU]\MPRZDQ\FK SU]H]

]PLHQQH NWyUH Z ZLNV]RFL SU]\SDGNyZ V RGSRZLHG]LDOQH ]D VWHURZDQLH SUDF

SURJUDPXDZLFLHZHQWXDOQHNROL]MH1DV]F]FLHSRGHMU]HQLH]DZDUWRFLZ\EUDQHM
zmienn

HMMHVWEDUG]RáDWZHZ\VWDUF]\GRWHJRSROHFHQLHEvaluate/modify (

TRL

-F4

)

z menu Debug

-HJR Z\GDQLH SRZRGXMH Z\ZLHWOHQLH RNLHQND ]DZLHUDMFHJR LQIRU-

PDFMRZDUWRFL]PLHQQHMRUD]SR]ZDODMFHJRQDMHM]PLDQWDN

Rysunek 14. Pole dialogowe Evaluate and Modify

W pole Expression

ZSLVXMHP\Z\UD*HQLHQSQD]Z]PLHQQHMZQDV]\PSU]\SDGNX

eps

NWyUHJRZDUWRüFKFHP\REHMU]Hü:DUWRüZ\ZLHWODQDMHVWZSROXResult]D

pole New value

XPR*OLZLDMHM]PLDQ]F]\PMHGQDNQDOH*\QLHFRXZD*Dü

&]DVDPLRND]XMHVL*HSRGHMU]DQ]PLHQQQDOH*\OHG]LüFDá\F]DV:WDNLHMV\WXDFML

]DPLDVWPDáRZ\JRGQHJRSRGJOGDQLDSROHFHQLHPEvaluateOHSLHMMHVWX*\üSROHFHQLD
Watch (

TRL

-F7

). Po jego wydaniu (i wpisaniu nazwy odpowiedniej zmiennej lub

wyra

*HQLDZRNLHQNXAdd WatchQDGROHHNUDQXSRMDZLVLRNLHQNRWatches, zawiera-

MFH ZDUWRFL OHG]RQ\FK ]PLHQQ\FK Z QDV]\P SU]\SDGNX ]PLHQQHM

, czyli lewej

JUDQLF\SU]HG]LDáXSRV]XNLZDSLHUZLDVWND

Rysunek 15. Okienko Watches

3RQLHZD*SRZUyWGRRNLHQNDHG\WRUD]Z\NOHSRZRGXMHSU]\VáRQLFLHRNLHQNDWatches,

ZDUWRXSRU]GNRZDüXNáDGRNLHQHNQDHNUDQLHQSSU]HVXZDMFMH]DSRPRFP\V]NL

OXEZ\GDMFSROHFHQLHTile z menu Window.

'\VSRQXMF W\PL ZLDGRPRFLDPL PR*HV] MX* Z\NRU]\VWDü WU\E NURkowy i polecenia

SRGJOGDQLD ]PLHQQ\FK GR SU]HOHG]HQLD ]DFKRZDQLD ]PLHQQHM

EGFHM ELH*F

ZDUWRFLSLHUZLDVWND

Jak

uruchamia

üRSRUQHSURJUDP\

133

:SU]\SDGNXZLNV]\FKSURJUDPyZPR*HVLRND]Dü*HGRWDUFLHGRIDWDOQHMLQVWUXNFML

] Z\NRU]\VWDQLHP WU\EX NURNRZHJR MHVW ]E\W F]DVRFKáRQQe. W takich sytuacjach
z

SRPRFSU]\FKRG]LSROHFHQLHGo to cursor (

SRZRGXMFHZ\NRQDQLHZV]\VWNLFK

LQVWUXNFML D* GR PLHMVFD ZVND]DQHJR NXUVRUHP D QDVWSQLH SU]HMFLH GR SUDF\

NURNRZHM:\NRU]\VWXMFMHPR*HV]áDWZRÄZVNRF]\ü´QSGRZQWU]DIXQNFMLf(x) bez
koniecz

QRFLZ\NRQ\ZDQLDLQVWUXNFMLSRSU]HG]DMF\FKMHMZ\ZRáDQLH

-HOLSRZ\*V]HF]\QQRFLPDV]Z\NRQ\ZDüZLHORNURWQLH]QDF]QLHEDUG]LHMX*\WHF]QH
od funkcji Go to cursor

RND]XMHVLSROHFHQLHAdd breakpoint z menu Debug (

TRL

). Jego wydanie pozwala na ustawienie w miejscu wskazanym kursorem tzw. punktu

wstrzymania

SRZRGXMFHJR]DWU]\PDQLHSURJUDPXSRND*GRUD]RZ\PMHJRRVLJQLFLX

1LH GRü WHJR GRGDWNRZH SDUDPHWU\ SXQNWX ZVWU]\PDQLD Condition i Pass count)

XPR*OLZLDMMHJRZDUXQNRZHZ\NRQ\ZDQLHOXE]LJQRURZDQLHRNUHORQHMOLF]E\SU]HMü

2SFMHWHX*\ZDQHVU]DGNRLQLHEG]LHP\LFKWXRPDZLDüZZLNV]RFLSU]\SDGNyZ

X*\FLH SXQNWyZ ZVWU]\PDQLD VSURZDG]D VL GR LFKXVWDZLDQLDLXVXZDQLD]DSRPRF
klawiszy

TRL

-F8

(odpowiednia instrukcja zos

WDQLH Z\Uy*QLRQD Z WUHFL SURJUDPX

NRORURZ\PSDVNLHP3RGRMFLXSURJUDPXGRSXQNWXZVWU]\PDQLDQDRJyáZ\VWDUF]\

VSUDZG]Lü]DZDUWRüSRGHMU]DQHM]PLHQQHMSROHFHQLHPEvaluate lub Add Watch.

6NUyWRZHRPyZLHQLHSROHFHV\VWHPXXUXFKRPLHQLRZHJRNRF]\QDV]Hwprowadzenie

GRSURJUDPRZDQLDL7XUER3DVFDOD'DOV]HZLDGRPRFL]GREG]LHV]NRU]\VWDMF]EDU-
dziej zaawansowanej literatury, a przede wszystkim na drodze praktycznej —

SLV]F

SURJUDP\3DPLWDM

.RU]\VWDQLH]NRPSXWHUDQLH]ZDOQLDRGP\OHQLD

,P ZLNV]\ QDFLVN SRáR*\V] QD ZáDFLZH ]DSURMHNWRZDQLH UR]ZL]DQLD W\P PQLHM

F]DVXEG]LHV]PXVLDáSRZLFLüQDMHJR]DSURJUDPRZDQLHLW\PPQLHMV]HV]DQVH*H

EG]LHV]PXVLDáRGZRá\ZDüVLGRSRPRF\URGNyZXUXFKRPLHQLRZ\FK

Powodzenia!