Kozics Sándor A Pascal programozási nyelvjoceee.web.elte.hu/vegyesz/elte_tananyag/pascal4.pdf · Kozics Sándor: A Pascal programozási nyelv - 4 - 2. Elemi nyelvi egységek A Pascal

Kozics Sándor

A

Pascal

programozási nyelv

Utómunkálatok: Helfenbein Henrik, Tóth Zoltán Budapest, ELTE Informatikai Kar, 2004

Észrevételek: [email protected]

mailto:[email protected]

Kozics Sándor: A Pascal programozási nyelv

- 2 -

Tartalomjegyzék 1. BEVEZETÉS .......................................................................................................................................... 3

2. ELEMI NYELVI EGYSÉGEK ............................................................................................................. 4

3. A PASCAL PROGRAM ........................................................................................................................ 5

4. A PASCAL NYELV TÍPUSAI .............................................................................................................. 7 4.1. EGYSZERŰ TÍPUSOK........................................................................................................................... 7 4.2. A REKORD TÍPUS.............................................................................................................................. 10 4.3. A REKORD VÁLTOZATAI .................................................................................................................. 11 4.4. VEKTOR, TÖMB................................................................................................................................ 11 4.5. A HALMAZ TÍPUS ............................................................................................................................. 12 4.6. A MUTATÓ TÍPUS ............................................................................................................................. 14 4.7. SZEKVENCIÁLIS FILE-OK.................................................................................................................. 14

4.7.1. A szekvenciális input file-okra értelmezett műveletek ............................................................. 14 4.7.2. A szekvenciális output file-okra értelmezett műveletek ........................................................... 15

4.8. TEXTFILE-OK ................................................................................................................................... 15 4.8.1. Szekvenciális input TEXT-file-okra vonatkozó műveletek....................................................... 15 4.8.2. Szekvenciális output TEXT-file-okra vonatkozó műveletek..................................................... 16

5. ELJÁRÁSOK, FÜGGVÉNYEK ......................................................................................................... 18

6. FELADATOK....................................................................................................................................... 21


- 3 -

1. Bevezetés

A 60-as évek közepéig kialakult nyelveknél a tervezők csak a programozók gyakorlati tapasztalatára támaszkodhattak. Ez kevés támasznak bizonyult egy nyelv definiálásához. Ezután megkísérelték a nyelv és a nyelv implementációjának szétválasztásával a nyelvi fogalmakat matematikai úton tisztábbá tenni. Ilyen törekvések eredménye lett például az Algol 68. További segítséget az jelentett, amikor az évtized végétől kezdve megjelentek Floyd, Dijkstra, Hoare és mások, a programozáselméletben alapvető munkái. Ezek nyomán a programozás mesterségből előlépett tudománnyá.

A Pascal programozási nyelv [10,21,23] első, vázlatos formáját N. Wirth 1968-ban írta le. A tervezők célja egy olyan nyelv kialakítása volt, ami a programozás oktatásában jól használható és könnyen implementálható. Szellemében az új nyelv az Algol 60 és az Algol-W vonalát követte, de erősen hatottak rá Hoare-nak a típusokkal kapcsolatos elképzelései [11]. A nyelv első hivatalos publikációja 1971-ben jelent meg, majd a használata során szerzett tapasztalatok alapján 1973-ban adták közre az átdolgozott definíciót.

A Pascal tette meg az első lényeges lépést abba az irányba, hogy a nyelvben absztrakciót tegyen lehetővé. Jó példa erre a felsorolási típus. Tervezésekor azonban túlságosan is vigyáztak arra, hogy egyszerű legyen, ne essenek az Algol 68 hibájába. Sajnos az Algol 68-beli jó ötleteket is elvetették a rosszak miatt, ráadásul a Pascal sok, az Algol 60-ból származó kezdetleges szintaktikus megoldást tartalmaz. További problémák, hogy a Pascal bizonyos szempontból szegényesen bánik a típusokkal, képtelen olyan rugalmasan kezelni a tömböket, mint az Algol 60, és a modularitás is hiányzik belőle. Az I/O -t bár a Pascal tartalmazza, "ad hoc" módon tervezték, és nem kiterjeszthető. Bár több gyengeség is található a nyelvben, hasznát és fontosságát mutatja, hogy több utána kialakított nyelvnek is alapjául szolgált.


- 4 -

2. Elemi nyelvi egységek

A Pascal jelkészlete háromfajta jelből áll. Ezek a betűk (A..Z, a..z), a számjegyek (0..9), és a következő speciális jelek (elhatároló jelek és alapszavak) :

+ - * / = <> < > <= >= ( ) <szóköz> [ ] (* *) := . .. ; : ' ^ ,

AND ARRAY BEGIN CASE CONST DIV DO DOWNTO ELSE END FILE FOR FUNCTION GOTO IF IN LABEL MOD NIL NOT OF OR PACKED PROCEDURE PROGRAM RECORD REPEAT SET THEN TO TYPE UNTIL VAR WHILE WITH

