A Turbo Pascal programok felépítése. A változók és a
konstansok |
A programunkat célszerű úgy írni, hogy a
későbbi fejlesztések során (akár évek múltán is) könnyen olvasható
legyen, még akár egy másik programozó számára is. Ezért ajánlott a
következőket betartani: -
Mielőtt
nekikezdünk a programozásnak, készítsünk tervet. A
legalkalmasabb módszer erre a Jackson-terv. -
A program különböző részeit szervezzük egységekbe (unitokba). -
Bár a Turbo Pascal nem különbözteti meg a
kis- és a nagybetűket, a könnyebb olvashatóság kedvéért a változók, az
eljárások és a függvények nevét írjuk nagybetűvel. -
A ciklusmagokat és az eljárástörzseket illetve a függvénytörzseket
írjuk 2-3 karakterrel beljebb. -
Használjunk inkább lokális változókat globális változók helyett. A lokális
változókat csak az eljárás látja, amiben deklaráltuk, míg a globális változót
a program összes eljárásában és függvényében, valamint a főprogramban is
használhatjuk, ami azt is jelenti, hogy egy eljárás vagy függvény változóját
bármelyik másik módosíthatja, míg a lokális változók más eljárások illetve
függvények „belepiszkálásától” védettek. Egy Turbo
Pascal program mindig a Begin paranccsal
kezdődik és az End. paranccsal fejeződik be. Ugyan ez igaz az
eljárásokra és a függvényekre is, csak ezek az End; sorral záródnak, nem
ponttal a végén. Egy Turbo
Pascal program szerkezete a következőképpen néz ki: Program programnév; A programunk által használt unitok
megjelölése Globális típusok deklarálása Globális változók deklarálása Globális konstansok deklarálása Eljárások és függvények Eljárások
vagy függvények lokális típusainak deklarálása Eljárások
vagy függvények lokális változóinak deklarálása Eljárások vagy
függvények lokális konstansainak deklarálása Eljárás-
vagy függvénytörzs Főprogram |
A programnév |
A programnevet nem kötelező megadni, de
célszerű annak érdekében, hogy a későbbiekben is tudjuk
miről szól, amit írtunk. Ha írunk egy jó eljárást, esetleg
elővehetjük évek múlva, amikor hasonlót kell írnunk; a programnév
megadása megkönnyítheti az eljárás megtalálását. A programnév nem
tartalmazhat ékezetes betűket, és mint a legtöbb Turbo
Pascal utasítást – néhány kivételtől eltekintve – pontosvesszővel
zárunk: Program Elso; |
A programunk által használt unitok
megjelölése |
A Turbo Pascal
programokat célszerű úgy megírni, hogy a különböző dolgokkal
foglalkozó részek (például az ablakkezelés, a billentyűzetkezelés, a
lemezkezelés, a menükezelő eljárások) különböző file-okba
(unitokba, vagy magyarul egységekbe) kerüljenek. Ennek az oka kettős, egyrészt
azért, hogy a program ne legyen túl nagy és így áttekinthetetlen, másrészt a
program különböző részeit külön kell fejleszteni és tesztelni (moduláris
programozás), hogy az egyik modul esetleges hibája ne zavarja a program többi
részét. A unitfile-ok
kiterjesztése .TPU. Ezeket az előre megírt unitokat egy közös
fejlesztői könyvtárba, úgynevezett Turbo
Pascal Libraryba lehet összegyűjteni,
amelyeknek a kiterjesztése .TPL. A Turbo
Pascalban vannak előre megírt unitok, ezek a TURBO.TPL
fájlban helyezkednek el. Ezek a unitok a SYSTEM.TPU (a
rendszerrel kapcsolatos alapvető dolgokat tartalmazza), az OVERLAY.TPU
(az átlapozással kapcsolatos dolgokat tartalmazza – ezekről
bővebben később lesz szó), a CRT.TPU (a képernyőkezeléssel
kapcsolatos dolgokat tartalmazza – például a képernyőtörlés stb.),
DOS.TPU (a DOS-sal kapcsolatos funkciók gyűjteménye
– például a megszakítások stb.) és a PRINTER.TPU (a nyomtatáshoz szükséges
unit). Mi is készíthetünk saját unitokat, mint azt a későbbiekben
meg is tesszük, sőt, a Turbo Pascal Library-ből törölhetünk is unitokat. A programunkba a uses paranccsal illeszthetünk
be unitot. A System unitot a Turbo
Pascal automatikusan beilleszti, azzal már nem kell foglalkoznunk; a Crt és a Dos unitot mindig
érdemes beillesztenünk, általában ezekre szükség van. Program Elso; Uses Crt, Dos; |
Globális változók deklarálása |
A változók deklarálását előrevettem, mert
szükséges ismerni a változók fogalmát a típus létrehozásához. A változókat úgy képzelhetjük
el, hogy van egy fiókos asztalunk, és minden fiókba különböző dolgokat
tehetünk: az egyikbe csak gémkapcsokat, a másikba csak A4-es papírt, a
harmadikba csak A3-as papírt, a negyedikbe csak borítékot, és a fiókban
lévő tárgyak mennyisége megváltozhat. A Turbo
Pascalban számtalan változótípus létezik: van, amiben számokat, van amiben
szövegeket és van, amiben bonyolult, összetett dolgokat tárolhatunk, de az közös bennük, hogy értéküket a program futása során
megváltoztathatjuk. A következő változófajtát
kell választanunk, ha egy változóba egész számot szeretnénk tenni: Shortint: értéke –128-tól 127-ig terjedhet, előjeles, 8 bites. Integer: értéke –32768-tól 32767-ig terjedhet, előjeles, 16 bites. Longint: értéke –2147483648-tól 2147483647-ig terjedhet, előjeles,
32 bites. Byte: értéke
0-tól 255-ig terjedhet, előjel nélküli, 8 bites. Word: értéke 0-tól 65535-ig terjedhet, előjel nélküli, 16
bites. Amennyiben valós
számokkal szeretnénk dolgozni, azokat erre alkalmas változókban kell
tárolnunk. Az ilyen célra az alábbi változótípusokból választhatunk: Real: értéke –2.9-39-tól
1.738-ig terjedhet, 11-12 számjegy, 6 byte-os. Single: értéke –1.5-45-tól 3.438-ig
terjedhet, 7-8 számjegy, 4 byte-os. Double: értéke –5.0-324-tól 1.7308-ig
terjedhet, 15-16 számjegy, 8 byte-os. Extended: értéke –3.4-4932-tól 1.14932-ig
terjedhet, 19-20 számjegy, 10 byte-os. Comp: értéke –9.2-18-tól 9.218-ig terjedhet, 19-20
számjegy, 8 byte-os. A karaktertípus neve Char, míg a karakterek egymás utáni sorozatának String. Létezik a Turbo Pascalban egy olyan változótípus, amelynek két
értéke lehet: hamis vagy igaz (true vagy false); ez a változótípus a Boolean. A későbbiekben még olvashatnak
másik öt típust is, melyek: Tömb: Ugyanolyan
típusú változók tárolására szolgáló adathalmaz. Rekord: Összetartozó
adatokat, de többféle típusú változót tudunk eltárolni benne (például egy
személy neve, címe, születési ideje és helye). Pointer: A pointer a memória meghatározott címére
mutat. Text: Típus
nélküli file. File of…: Típusos file. A változókat a var (az
angol variable (változó) szóból származik)
paranccsal deklarálhatjuk. Szintaktikája a következő: Var Valtozonev : tipus; A változók deklarálását is – ahogy ezt már
megszokhattuk – pontosvesszővel kell lezárni. A változónevekben, az
eljárások és a függvények nevében szintén nem szerepelhetnek ékezetes nevek. Álljon itt egy példa a változók deklarálására: Program Elso; Uses Crt, Dos; Var Bekert_szoveg : String; Ciklusvaltozo
: Byte; |
Globális típusok deklarálása |
A Turbo Pascal Type parancsával lehetőségünk nyílik arra, hogy
mi is készíthessünk saját változótípusokat. A típusdeklaráció
szintaktikája következőképpen fest: Type ujvaltozotipusnev
= változótipus; Természetesen a típusdeklarációt is pontosvesszővel kell lezárni, a
változónév nem tartalmazhat ékezetes betűt. A lenti példán láthatjuk, hogy az általunk megadott típust már
megadhatjuk a változódeklarációnál. Persze itt még nem sok értelme van típust
deklarálni, mert közvetlenül is megadhatjuk a típusát, de majd látunk olyan példát,
ahol elegánsabb így megoldani. Program Elso; Uses Crt, Dos; Type Szovegtipus = String; Var Bekert_szoveg : Szovegtipus; Ciklusvaltozo
: Byte; |
Globális konstansok deklarálása |
A konstansok értéke – amint
az nevében is benne van – a program futása során nem változhat. Konstanst a Const paranccsal hozhatunk létre. A konstansdeklaráció
szintaktikája következőképpen fest: const konstansvaltozo
= ertek; Konstansváltozó lehet
szám vagy string. Álljon itt egy példa a konstans deklarációjára: Program Elso; Uses Crt, Dos; Type SzovegTipus = String; Var Bekert_szoveg : SzovegTipus; Ciklusvaltozo : Byte; Const Jelszo = ’Hello, Pascal!’; |
Eljárások és függvények |
Eljárásokat és függvényeket akkor használunk, ha
egy eljárást a programunkban többször szeretnénk meghívni, illetve a
programunk egy részletét egy másik programban is fel szeretnénk használni.
Mind az eljárásnak, mind a függvénynek adhatunk át paramétert, amit csak az az adott eljárás vagy függvény fog látni (lokális változó
lesz), ellenben a függvény vissza is ad egy értéket. Az eljárások és a
függvények korlátlanul egymásba ágyazhatók. Az eljárást a procedure eljárásnév (esetleges paraméter); kulcsszóval, a
függvényt a function függvénynév (esetleges paraméter): visszaadott érték típusa; kulcsszóval
deklaráljuk. Természetesen mind az eljárás-, mind a függvénydeklarációt
pontosvesszővel kell lezárni. Álljon itt egy példa egy
eljárás és egy függvény létrehozásáról: Uses Crt, Dos; Type SzovegTipus = String; Var Bekert_szoveg : SzovegTipus; Ciklusvaltozo : Byte; Const Jelszo =
’Hello, Pascal!’; Procedure Szovegbekero_eljaras (Kodolt :
Boolean); Begin End; Function Jelszoellenorzo_fuggveny
(Jelszo
: String) : Boolean; Begin End; |
Eljárások és függvények lokális típusainak,
lokális változóinak és lokális konstansainak deklarálása |
Az eljárások és függvények lokális típusainak,
lokális változóinak és lokális konstansainak deklarálása ugyanúgy történik,
mint a globális típusok, változók és konstansok deklarációja; az eljárás vagy
függvény első sorában állnak, és tulajdonságuk az, hogy az eljáráson
illetve a függvényen kívüli eljárás vagy függvény nem férhet hozzá, ellenben
a beágyazott eljárások és függvények (amelyek alatta vannak) hozzáférhetnek.
Ugyanez igaz a globális változókra is, tehát a deklaráció alatti függvények
és eljárások hozzáférhetnek, a fölötte lévők nem. Ha egy eljárásban vagy
függvényben ugyanolyan nevű típust, változót vagy konstanst hoztunk
létre, ami korábban már létezett, akkor az új típus, változó vagy konstans
lesz érvényes (a régit a verembe teszi), és amint kilép a függvényből
vagy eljárásból, az eredeti változó vagy konstans visszakapja értékét. A
verem a memóriának egy része, amelyben úgy tudunk adatokat tárolni, hogy amit
utolsónak beletettünk, azt tudjuk elsőként
kivenni belőle (LIFO – Last In, First Out rendszerű). Példa a lokális változó
létrehozására: Uses Crt, Dos; Type SzovegTipus = String; Var Bekert_szoveg : SzovegTipus; Ciklusvaltozo : Byte; Const Jelszo =
’Hello, Pascal!’; Procedure Szovegbekero_eljaras (Kodolt :
Boolean); Begin End; Function Jelszoellenorzo_fuggveny
(Jelszo
: String) : Boolean; Var Ciklusvaltozo : Byte; Begin End; |
Az eljárástörzs és a függvénytörzs |
Az eljárástörzsben és a függvénytörzsben található
utasítások soronként, egymás után végrehajtódnak. Amikor a programunk több
részén szeretnénk ugyanazt a dolgot végrehajtani, érdemes eljárásba (vagy ha
kell visszaadott érték, akkor függvénybe) szervezni, így időt és értékes
tárhelyet takaríthatunk meg. |
A főprogram |
A főprogram a programnak az a része, ami
elsőként betöltődik a memóriába, innen lehet meghívni az eljárásokat illetve a függvényeket. Ami a főprogramban van, soronként kerül végrehajtásra. Álljon most itt a teljes, futtatható program: Uses Crt, Dos; Type SzovegTipus = String; Var Bekert_szoveg : SzovegTipus; Ciklusvaltozo : Byte; Const Jelszo =
’Hello, Pascal!’; Procedure Szovegbekero_eljaras (Kodolt :
Boolean); Begin End; Function Jelszoellenorzo_fuggveny : Boolean; Var Ciklusvaltozo : Byte; Begin End; Begin Szovegbekero_eljaras
(False); Jelszoellenorzo_fuggveny; End. Ha programunkat
lefuttatjuk, egyelőre nem látunk semmit, mert most még csak a főprogram
meghívott egy üres eljárást és egy üres programot. Ez lesz későbbi programunk váza. |
Halmos
Tamás Kristóf |