(A speciális jelkészlet egy részét több karakterrel fejezzük ki, de ezek nem választhatók el semmilyen körülmények között sem. A " " jellel a szóközt jelöljük.) Az alapszimbólumok mellett elemi nyelvtani egységek még az azonosítók, számok és a karakterláncok (stringek). Az azonosítókat konstansok, típusok, változók, eljárások és függvények jelölésére használjuk. Egy azonosító csak betűvel kezdődhet, betűket és számjegyeket tartalmazhat (csak az első 8 karaktere érvényes). Az egész számok előjelből és számjegyekből állhatnak (pl. -2, 6, +341), a valós számok írására két formát használunk: a tizedestörtes alakot (pl. 3.14, -0.1), és a kitevős alakot (pl. 5E-3, 87.35 E+8, amelyek jelentése ötször tíz a mínusz harmadikon, és nyolcvanhét egész harmincöt század szorozva tíz a nyolcadikonnal).

A két aposztróf közé tett jelsorozatot karakterláncnak (string-nek) nevezzük (ha a karakterláncba aposztrófot akarunk írni, azt meg kell kettőzni). Karakterláncok pl. a következők: 'karakterlanc', ' ', 'Pascal', ''''.

Bármely két azonosító, szám, vagy speciális szimbólum közé leírható a

(* tetszőleges, '*)' -t nem tartalmazó jelsorozat *)

konstrukció, az ún. magyarázat (komment).

A Pascal program elemi nyelvtani egységeknek a (következőkben tárgyalandó) szintaktikus szabályoknak eleget tevő sorozata.


- 5 -

3. A Pascal program Áttekintjük a nyelv legfontosabb elemeit, majd a további pontokban részletesen tárgyaljuk a típusok, típusműveletek és az alprogramok (azaz eljárások és függvények) írásának szabályait. A Pascal nyelven írt program (sorrendben) a következő részekből áll:

- fejrész (a program azonosítójának megadása) - konstansdefiníciók - típusdefiníciók - változódefiníciók - alprogramok definíciói - utasítássorozat, a program végrehajtható része

A Pascal programban az alprogramok (ld. 4.) ugyanolyan felépítésűek, mint maga az egész program. Ezeket az egységeket blokkoknak is mondjuk, és a blokkok által alkotott hierarchikus szerkezet neve blokkstruktúra. A program bármely blokkjában definiált azonosító a szokásos értelemben lokális ill. globális: egy deklaráció hatásköre kiterjed magára a blokkra és a blokkban definiált blokkokra, viszont nem lép túl azon (a blokkot tartalmazó blokkokra). Egy blokkban láthatóak a blokk lokális deklarációi és a blokkot tartalmazó blokkok deklarációi (hacsak egy lokális azonosító meg nem egyezik egy globális azonosítóval, ekkor ugyanis a globális azonosítóra - bár a hatáskörén belül vagyunk - nem tudunk hivatkozni). A változók élettartama nem terjed ki a program végrehajtásának teljes idejére: a blokkban definiált változók a blokk utasításrésze végrehajtásának megkezdésekor "születnek meg", a végrehajtása befejezésekor pedig "megszűnnek létezni". A Pascal nyelvben (előredefiniált) elemi típusok az egész, logikai, karakteres és a valós, típuskonstrukciók a rekord, az unió, valamint a halmaz, a vektor (tömb) és a szekvenciális file (ld. 3.). A megengedett feltételek az "=" (egyenlő), "<>" (nem egyenlő) relációkból (ezek file-ok kivételével minden más változóra alkalmazhatók), a logikai típus típusműveleteiből (NOT, AND, OR) és rendezett típusok esetében a "<", ">", "<=", ">=" relációkból, a halmaz típushoz tartozó "IN" (tartalmazási) relációból, valamint változókból, függvényhivatkozásokból és konstansokból épülhetnek fel. Az elemi programok az értékadás (ami a file-okat kivéve minden fajta változóra alkalmazható, jele a szokásos ":=" ), a típusok típusműveletei (ld. 3.), és megengedettek a következő f0 programkonstrukciók (a jelentésüket egy-egy megegyező hatású struktogrammal adjuk meg). Az utasítások elválasztására a ";" szolgál.

S1 S2 S1 ; S2

Az üres programnak külön jele nincs, egyszerűen nem írunk semmit a program helyére. Így pl. S1;;;S2 is szabályos. A ciklusnak a Pascalban három formája használatos.

f S WHILE f DO BEGIN S END

S NOT f REPEAT S UNTIL f S

i:=i0 I≤n S FOR i:=i0 TO n DO BEGIN S END I:= i+1

Itt i, i0 és n típusa INTEGER, BOOLEAN, CHAR, felsorolási típus vagy részintervallum (ld. 3.1.). Elágazást szintén többféleképpen kódolhatunk.

\ f / S SKIP IF f THEN BEGIN S END

\ f / IF f THEN BEGIN S1 END

S1 S2 ELSE BEGIN S2 END


- 6 -

t=t1

\ ...

\ t=tn

\ t<>t1 ^ ... ^ t<>tn

\ S1 ... Sn SKIP

CASE t OF t1 : BEGIN S1 END; ... tn : BEGIN Sn END; END;

Ha a programokban az S,S1,S2,... program nem szekvencia, hanem csak egyetlen konstrukcióból, vagy elemi programból áll, akkor a BEGIN-END ún. utasítás-zárójelek elhagyhatók.

(* Teljes Pascal program : n db érték koszinuszának meghatározása *)

PROGRAM cosinus; CONST eps = 1E-8; VAR x,sx,s,t: REAL;

i,k,n : INTEGER; BEGIN

WRITELN('n ? '); READLN(n); FOR i := 1 TO n DO

BEGIN WRITELN('x ? '); READLN(x); t := 1.0; k := 0; s := 1.0; sx := x*x;

WHILE ABS(t) > eps*ABS(s) DO BEGIN k := k+2; t := -t*sx/(k*(k-1)); s := s+t END; WRITELN(x,s,k DIV 2) END;

END; END.


- 7 -

4. A Pascal nyelv típusai

A típus fogalma a Pascalban sokkal fontosabb szerepet kap, mint bármelyik korábbi nyelvben. Két típust a Pascalban akkor tekintünk ekvivalensnek, ha a konstrukciójuk megegyezik és a megfelelő helyeken szereplő elemi típusok ugyanazok. Az értékadás két oldalának, valamint az egymásnak megfeleltetett formális és aktuális paramétereknek (ld. 5.) a típusai ekvivalensek kell legyenek. A Pascal típusdefiníciói statikusak, kiértékelésük teljes egészében fordítási időben történik (következésképpen a típusdefiníciók nem tartalmazhatnak változókat, csak konstansokat).

4.1. Egyszerű típusok

A típusok definiálásának legegyszerűbb módja az, hogy azonosítóikkal felsoroljuk a típusértékeket. TYPE t = ( c0 , c1 , ..., cn )

A felsorolási típus definíciója nemcsak új típusazonosítót vezet be, hanem az új típus értékeit megjelölő azonosítókat is. Ezek az azonosítók azután konstansként használhatók a programban.

TYPE alakzat = (haromszog, teglalap, kor) ; szin = (piros sarga, zold, fekete) ; nem = (ferfi, no) ; nap = (hetfo, kedd, szerda, csutortok, pentek,

szombat, vasarnap) ; valuta = (marka, font, dollar, lira, forint, rubel, yen) ;

Ha bevezetjük a

VAR a : alakzat ; v : valuta ;

változódeklarációkat akkor szabályosak a

a := kor; v := lira ;

értékadások. A felsorolási típus rendezett típus, ahol

ci < cj i < j ,

és a felsorolási típusok értékeire értelmezve vannak a "<", ">", "<=", ">=" relációk.

A felsorolási típus típusműveletei a PRED(x), a SUCC(x), és az ORD(x) függvények. Ezek definíciója a következő:

i [0,n-1] : SUCC(ci) = ci+1, i [1,n] : PRED(ci) = ci-1, i [0,n] : ORD(ci) = i .

Azaz PRED(kedd) = hetfo, SUCC(lira) = forint, PRED(v) = dollar, és ORD(v) = 3, ha v = lira.


- 8 -

A Pascal standard egyszerű típusai (vagy predefinit típusai) a következők: INTEGER (egészek)

BOOLEAN (logikai típus) CHAR (karakteres típus) REAL (valós típus)

Az INTEGER, BOOLEAN, CHAR típust, a felsorolási típusokat és ezek részintervallumait együttvéve diszkrét típusnak mondjuk.

Az INTEGER típus műveletei az összeadás (+), kivonás (-), szorzás (*), osztás (DIV), a modulus-képzés (MOD), a négyzetre-emelés (SQR(x)), valamint az ABS(x) és az ODD(x) függvények (az ODD(x) igaz, ha x páratlan, különben hamis). Itt m DIV n az m és n egész hányadosa, és teljesül a következő egyenlőség:

(m DIV n)*n + (m MOD n) = m .

A REAL típus műveletei az összeadás (+), kivonás (-), szorzás (*), osztás (/), valamint az ABS(x), SIN(x), COS(x), EXP(x), LN(x), SQR(x) (négyzetre-emelés), SQRT(x) (négyzetgyökvonás) függvények. A REAL és az INTEGER típus közötti átviteli (konverziós) függvények a FLOAT és a TRUNC. FLOAT(i) az i egész számnak megfelelő valós érték, TRUNC(x) az x valós számnál abszolút értékben kisebb legnagyobb egész szám.

A BOOLEAN típus konstansainak nevei a TRUE (igaz), és a FALSE (hamis), a definíciója

TYPE BOOLEAN = (FALSE, TRUE) .

A logikai típuson értelmezett műveletek a NOT (tagadás), az OR (vagy), és AND (és). Logikai értéket szolgáltatnak a relációk és az ODD függvény.

A CHAR típus típusérték-halmaza az adott számítógép standard karakterkészlete. A típus tartalmazza a latin betűket, a számjegyeket, és egyéb jeleket (pl. <,=, /,...), valamint tartalmaz egy helyköz karaktert (space). A betűk és a számjegyek részhalmazára teljesül a következő:

( 'A' =< x ) ^ ( x =< 'Z' ) x betű

( '0' =< x ) ^ ( x =< '9' ) x számjegy

A CHAR és az INTEGER típusok között is létezik két átviteli függvény, az ORD és a CHR : ORD(c) a c karakternek a CHAR típusérték-halmazbeli sorszáma, CHR(i) pedig a CHAR típus i-edik karaktere (0 =<i =<255). Érvényesek a következő összefüggések:

ORD(CHR(i)) = i (ha CHR(i) definiált),

CHR(ORD(c)) = c.

Bármely diszkrét típus típusérték-halmazának felhasználásával definiálható részintervallum. A részintervallum-képzés nem vezet be új típust; a részintervallum típus ekvivalens az őstípusával. Itt mindössze az értékhalmaz leszűkítéséről van szó, ami a program végrehajtásakor ellenőrzésre ad lehetőséget.

TYPE t = min .. max

A részintervallumra érvényesek az őstípus műveletei (értelemszerűen leszűkítve a min..max intervallumra) .

TYPE ev = 1900 .. 1999 ; TYPE betu = 'A' .. 'Z' ; TYPE munkanap = hetfo .. pentek ;


- 9 -

Gyakorlatok

1. Állapítsuk meg, milyen feladatot old meg az alábbi programrészlet !

a) CONST n = 10 ; TYPE vektor1 = ARRAY CHAR OF INTEGER;

vektor2 = ARRAY [1..n] OF CHAR; VAR t : vektor1;

x : vektor2; i : INTEGER ; c : CHAR;

BEGIN FOR c:=CHR(0) TO CHR(255) DO t[c] := 0 ; FOR i:=1 TO n DO

IF ('A' <= x[i]) AND (x[i] <= 'Z') THEN t[x[i]] := t[x[i]] + 1 END ;

b) TYPE ev = 1 .. 365 ;

nap = (munka,unnep) ; vektor = ARRAY [ev] OF nap;

VAR i,n,s : INTEGER; x : vektor;

n := 0 ; i := 1 ; WHILE (i <= 365) AND (n <> 100) DO

BEGIN n := n + ORD(x[i]=munka); i := i+1

END ; IF n=100 THEN szazadik := i ELSE szazadik := 0


- 10 -

4.2. A rekord típus

TYPE t = RECORD

s1 : T1 ; ... sn : Tn ; END

Itt s1,s2,...,sn a szelektorok, T1,T2,...,Tn tetszőleges típusok. Egy x:t változó komponenseinek értékére az alábbi formában hivatkozhatunk:

x.s1 , x.s2 , ..., x.sn

TYPE komplex = RECORD va:REAL; ke:REAL END ; TYPE datum = RECORD

ev : 1..2000 ; ho : 1..12 ; nap : 1..31

END ; TYPE szemely = RECORD

vezeteknev, keresztnev : alfa ; szuletes : datum ; nem : (ferfi, no) ; allapot : (maganos, hazas, ozvegy, elvalt);

END ;

Ha érvényesek a

VAR z : komplex ; VAR d : datum ; VAR s : szemely;

deklarációk, akkor szabályosak a

d.ho := 10 ; z.ke := 0.0 ; s.nem := ferfi ;

értékadások.

A program utasításaiban a rekord típusú változókra való hivatkozás rövidítésére szolgál a WITH utasítás.

WITH d DO IF honap = 12 THEN BEGIN honap:=1; ev:=ev+1 END; ELSE honap:=honap+1;

A WITH utasítás belsejében a rekord mezőire pusztán a szelektorokkal hivatkozunk, a rekordváltozó neve nem használható.


- 11 -

4.3. A rekord változatai TYPE t = RECORD

s1 : T1 ; ... sn : Tn ; CASE s : T0 OF c1 : ( s11 : T11 ; ... ); ... cm : ( sm1 : Tm1 ; ... ) END

Ahol T0 diszkrét típus (általában felsorolási vagy részintervallum típus) , a szelektorok pedig mind különbözőek. Egy x : t változó az x.sub 1, x.s2, ..., x.sn és az x.s11, x.s12, ... komponensekből áll, ha x.s = c1 ... Az x.s1, ..., x.sn, x.s komponensek az m darab változat közös részét alkotják, és bár x.s1,...x.sn elmaradhat, azért a változatoknak legalább egy közös komponense van.

TYPE t = RECORD x,y : REAL ; terulet : REAL ; CASE s : alakzat OF

haromszog : (oldal : REAL ; doles, szog1, szog2 : REAL);

teglalap : (oldal1, oldal2 : REAL; dolesszog : REAL );

kor (sugar : REAL ) END ;

4.4. Vektor, tömb

A Pascal nyelvben lehetőség van egy- és többdimenziós tömbök (pl. vektorok, mátrixok) definiálására. Ezek megfelelnek az egy- ill. többváltozós függvénytípusnak.

TYPE t = ARRAY [ I ] OF T0

Itt T0 tetszőleges típus, I pedig egy diszkrét típus. I a függvény értelmezési tartománya.

TYPE string = ARRAY [1..5] OF CHAR ; TYPE vektor = ARRAY [1..hossz] OF t ; TYPE matrix = ARRAY [1..n,1..n] OF szin;

A CHAR típus elemeiből képezett vektor rendezett típus. A tömbök elemeire indexekkel hivatkozunk. x[i] , m[i,j]

Gyakorlatok

2. Fogalmazzuk meg, milyen feladatot old meg az alábbi programrészlet !

CONST hossz = 10; h = 0 ; VAR x : ARRAY [1..hossz] OF INTEGER ;

m,n,k : INTEGER ; l : BOOLEAN ;

... l:=FALSE; m:=1; n:=hossz; WHILE NOT l AND m <= n DO

BEGIN k := (m+n) DIV 2 ;

IF x[k]=h THEN l:=TRUE ELSE IF x[k]<h THEN m:=k+1 ELSE n:=k-1

END;


- 12 -

4.5. A halmaz típus TYPE t = SET OF T0

Itt a T0 típus csak diszkrét típus lehet, amelynek nincs több mint 64 értéke.

TYPE ehalmaz = SET OF 0..63 ; TYPE karhalmaz = SET OF CHAR ; TYPE szinhalmaz = SET OF szin ;

Ha érvényesek a VAR s : ehalmaz ;

VAR c : karhalmaz ; VAR t : ARRAY [1..6] OF színhalmaz ;

deklarációk, akkor szabályosak az s := [1,4,9,16] ; c := ['+','-','*','/'] ; t[1] := [] ; t[2] := [piros..zöld] ;

értékadások.

A halmaz típus típusműveletei a következők:

metszetképzés (jele a * ) egyesítés (jele a + ) különbség (jele a - ) halmazba tartozás (a reláció jele IN )

Gyakorlatok

3. Fogalmazzuk meg, milyen feladatot old meg az alábbi programrészlet! a)

TYPE szamjegyek = SET OF '0'..'9' ; VAR kn,i : INTEGER ; x : ARRAY [1..80] OF CHAR ; hn : szamjegyek ; BEGIN ... kn:=0 ; hn := ['0','2','4','6','8'] ; FOR i:=1 TO 80 DO IF x[i] IN hn THEN kn:=kn+1 END;

b) CONST n = 10 ; kezdo = '(' ; zaro = ')' ; TYPE vektor = ARRAY ['A'..'Z'] OF CHAR ; betuk = SET OF CHAR ;

VAR c:CHAR; p:INTEGER; mh:betuk; x:vektor;

p := 0 ; c := PRED('A') ; WHILE c <> 'Z' DO BEGIN c := SUCC(c) ; IF x[c] = kezdo THEN WHILE x[c] <> zaro DO c := SUCC(c) ; IF x[c] IN mh THEN p := p+1 END; END ;


- 13 -

4. Adottak a következő típusok :

TYPE szin = (kek,piros,sarga,zold,fekete,feher); adat = RECORD

s : SET OF szin; db : INTEGER

END;

Írjunk olyan programrészletet, ami összeadja a v:adat; változó azon elemeinek "db" mezőit, amelyeknek az "s" komponense csak a "feher" és "fekete" színeket tartalmazza!


- 14 -

4.6. A mutató típus Egy alprogram végrehajtása során annak lokális változói mindvégig léteznek. Ezért az ilyen változókat statikus változóknak nevezzük. Definiálhatunk olyan változókat is, amelyek a program statikus struktúrájától függetlenül léteznek. Az ilyen, ún. dinamikus változókat a NEW predefinit eljárás hozza létre, s minthogy explicit változódeklarációban nem szerepelnek, névvel nem hivatkozhatunk rájuk. Ehelyett egy ún. mutató (pointer) értékén keresztül érhetők el, amely a dinamikus változó előállításakor keletkezik. Egy mutató típus tehát olyan értékek halmaza, amelyek azonos típusú értékekre mutatnak. A mutató típusokra az értékadáson és az egyenlőségvizsgálaton kívül más művelet nincs értelmezve. A NIL konstans mutatóérték mindegyik mutatótípusnak eleme; ez egyetlen értékre sem mutat.

TYPE kapcsolat = ^személy; személy = RECORD;

név : ARRAY [1..20] OF CHAR; kor : INTEGER; következő : kapcsolat

END; VAR pt, fej : kapcsolat; pt := fej; b := TRUE; WHILE (pt <> NIL) AND b DO

IF pt^.kor < 30 THEN b := FALSE ELSE pt := pt^.következő;

A NEW(pt) eljáráshívás helyet jelöl ki a memóriában egy személy típusú értéknek, és a pt mutató értékét erre a helyre irányítja.

fej := NIL; WHILE NOT EOLN DO BEGIN

READ(x); NEW(q); q^.x := x; q^.q := NIL; IF fej = NIL THEN fej := q ELSE p^.q := q; p := q;

END;

4.7. Szekvenciális file-ok

Legyen T0 tetszőleges (de nem file) típus. Ekkor

TYPE t = FILE OF T0

formában definiáljuk a szekvenciális file típust. Míg a többi változó ábrázolása az operatív memóriában történik, a szekvenciális file-ok háttértáron, általában mágneslemezen helyezkednek el.

TYPE szoveg = FILE OF CHAR ;

TYPE kartyacsomag = FILE OF kartya ; Legyen

TYPE t = FILE OF rekord ; VAR f : t ;

x : rekord ; fn: ARRAY [1..16] OF CHAR;

4.7.1. A szekvenciális input file-okra értelmezett műveletek

• RESET(f,fn) a file megnyitása ("fn" a file neve)

• x:=f^;GET(f) a lorem művelet - olvasás a file-ból

• EOF(f) logikai függvény (pontosan akkor igaz, ha a file "üres", azaz a READ -del az utolsó

elemét is leválasztottuk)


- 15 -

4.7.2. A szekvenciális output file-okra értelmezett műveletek

• REWRITE(f,fn) _fcres file létrehozása ("fn" a file neve)

• f^:=x;PUT(f) a hiext művelet - írás a file-ba

• CLOSE(f) a file lezárása

PROGRAM s ; (* Egy szekvenciális file másolása *) TYPE rekord = ARRAY [1..5] OF REAL ; TYPE t = FILE of rekord ; VAR f,g : t ; BEGIN

RESET(f,'ADAT.DAT') ; REWRITE(g,'EREDMENY.DAT'); WHILE NOT EOF(f) DO BEGIN g^ := f^; GET(f); PUT(g); END;

END.

4.8. Textfile-ok

Speciális szekvenciális file a szövegfile. Ennek jelölésére a Pascal nyelvben külön nevet is bevezettek, ez a TEXT.

TYPE TEXT = FILE OF CHAR

Az összes "grafikus formátumú" file (pl. a a sornyomtató és a display képernyője) TEXT típusú. A TEXT típusú file karakterek sorozata, amit speciális jelek, ún. sorvŕ09ge jelek tördelnek sorokra. A TEXT típusú file-okhoz nemcsak CHAR típusú mennyiségekre vonatkozó műveletek vannak, hanem olyanok is, amelyek INTEGER és REAL mennyiségeket írnak ill. olvasnak. A file-ban természetesen karakteres (decimális) formában vannak az INTEGER és REAL mennyiségek is. Legyen a továbbiakban

VAR f : TEXT ;

4.8.1. Szekvenciális input TEXT-file-okra vonatkozó műveletek

• RESET(f,fn)

• tab a file megnyitása

• READ(f,x)

• tab a lorem művelet olvasás a file-ból ha x:CHAR, akkor leválasztja f-ből a következő karaktert; ha x:INTEGER, vagy x:REAL, akkor (átlépve előbb a szóközöket és sorvége jeleket) leválasztja f -ből az első számot, amit szóköz, vessző, vagy sorvége zár le; ha x:ARRAY [1..n] OF CHAR, akkor (átlépve előbb a szóközöket és sorvége jeleket) leválasztja az első szóközzel, vesszővel vagy sorvégével befejeződő karakterláncot, a vektorban balra ütközteti (ha rövidebb a vektornál, akkor kiegészíti szóközökkel, ha hosszabb, akkor az utolsó n jelre csonkítja)

• READLN(f) átlépi az input file karaktereit a következő sorvége jellel bezárólag

• EOLN(f) logikai függvény, aminek értéke igaz, ha a sorban már nem maradt más beolvasatlan

karakter, csak a sorvége jel; különben hamis. • EOF(f) logikai függvény, ami pontosan akkor igaz, ha a file már "üres", azaz a READ-del

az utolsó elemét (az utolsó sorvége jelet) is leválasztottuk.


- 16 -

4.8.2. Szekvenciális output TEXT-file-okra vonatkozó műveletek

• REWRITE(f,fn) _fcres file létrehozása

• WRITE(f,x) a hiext művelet - írás a file-ba ha x:CHAR, akkor kiegészíti f -et az x karakterrel; ha x:INTEGER, akkor WRITE(f,x:m) legalább m pozíción jobbra tömörítve helyezi el a számot (x:REAL esetén ennek formája WRITE(f,x:m:t) , ahol t a kiírt tizedesjegyek száma) ha x:ARRAY [1..n] OF CHAR, akkor a vektor n karakterét hozzáfűzi f-hez

• WRITELN(f) egy sorvége jellel egészíti ki a file-t

• PAGE(f) (csak sornyomtató esetén) a következő lap tetejére áll

• CLOSE(f) a file lezárása

PROGRAM s ; (* Text-file másolása *) VAR f,g : TEXT ; VAR c : CHAR ; BEGIN

RESET(f,'ADATOK.DAT') ; REWRITE(g,'X.DAT'); WHILE NOT EOF(f) DO

BEGIN WHILE NOT EOLN(f) DO BEGIN READ(f,c); WRITE(g,c); END;

READLN(f) ; WRITELN(g);END; END .

A READ(f,x1,x2,...,xn) program ekvivalens a BEGIN READ(f,x1); READ(f,x2); ... ; READ(f,xn); END. programmal. A WRITE(f,x1,x2,...,xn) program ekvivalens a BEGIN WRITE(f,x1); WRITE(f,x2); ...;WRITE(f,xn); END. programmal. Ha a file-változót elhagyjuk azt úgy értjük, hogy az átvitel a terminálra vonatkozik. A terminál egyszerre input és output TEXT-file.


- 17 -

Gyakorlatok 5. Állapítsuk meg, milyen értékeket ír ki a következő programrészlet !

a) VAR i,f : INTEGER ; BEGIN

f := 0 ; FOR i := 2 TO 4 DO f := f + 2*i ; WRITELN('f = ',f:8)

END; b)

VAR n,m : INTEGER ; BEGIN

n:=2 ; m:=1 ; WHILE n <= 5 DO

BEGIN m := n*m ; n := n+1

END ; WRITELN('m = ',m:6)

END;

c) VAR a,x,y : INTEGER ; BEGIN

x := 7; y := 4; WHILE x > y DO

BEGIN a := a + x-y ; x := x-1 ; y := y+1

END ; WRITELN('a = ',a:6)

END;

d) VAR i : INTEGER ;

h,x : REAL ; y : REAL ;

BEGIN WRITELN('x ? '); READLN(x) ; WRITELN('h ? '); READLN(h) ; FOR i:=1 TO 12 DO

BEGIN y := x + SIN(x) ; x := x + h; WRITELN(y:8:6)

END ; END;

e) VAR a,b,z : INTEGER ; BEGIN

WRITELN('a , b ? '); READLN(a,b) (* a>=0, b>=0 *) ; z := 0; WHILE b > 0 DO

BEGIN IF ODD(b) THEN z := z+a ; a := 2*a ; b := b DIV 2

END ; WRITELN(('z = ',z)

END;

f) TYPE rekord = RECORD

kulcs : INTEGER ; t1 : BOOLEAN ; t2 : INTEGER ; t3 : ARRAY CHAR OF CHAR ;

END ; adat = FILE OF rekord ;

VAR f,g : adat ; x : rekord ; n : INTEGER ;

BEGIN RESET(f,'INPUTFILE.DAT') ; REWRITE(g,'OUTFILE.DAT') ; n := 0 ; WHILE NOT EOF(f) DO

BEGIN x := f^; GET(f) ; IF (x.kulcs >= 100) AND (x.kulcs <= 200) THEN

BEGIN n := n+1 ; x.t2 := n ; g^ := x; PUT(g) END; END;

CLOSE(f); CLOSE(g) END;


- 18 -

5. Eljárások, függvények

A Pascal program tagolásának eszköze az eljárás és a függvény. Ezek a nyelv alprogramjai. Egy alprogram “csakúgy mint maga a program” azonosítóból, az argumentumokat leíró ún. specifikációs részből, lokális definíciókból, és az alprogram utasításrészéből áll. Az alprogramok önmagukat is aktivizálhatják (vagyis rekurzív programot is írhatunk).

A Pascal program az általa felhasznált operatív memóriát három részre osztja. Az egyik a statikus (állandó című és méretű) memória, amiben a program legkülső blokkjában definiált változók foglalnak helyet.

A verem memóriarészbe kerülnek az aktivizált alprogramok lokális változói. A dinamikus memóriaterületet használja a Pascal program a NEW és DISPOSE műveletekkel kezelhető változók elhelyezésére.

PROCEDURE eljárásnév ( argumentumok ) ;

lokális deklarációk BEGIN az eljárás utasításrésze END ;

(Az argumentumokat a Pascal terminológiában formális paraméternek szokás hívni.) A paramétereket “változónév:típus” formában írjuk és pontosvesszővel választjuk el. Amely paraméterek elé a paraméterlistában kiírjuk a "VAR" szót, azok átvétele cím szerint, a többié érték szerint történik.

CONST n=10 ; TYPE vektor = ARRAY [1..n] OF INTEGER ; (* A vektor legnagyobb eleme indexének

meghatározása *) PROCEDURE maximum (x:vektor; VAR k:INTEGER) ; VAR i:INTEGER; BEGIN

k:=1 ; FOR i:=1 TO n DO

IF x[i] > x[k] THEN k:=i END ;

(Itt az "n" konstans és a "vektor" típus globális adatok, az "x" és "k" formális paraméterek.)

A függvények abban különböznek az eljárásoktól, hogy a specifikációs részben a függvényértéknek a típusát is meg kell adni, és a függvény utasításrészében egy értékadással ki kell jelölni a függvény értékét.

FUNCTION függvényvnév ( argumentumok ) : fvtípus

deklaráció BEGIN a függvény utasításrésze függvénynév := függvényérték END ;


- 19 -

Gyakorlatok

6. Fogalmazzuk meg, milyen feladatot old meg az alábbi programrészlet!

a) FUNCTION m (a,b:INTEGER) : INTEGER ;

BEGIN IF k*a > k*b THEN m := a ELSE m := b

END;

b) TYPE vektor = ARRAY [1..n] OF INTEGER;

FUNCTION m(f:vektor):INTEGER; FUNCTION mm(l,r:INTEGER):INTEGER; VAR k,m1,m2:INTEGER; BEGIN

IF r-l < 2 THEN BEGIN

IF f[l] < f[r] THEN mm := f[r] ELSE mm := f[l] END;

ELSE BEGIN

h := (l+r) DIV 2; m1 := mm(l.h); m2 := mm(h+1,r); IF m1 > m2 THEN mm := m1 ELSE mm := m2

END; END;

BEGIN m := mm(1,n)

END;

7. Állapítsuk meg, milyen értéket ír ki az alábbi programrészlet!

a) VAR x,z : REAL ; PROCEDURE t1(VAR b:REAL; a:REAL; FUNCTION c) ;

BEGIN b := a*a ; b := c(b) END ; FUNCTION s1(x:REAL):REAL ;

BEGIN s1 := x * x * x; END ; FUNCTION c1(x:REAL):REAL ;

BEGIN c1 := 4.0 * x; END ; BEGIN

x := 2.0 ; t1(z,x,c1); WRITELN('z = ',z:10:2) ; t1(z,x,s1); WRITELN('z = ',z:10:2);

END . b)

VAR x,y,t,h : REAL ; i : INTEGER ;

PROCEDURE int(VAR y:REAL; t,h:REAL; FUNCTION f(x:REAL):REAL); VAR y1,y2 : REAL ; BEGIN

y1 := f(t) ; y2 := f(t+h) ; y := (y1+y2) * h / 2.0 END ;

FUNCTION fv(x:REAL) : REAL ; BEGIN fv := 2.0 * x + 3.0 END ;

BEGIN y := 0.0 ; t := 0.5 ; h := 0.1 ; FOR i := 1 TO 10 DO

BEGIN int(x,t+FLOAT(i-1)*h,h,fv) ; y := y + x END ; WRITELN('y = ',y:8:4)

END . c)

TYPE matrix = ARRAY [1..3,1..3] OF INTEGER ; VAR i,j : INTEGER ;

a : matrix ; FUNCTION d(a:matrix) : INTEGER ;

VAR i : INTEGER ; BEGIN

d := 0 ; FOR i:=1 TO 3 DO

d := d + a[i,i] END ;

BEGIN FOR i:=1 TO 3 DO

FOR j:=1 TO 3 DO a[i,j] := i+j ;

WRITELN('Az osszeg= ',d(a):6) END .


- 20 -

d) CONST n = 10 ; TYPE vektor = ARRAY [1..n] OF REAL ; VAR i : INTEGER ;

s : REAL ; b : vektor ;

PROCEDURE sum(x:vektor; VAR c:REAL); VAR i : INTEGER ; BEGIN

c := 0.0 ; FOR i := 1 TO n DO c := c + x[i] ;

END ; BEGIN

b[1] := 1.0; FOR i := 2 TO n DO b[i] := b[i-1] + 2 ; sum(b,s) ; WRITELN('s = ',s:10:4)

END;


- 21 -

6. Feladatok

1. Adottak az a[N], b[N], c[N] vektorok, amelyek egész számokat tartalmaznak. Nyomtassuk ki a számhármasokat külön sorba x.y.z. alakban úgy, hogy a szöveg a 40. pozíción érjen véget (a számok között ne legyenek szóközök)!

2. Adott egy szövegfile, amelynek a sorai nem haladják meg a 80 karaktert. Másoljuk át a file-t úgy, hogy a szavak közé szóközöket beszúrva minden sort kiegészítünk 80 hosszúságúra!

3. Másoljunk át úgy egy szintaktikusan helyes Pascal programot, hogy a kommenteket közben kihagyjuk belőle!

4. Gyűjtsük ki egy szintaktikusan helyes Pascal programból a szövegkonstansokat!

5. Határozzuk meg, hogy egy bizonyos szó a Pascal forrásprogram mely soraiban fordul elő!

6. Számoljuk meg egy szintaktikusan helyes Pascal programban, hogy melyik alapszó hányszor szerepel!

7. Gyűjtsük ki egy szintaktikusan helyes Pascal programból a benne definiált eljárások és függvények neveit!

8. Egy szintaktikusan helyes Pascal programban az alapszavak betűit változtassuk nagybetűkre, a kommentek és szövegkonstansok betűit ne változtassuk, a többi betűt cseréljük kisbetűre!

Documents

Kozics Sándor A Pascal programozási nyelvjoceee.web.elte.hu/vegyesz/elte_tananyag/pascal4.pdf · Kozics Sándor: A Pascal programozási nyelv - 4 - 2. Elemi nyelvi egységek A Pascal