Programozás-elmélet Oktatási segédlet

Programozás-elmélet Oktatási segédlet Összeállította: Kovács László

Programozás-elmélet  K.L.

2

Tartalomjegyzék

A számítógépes feladatmegoldás lépései..................................................................................................................3 A feladat meghatározása...........................................................................................................................................3 Adatszerkezetek .......................................................................................................................................................4 Algoritmuskészítés ...................................................................................................................................................7 Programozási tételek ................................................................................................................................................9 Rekurzió .................................................................................................................................................................20 Fájlkezelés..............................................................................................................................................................24 Programozási nyelvek osztályozása .......................................................................................................................27 Programkészítési elvek...........................................................................................................................................30 Programhelyességvizsgálat.....................................................................................................................................31 Hibakeresés és -javítás ...........................................................................................................................................32 Hatékonyságvizsgálat.............................................................................................................................................34 Dokumentálás.........................................................................................................................................................36 Összetett adatszerkezetek megvalósítása................................................................................................................37 Statikus verem és műveletei ...................................................................................................................................40 Dinamikus verem és műveletei...............................................................................................................................41 Statikus sor és műveletei ........................................................................................................................................42 Dinamikus sor és műveletei....................................................................................................................................43 Statikus lista és műveletei.......................................................................................................................................44 Dinamikus lista és műveletei ..................................................................................................................................47 Bináris fa ................................................................................................................................................................50 Gráf ........................................................................................................................................................................56 Objektumorientált programozás .............................................................................................................................58


3

Programozás A számítógépes feladatmegoldás lépései 1. A feladat meghatározása 2. Algoritmuskészítés 3. Kódolás: programkészítés (a szg. számára érthető algoritmus írása, fordítása) 4. Tesztelés, hibakeresés, javítás 5. Hatékonyságvizsgálat 6. Dokumentálás

A feladat meghatározása Elemei: 1. Bemenet -kiindulási adatok (megnevezés, típusmeghatározás) -bemenő paraméterek -felhasználható függvények, eljárások 2. Kimenet -előállítandó adatok (megnevezés, típusmeghatározás) 3. Előfeltétel -az algoritmus elkészítése során figyelembe vehető illetve veendő kiindulási körülmények -a bemenetekre vonatkozó előírások illetve megkötések 4. Utófeltétel -az algoritmussal szemben támasztott követelmények -a lefutás után a kimenetek értékére vonatkozó meghatározások, elvárások 1. példa: gyökvonás

2. példa: másodfokú egyenlet megoldása

Be:

X ∈ R

Be:

a,b,c ∈ R

Ki:

Y12 ∈ R

Ki:

x12 ∈ R

Ef:

X >= 0

Ef:

a <> 0

Uf:

Y12 = ± X

Uf:

x12 =

és

b2-4ac >= 0

− b ± b2 − 4ac 2a


4

Adatszerkezetek I., Elemi típusok Egy változónév alatt egyetlen adat tárolható el. 1. Megszámlálható típusosztály: a., egészek: Típus byte word shortint integer longint

Méret 1B 2B 1B 2B 4B

Ábrázolás:

kettes komplemens kódban

Műveletei:

+, −, ∗, DIV, MOD, INC, DEC; SHL, SHR, AND, OR, XOR.

b., karakteres:

Előjel előjel nélküli előjel nélküli előjeles előjeles előjeles

char

Tartomány 0..255 0..65535 -128..+127 -32768..+32767 ± 2 milliárd

1B

Ábrázolás:

ASCII kódtábla alapján: 0 .. 31 vezérlő karakterek 32 .. 127 alapkarakterek 128 .. 255 kiegészítő karakterek (kódlap-függő)

Műveletei:

chr(65), ord('A').

c., logikai: Műveletei:

boolean / logical

1B

{false..true}

NOT; AND, OR, XOR, EQU, NAND, NOR, implikáció.

Hasonlító operátorok:

=, >, <, <>, >=, <=, IN.


2. Valós típusosztály:

5

real single double extended comp

5+1 B 3+1 B 6+2 B 7+3 B

Ábrázolás:

lebegőpontos számként: mantissza+karakterisztika

Műveletei:

minden matematikai művelet és függvény - pl: abs(), int(), random() - pascalban nincs hatványozás, de ab = exp(b*ln(a))

II., Összetett típusok Egy változónév alatt több adat is eltárolható. 1. Karaktersorozat: string Műveletei:

s = 'Szövegkonstans' Hossz (s) = n RészSztring (s,n,n) = sz Pozíció (s1,s2) = n Konkateráció(s1,s2) = s12

2. Tömb:

array (azonos típusú elemek; hivatkozás sorszámmal)

3. Rekord:

record (különböző típusú elemek; hivatkozás mezőnévvel)


6

III. Definiált típusok 1. Táblázat: rekordok tömbje tipus táblázat = tömbje[1..100] Rekord-nak mez ő1: tipus1 mez ő2: tipus2 mez ő3: tipus3 Reko rd vége

2. Részintervallum: valamilyen megszámlálható típus résztartománya 3. Halmaz: elemek csoportja, ahol - nincsenek azonos elemek - elemek sorrendje nem értelmezhető 4. Felsorolás 5. Verem: Last In First Out (LIFO) 6. Sor: First In First Out (FIFO) 7. Lista 8. Gráf: pontok és élek halmaza, ahol az élek ponttól pontig tartanak. 9. Fa: körmentes, irányított, összefüggő gráf; minden pontja max. 1 bemenő és tetszőleges számú kimenő éllel. Bináris fa: minden pontja max. 1 bemenő és max. 2 kimenő éllel.

IV. Mutató típus: pointer V. Konstansok: const 1. Definiált konstans 2. Tipizált konstans


7

Algoritmuskészítés Algoritmus: utasítássorozat, mely megadja egy feladat megoldásmenetének pontos leírását - véges sok utasítást tartalmaz - nem feltétlenül véges végrehajtási idejű - megfelelő sorrendű (szemantikailag helyes) - utasításonként megfelelően paraméterezett (szintaktikailag helyes) Strukturált algoritmus elemei: a., szekvencia (soros algoritmus, blokk) b., szelekció (elágazás) - feltételes - többirányú c., iteráció (ciklus, ismétlés) - elöltesztelő - hátultesztelő - számláló d., procedura (eljárás, szubrutin) e., függvény Ugró utasítások nem elemei a strukturált algoritmusnak! Programozás alaptétele:

minden algoritmus megvalósítható strukturáltan. (Böhm-Jacopini - tétel)

Algoritmusleíró eszközök Rajzos: látványos, de nehezen szerkeszthető 1., folyamatábra (blokkdiagram) 2., struktogram 3., Jackson-ábra Szöveges: nem annyira látványos, de könnyen szerkeszthető 1., mondatokkal történő leírás nem egyértelmű, nem specifikus 2., programnyelven történő leírás nem mindenki számára érthető 3., mondatszerű leírás (pszeudokód, leírónyelv) előnyök ötvözése: anyanyelvű, specifikus


8

Példák: 1., Számrendszerváltás

Be: Ki: Ef: Uf:

Szam1 ∈ karaktersorozat SzR1, SzR2 ∈ [2..36] Szam2 ∈ karaktersorozat SzJ=‘0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ’ Szam2: az SzR1 számrendszerbeli Szam1 SzR2-ben

H:=1 : Tizes:=0 Ciklus i:=Hossz(Szam1)-től 1-ig -1-esével Tizes:=Tizes+(Pozició(Szam1[i],SzJ)-1)*H H:=H*SzR1 Ciklus vége Szam2:=’’ Ciklus amig Tizes>0 Szam2:=SzJ[Tizes mod SzR2]+Szam2 Tizes:=Tizes div SzR2 Ciklus vége

2., Fix idejű programvárakoztatás (max. késleltetés: 23 óra) Eljárás Várj(mp: valós) vált t: Rekord óra,perc,mp,mp100: egész Rekord vége p,v: valós RendszerIdő?(t.óra,t.perc,t.mp,t.mp100) p:= 3600.0*t.óra + 60*t.perc + t.mp + t.mp100/100 v:= p+mp Ha v >= 86400 akkor Ciklus RendszerIdő?(t.óra,t.perc,t.mp,t.mp100) Mígnem t.óra = 0 Ciklus vége v:= v-86400 Elágazás vége Ciklus RendszerIdő?(t.óra,t.perc,t.mp,t.mp100) p:= 3600.0*t.óra + 60*t.perc + t.mp + t.mp100/100 Mígnem p >= v Ciklus vége Eljárás vége


9

Programozási tételek 1., Sorozatszámítás Be:

X(N) f F0

-

X nevű, N elemű tömb függvény kezdőérték

Ki:

Y

-

érték

Ef:

--

Uf:

Y=f(F0,X)

Eljárás Sorozatszámítás Y:=F0 Ciklus i:=1-től N-ig Y:=f(Y,X(i)) Ciklus vége Eljárás vége Kapcsolódó feladat: - összegzés, átlagszámítás - számrendszerváltás tizes számrendszerbe - egészkitevős hatványozás (12.11.) - faktoriális

2., Megszámlálás Be:

X(N) T

-

X nevű, N elemű tömb tulajdonság

Ki:

DB ∈ N

-

darabszám

Ef:

--

Uf:

DB :

0<=DB<=N,

X-beli T tulajdonságú elemek száma

Eljárás Megszámlálás DB:=0 Ciklus i:=1-től N-ig Ha T(X(i)), akkor DB:=DB+1 Ciklus vége Eljárás vége Kapcsolódó feladat: - megszámlálás átlagszámításhoz - szöveg szótagszámának meghatározása - kockadobások: egyes, hatos, stb. dobások száma (8.1.29.d., e., f.) - a π értékének közelítése geometriai valószínűség alapján (10.50.)


10

3., Maximumkiválasztás Be:

X(N)

-

X nevű, N elemű tömb

Ki:

MAX ∈ N

-

sorszám

Ef:

--

Uf:

MAX :

1<=MAX<=N,

X(MAX)>=X(i)

minden 1<=i<=N esetén

Eljárás Maximumkiválasztás MAX:=1 Ciklus i:=2-től N-ig Ha X(i)>X(MAX), akkor MAX:=i Ciklus vége Eljárás vége Kapcsolódó feladat: - minimumkiválasztás - kockadobások: legtöbbször előforduló szám (8.1.29.g.) - egy szöveg leghosszabb szavának hossza

4., Eldöntés Be:

X(N) T

-


Ki:

VAN ∈ L

-

logikai érték

Ef:

--

Uf:

VAN=igaz, ha létezik olyan 1<=i<=N, melyre T(X(i)), VAN=hamis egyébként.

Eljárás Eldöntés i:=1 Ciklus amíg i<=N és nem T(X(i)) i:=i+1 Ciklus vége VAN:=(i<=N) Eljárás vége Kapcsolódó feladat: - prímszámvizsgálat (8.1.6.) - vizsgálódás mátrixokban (8.2.4., 8.2.8., 8.2.11.)


11

5., Keresés Be:

X(N) T

-


Ki:

VAN ∈ L Ha VAN, akkor

Ef:

--

Uf:

VAN=igaz, ha létezik olyan 1<=i<=N, melyre T(X(i)), VAN=hamis egyébként. Ha VAN, akkor S : 1<=S<=N és T(X(S))

S ∈ N

-

logikai változó sorszám

Eljárás Keresés i:=1 Ciklus amíg i<=N és nem T(X(i)) i:=i+1 Ciklus vége VAN:=(i<=N) Ha VAN, akkor S:=i Eljárás vége Kapcsolódó feladat: - keresés szótárban (rekordokat tartalmazó tömbben)

6., Kiválasztás Be:

X(N) T

-


Ki:

S ∈ N

-

sorszám

Ef:

Létezik olyan 1<=i<=N, melyre T(X(i))

Uf:

S :

1<=S<=N

és

T(X(S))

Eljárás Kiválasztás i:=1 Ciklus amíg nem T(X(i)) i:=i+1 Ciklus vége S:=i Eljárás vége Kapcsolódó feladat: - legnagyobb közös osztó és legkisebb közös többszörös meghatározása (8.1.9., 8.1.10.)


12

7., Másolás Be:

X(N) f

-

X nevű, N elemű tömb függvény

Ki:

Y(N)

-

Y nevű, N elemű tömb

Ef:

--

Uf:

Y(N) :

Y(i)=f(X(i))

minden 1<=i<=N esetén

Eljárás Másolás Ciklus i:=1-től N-ig Y(i):=f(X(i)) Ciklus vége Eljárás vége Kapcsolódó feladat: - függvénytáblázatok készítése - ASCII kódtábla megjelenítése (10.51.) - szöveg megfordítása ill. eszperente nyelvre „fordítása” (10.52., 10.53.)

8., Kiválogatás Be:

X(N) T

-


Ki:

DB ∈ N Y(DB):

-

darabszám Y nevű, DB elemű tömb

Ef:

--

Uf:

DB : Y(DB):

0<=DB<=N, X-beli T tulajdonságú elemek száma minden 1<=i<=DB esetén T(X(Y(i)))

Eljárás Kiválogatás DB:=0 Ciklus i:=1-től N-ig Ha T(X(i)), akkor DB:=DB+1 : Y(DB):=X(i) Ciklus vége Eljárás vége Kapcsolódó feladat: - szám összes osztójának meghatározása - Armstrong-számok keresése (10.22.)


9., Szétválogatás a., Szétválogatás két tömbbe Be:

X(N) T

-


Ki:

DB ∈ N Y(DB) Z(N-DB):

-

darabszám Y nevű, DB elemű tömb Z nevű, N-DB elemű tömb

Ef:

--

Uf:

DB : Y(DB) : Z(N-DB) :

0<=DB<=N, X-beli T tulajdonságú elemek száma minden 1<=i<=DB esetén T(Y(i)) minden 1<=i<=N-DB esetén nemT(Z(i))

Eljárás Szétválogatás_két_tömbbe DB:=0 : DBZ:=0 Ciklus i:=1-től N-ig Ha T(X(i)), akkor DB :=DB +1 : Y(DB) :=X(i) különben DBZ:=DBZ+1 : Z(DBZ):=X(i) Ciklus vége Eljárás vége

b., Szétválogatás egy tömbbe Be:

X(N) T

-


Ki:

DB ∈ N Y(N)

-

darabszám Y nevű, N elemű tömb

Ef:

--

Uf:

DB : Y(N) :

0<=DB<=N, X-beli T tulajdonságú elemek száma minden 1<=i<=DB esetén T(Y(i)) és minden DB+1<=i<=N esetén nemT(Y(i))

Eljárás Szétválogatás_egy_tömbbe DB:=0 : DBZ:=0 Ciklus i:=1-től N-ig Ha T(X(i)), akkor DB :=DB +1 : Y(DB):=X(i) különben DBZ:=DBZ+1 : Y(N+1-DBZ):=X(i) Ciklus vége Eljárás vége

13


14

c., Szétválogatás helyben Be:

X(N) T

-


Ki:

DB ∈ N X(N)

-

darabszám X nevű, N elemű tömb

Ef:

--

Uf:

DB : X(N) :

0<=DB<=N, X-beli T tulajdonságú elemek száma minden 1<=i<=DB esetén T(X(i)) és minden DB+1<=i<=N esetén nemT(X(i))

Eljárás Szétválogatás_helyben Y:=X(1) : E:=1 : U:=N Ciklus amíg E

10., Metszet Be:

X(N) Y(M)

-

X nevű, N elemű tömb Y nevű, M elemű tömb

Ki:

DB ∈ N Z(DB)

-

darabszám Z nevű, DB elemű tömb

Ef:

X és Y

Uf:

DB : Z(DB) :

halmazok 0<=DB<=min(N,M), X∩Y halmaz elemeinek száma minden 1<=i<=DB esetén Z(i)∈X és Z(i)∈Y

Eljárás Metszet DB:=0 Ciklus i:=1-től N-ig j:=1 Ciklus amíg j<=M és X(i)<>Y(j) j:=j+1 Ciklus vége Ha j<=M akkor DB:=DB+1 : Z(DB):=X(i) Ciklus vége Eljárás vége

11., Unió Be:

X(N) Y(M)

-


Ki:

DB ∈ N Z(DB)

-

darabszám Z nevű, DB elemű tömb

Ef:

X és Y

Uf:

DB : Z(DB) :

halmazok 0<=DB<=N+M, X∪Y halmaz elemeinek száma minden 1<=i<=DB esetén Z(i)∈X vagy Z(i)∈Y

Eljárás Unió Z:=X : DB:=N Ciklus i:=1-től M-ig j:=1 Ciklus amíg j<=N és X(j)<>Y(i) j:=j+1 Ciklus vége Ha j>M akkor DB:=DB+1 : Z(DB):=Y(i) Ciklus vége Eljárás vége

15


16

12., Összefuttatás, összefésülés Be:

X(N) Y(M)

-


Ki:

Z(K)

-

Z nevű, K elemű tömb

Ef:

X és Y

elemei rendezettek

Uf:

Z(K) :

minden 1<=i<=K esetén Z(i)∈X vagy Z(i)∈Y (K a XUY halmaz elemeinek száma)

Eljárás Összefuttatás i:=1 : j:=1 : k:=0 Ciklus amíg i<=N és j<=M k:=k+1 Elágazás X(i)Y(j) esetén: Z(k):=Y(j) : j:=j+1 Elágazás vége Ciklus vége Cilkus amíg i<=N k:=k+1 : Z(k):=X(i) : i:=i+1 Ciklus vége Cilkus amíg j<=M k:=k+1 : Z(k):=Y(j) : j:=j+1 Ciklus vége Eljárás vége Eljárás Összefésülés i:=1 : j:=1 : k:=0 : X(N+1):=+∞ : Y(M+1):=+∞ Ciklus amíg i

13., Rendezés Be:

X(N)

-


Ki:

X(N)

-


Ef:

--

Ki:

X(N) :

elemek sorrendje érték szerint növekvő (rendezett)

a., Eljárás Egyszerű_cserés_rendezés Ciklus i:=1-től N-1-ig Ciklus j:=i+1-től N-ig Ha X(j)<X(i), akkor s:=X(i) : X(i):=X(j) : X(j):=s Ciklus vége Ciklus vége Eljárás vége b., Eljárás Buborékelvű_rendezés Ciklus i:=N-1-től 1-ig -1-esével Ciklus j:=1-től i-ig Ha X(j)>X(j+1), akkor s:=X(j) : X(j):=X(j+1) : X(j+1):=s Ciklus vége Ciklus vége Eljárás vége c., Eljárás Minimumkiválasztásos_rendezés Ciklus i:=1-től N-1-ig MIN:=i Ciklus j:=i+1-től N-ig Ha X(j)<X(MIN), akkor MIN:=j Ciklus vége s:=X(MIN) : X(MIN):=X(i) : X(i):=s Ciklus vége Eljárás vége d., Eljárás Beillesztéses_rendezés Ciklus i:=1-től N-1-ig Y:=X(i+1) j:=i Ciklus amíg j>0 és X(j)>Y X(j+1):=X(j) j:=j-1 Ciklus vége X(j+1):=Y Ciklus vége Eljárás vége

17


18

14., Logaritmikus keresés Be:

X(N) Y

-

X nevű, N elemű tömb érték

Ki:


Ef:

X elemeinek sorrendje érték szeint növekvő (rendezett)

Uf:

VAN=igaz, ha létezik olyan 1<=i<=N, melyre Y=X(i), VAN=hamis egyébként. Ha VAN, akkor S : 1<=S<=N és Y=X(S)

S ∈ N

-

Eljárás Logaritmikus_keresés E:=1 : U:=N Ciklus k:=[(E+U)/2] Elágazás X(k)Y esetén: U:=k-1 Elágazás vége Mígnem E>U vagy X(k)=Y Ciklus vége VAN:=(E<=U) Ha VAN, akkor S:=k Eljárás vége Kapcsolódó feladat: - 2 x = x 3 egyenlet megoldása (10.45)

logikai változó sorszám


19

15., Visszalépéses keresés (BackTrack) Be:

N db sorozat T -

M(1), M(2), ... M(N) elemszámmal tulajdonság

Ki:


Ef:

-

Uf:

VAN=igaz, ha létezik olyan S(N) sorozat, melyre T(S(N)) VAN=hamis egyébként. Ha VAN, akkor S(N) : az egyes sorozatok megfelelő elemei sorszámának tömbje

S(N) ∈ N

-

logikai változó sorszámokat tartalmazó sorozat

Eljárás Visszalépéses_keresés i:=1 : S(1):=0 Ciklus amig i>=1 és i<=N Ha VanJóElem(i) akkor i:=i+1: S(i):=0 kül. i:=i-1 Ciklus vége VAN:=(i>N) Eljárás vége Függvény VanJóElem(i:szám):logikai Ciklus S(i):=S(i)+1 Mignem s(i)>M(i) vagy ElemRendben(i,S(i)) Ciklus vége VanJóElem:=(S(i)<=M(i)) Függvény vége Függvény ElemRendben(i,S(i)):logikai j:=1 Ciklus amig j
másként: (i,S(i)) nem zája ki (j,S(j))-t pl: Sakktábla királynői esetén S(i)<>S(j) és |i-j|<>|S(i)-S(j)|


20

Rekurzió Matematikai művelet: 1  Fakt(n)=   n ⋅ Fakt(n − 1)

ha n ≤ 1 ha n > 1

Algoritmusban: - specifikáció önmagára visszautal - eljárás saját magát is meghívhatja

Programozási nyelvben: - rekurziv a nyelv, ha megengedi a változók sokszorozódását - rekurziv: Pascal, Logo - nem rekurziv: Basic

Példák: 1., Faktoriális számítása Függvény Fakt(n):szám Ha n<=1 akkor Fakt:=1 kül. Fakt:=n∗Fakt(n-1) Függvény vége Végrehajtás: Fakt(3) Ha 3≤1 kül. Fakt:=3∗Fakt(3-1) Fakt(2) Ha 2≤1 kül. Fakt:=2∗Fakt(2-1) Fakt(1) Ha 1≤2 akkor Fakt:=1 Függvény vége Függvény vége Függvény vége


21

2., Fibonacci sorozat  Fib(n)=  

1 Fib(n-1)+Fib(n-2)

ha ha

n = 0 vagy n =1 n >1

Függvény Fib(n):szám Ha n<=1 akkor Fib:=1 kül. Fib:=Fib(n-1)+Fib(n-2) Függvény vége

3., Rendezés: QuickSort Eljárás QuickSort(E,U) SzétválogatásHelyben(E,U, vált K) Ha K-E>1 akkor QuickSort(E,K-1) Ha U-K>1 akkor QuickSort(K+1,U) Eljárás vége

4., Grafika: Területfestés Eljárás Festés(X,Y) PontRajz(X,Y) Ha nem Festett(X-1,Y) Ha nem Festett(X,Y-1) Ha nem Festett(X+1,Y) Ha nem Festett(X,Y+1) Eljárás vége

akkor akkor akkor akkor

Festés(X-1,Y) Festés(X,Y-1) Festés(X+1,Y) Festés(X,Y+1)

5., Játék: Hanoi tornyai Eljárás Hanoi(N, vált A, vált B, vált C) Ha N=1 akkor A→B kül. Hanoi(N-1,A,C,B) A→B Hanoi(N-1,C,B,A) Elágazás vége Eljárás vége


22

6., Fa adatszerkezet

7., Rajz: Fraktálok Fraktál:

minden olyan görbe vagy felszín, amely a felbontástól függetlenül többé-kevésbé ugyanúgy néz ki

- tulajdonságai: - önhasonlóság: a görbe bármely részét felnagyítva az eredetivel azonos görbét kapunk - törtdimenzió: "Hány dimenziós a fa lombja?" - a szó eredete:

Berniot B. Mandelbrot (Amerikában élő, lengyel szárm.) 1975: fraktus (latin: törött)

Fraktálok a természetben: a., - hópelyhek - jégvirág az ablakon - felhők - villámlás - hullámok - hegyek - partvonal

- kristályok - fa - penész - korall - tüdő - idegsejt - műanyaghab

b., - mechanikai feszültség síküvegben => törés - eltépett papír határfelülete Fraktálkutatás területei: a., káoszelmélet: meteorológia, orvostudomány b., törésmechanika c., nagy felületek kialakításának igénye - hűtőfelületek - hangszigetelők - katalizátorok autók kipufogógázaihoz Fraktálok a művészetben: - festészet - számítógépes grafika - zene Linkajánlat: - fraktal.lap.hu


23

Nevezetes fraktálok: a., Koch-görbe Eljárás Koch irány:=0 Pozició1(0,0) KochRajz(4,270) Eljárás vége Eljárás KochRajz(szint, hossz: egész) Ha szint=0 akkor x:=hossz∗cos(irány) y:=hossz∗sin(irány) VonalAktuálisPontból2(x,y) különben KochRajz(szint-1,hossz/3) irány:=irány+60 KochRajz(szint-1,hossz/3) irány:=irány-120 KochRajz(szint-1,hossz/3) irány:=irány+60 KochRajz(szint-1,hossz/3) Elágazás vége Eljárás vége b., Sierpinski-csipke

c., Cantor-halmaz

1 2

Pascalban: MoveTo Pascalban: LineRel


24

Fájlkezelés Fájltípusok hozzáférés szerint: a., Szekvenciális:

-soros hozzáférés -pl.: szöveges fájl

b., Direkt

-közvetlen hozzáférés -pl.: típusos és típus nélküli fájlok

Használat: 1. Logikai fájlváltozó deklarálása → text → file of ... → file

-szöveges fájl -típusos fájl -típus nélküli fájl 2. Hozzárendelés(fájlváltozó,fájlnév)

→ assign

3. Megnyitás(fájlváltozó) 4. Fájlműveletek → close

5. Bezárás(fájlváltozó) Fájl megnyitása: -létrehozással -csak olvasásra -hozzáfűzésre -módosításra

→ rewrite → reset → append → reset

Fájlműveletek: -sor olvasása -sor írása -adat olvasása -adat írása -blokk olvasása -blokk írása -sorvége? -fájlvége? -hibakód? -fájlméret? -fájlpozíció? -pozícionálás -fájlcsonkítás

szöveges

típusos

típus nélküli

ü ü ü

ü

ü

ü

ü

típusos

típus nélküli

szöveges → readln → writeln → read → write → blockread → blockwrite → seekeol,eoln → seekeof → eof → ioresult → filesize → filepos → seek → truncate

ü ü ü

ü ü ü ü

ü ü ü ü

ü ü ü ü ü ü

ü ü ü ü ü ü


Példaprogramok Pascalban: a., olvasás fájlból: var f: text; s: string; begin assign(f,'c:\config.sys'); reset(f); while not eof(f) do begin readln(f,s); writeln(s); end; close(f); end.

b., írás fájlba: var f: text; i: byte; begin assign(f,'ascii.txt'); rewrite(f); for i:=32 to 255 do writeln(f,i:6,chr(i):3); close(f); end.

Kapcsolódó feladat: Irassa ki fájlba a jövő évi ünnepnapok listáját, megadva az egyes ünnepek dátumát, és hogy azok milyen napra esnek! - szükséges hozzá: procedure SetDate(Year, Month, Day: Word); procedure GetDate(var Year, Month, Day, DayOfWeek: Word);

melyek definiciója a Dos unitban található.

25


26

Rendezés: Probléma: a fájl nagyobb, mint amekkora adatmennyiség befér a memóriába. Megoldás: négysegédfájlos rendezés összefuttatással. FUTAM: az az adatmennyiség, ami még befér a memóriába. Eredeti fájl:

1. segédfájl:

2. segédfájl:

1. futam

1. futam rendezve

2. futam rendezve

2. futam

3. futam rendezve

4. futam rendezve

3. futam

5. futam rendezve

6. futam rendezve

4. futam

⇒

5. futam

7. futam rendezve

8. futam rendezve

9. futam rendezve

10. futam rendezve

6. futam

Ezek után futamok összefuttatása: 3. segédfájl:

4. segédfájl:

1-2. futam rendezve

3-4. futam rendezve

5-6. futam rendezve

7-8. futam rendezve

9-10. futam rendezve

1. segédfájl:

1-4. futam rendezve

9-12. futam rendezve

Végül előáll a rendezett fájl.

2. segédfájl:

5-8. futam rendezve


27

Programozási nyelvek osztályozása I. Felhasználó szerinti csoportosítás b., professzionális nyelv - modularitás - stabilitás - kevés nyelvi elem - összetett programszerkezet - gépfüggetlenség

a., amatőr nyelv - párbeszédesség - gyors fejlődés - sok nyelvi elem - egyszerű programszerkezet - gépfüggőség

II. Emberközeliség szerinti csoportosítás a., gépi nyelv: hexadecimális kódok b., alacsonyszintű: mnemonikok c., magasszintű: összetett utasítások, függvények (pl. Pascal) Példa: numerikus billentyűzet (NumLock) kikapcsolása programmal Módosítóbillentyű információk a $0040:$0017 és a $0040:$0018 memóriacímeken. A $0040:$0017 cím bitkiosztása: 7. Insert 6. CapsLock 5. NumLock 4. ScrollLock 3. Alt keys (bármelyik) 2. Ctrl keys (bármelyik) 1. bal Shift 0. jobb Shift

A $0040:$0018 cím bitkiosztása: 7. Insert 6. CapsLock 5. NumLock 4. ScrollLock 3. Pause 2. PrintScreen 1. bal Alt 0. bal Ctrl

Kikapcsolandó a $0040:$0017 memóriacím 5. bitje. (Maszk: 11011111 = DF) - magasszintű megvalósítás: begin Mem[$40:$17] := Mem[$40:$17] AND $DF; end. - alacsonyszintű megvalósítás: mov mov mov and mov int

AX,40H ES,AX AL,ES:[17H] AL,0dfH ES:[17H],AL 20H

; Pascal/C asm betét esetén nem kell!

- gépnyelvi megvalósítás: B8 40 00

8E C0

26 A0 17 00

24 DF

26 A2 17 00

CD 20


28

III. Számítási modell (működés) szerinti csoportosítás a., Neumann-elvű nyelvek (imperatív, utasításszerkezetű) - címezhető memória - adatok kezelése: változók, értékadás, beolvasás, kiírás - program: strukturált felépítés b., automata-elvű nyelvek (pl. Logo) - állapotváltoztató működés - állapotátmenet-függvény - állapotváltoztató és -lekérdező utasítások - fix felosztású memória - nincsenek változók - bemenet: kiindulási állapot + paraméterezés - kimenet: állapotváltozás eredménye (kimeneti állapot) - párhuzamosság - elágazás, ciklus + rekurzió c., logikai nyelvek (deklaratív; pl. Prolog - Programming in logic) - program: paraméterezhető logikai formula, logikai függvény - f(x,y,z) ⇒ {igaz, hamis} - f(?,?,3) ⇒ megadja, mi lehet a ? helyén, hogy igaz legyen Példa: családfa. Definíciók: családtag(x) ha x=antal vagy x=béla vagy x=csaba vagy x=dezső vagy x=dénes vagy x=endre vagy x=erik vagy x=ernő. apja(antal,béla ). apja(béla ,csaba). apja(csaba,dezső). apja(csaba,dénes). apja(dezső,endre). apja(dénes,erik ). apja(dénes,ernő ). Szabályok: nagyapja(X,Y) ha apja(X,Z) és apja(Z,Y). őse(X,Y) ha apja(X,Y) vagy apja(X,Z) és őse(Z,Y). Kérdések: apja(antal,dezső) ⇒ hamis őse(antal,dezső) ⇒ igaz apja(_,béla) ⇒ antal nagyapja(béla,_) ⇒ dezső, dénes őse(_,endre) ⇒ dezső, csaba, béla, antal

d., funkcionális (függvényszerű) nyelvek - program: paraméterezhető függvény - nincs: memória, változó, értékadás - van: paraméter, függvényérték, függvénykompozíció - f(g(x)) - ciklus helyett rekurzió


29

IV. Alkalmazás szerinti csoportosítás a., számítások - sok számtípus, num. műveletek, jól kidolgozott tömbhasználat - csekély rekord- és fájlkezelés b., adatfeldolgozás (dBase) - adatstrukturálás széles lehetősége - formátumozás képernyőn, nyomtatón c., rendszerprogramozás (C) - hardverkihasználás - operációs rendszerrel kommunikálás d., szövegfeldolgozás - sztringkezelés, fájlkezelés e., folyamatvezérlés - párhuzamos működés - portkezelés f., szimuláció - gyors - grafikus g., oktatás (Basic, Pascal, Elan) - jól stukturált, erősen típusos - szintaktikai ellenőrzés beíráskor h., általános célú nyelvek

Programnyelv-generációk 1GL: - elemi adattípusok - beolvasás, kiírás, műveletek

'50s

2GL: - kifejezések, szintaxis - zárójelezés - összetett típusok - fájlkezelés

'60s

3GL: - stukturált programozás - programozási tételek

'70s

4GL: - moduláris programozás - objektumorientált programozás - programkódgenerátor

'80s

5GL: - párhuzamosság

'90s


30

Programkészítési elvek I. Stratégiai elvek 1. frontális: "nekiesünk", és egyszerre mindent fejlesztünk (kerülendő) 2. felülről lefelé: részekre bontással 3. alulról felfelé: nyelvi elemek → prog. tételek → rutinok → modulok

II. Taktikai elvek (a részletekre vonatkozólag) 1. párhuzamos finomítás 2. döntések elhalasztása (hátha később egyértelműsödik) 3. döntések nyilvántartása (folyamatos dokumentálás) 4. vissza az ősökhöz (strukturában felette állók módosíthatók) 5. nyílt rendszerfelépítés (program általánosítása) 6. párhuzamos ágak függetlensége 7. strukturálás (célszerű méretű rutinok használata) 8. szintenkénti teljes kifejtés (elvileg önállóan is működőképes modulok) 9. adatok elszigetelése (lokális változók használata)

III. Technológiai elvek (forráskód formai követelményei) 1. strukturák zárójelezése (begin...end) 2. bekezdések alkalmazása 3. értelmes azonosítók használata (konvencionális és beszédes változónevek) 4. sorokra tördelés értelmesen (üres sorok is) 5. kommentek alkalmazása

IV. Esztétikai elvek (felhasználó esztétikai elvárásai) 1. lapkezelés módja - felhasználóra bízott megjelenítési időtartam - célszerű mennyiségű és elhelyezésű kitöltés, látványos adatcsoportosítás - kiemelések használata (villogás kerülése) 2. menühasználat - hierarchikus, szintenként néhány menüponttal - fajtái: állandó (fix) menü, legördülő menü helyi menü - választás: aktuális jelölésével, kezdőbetűvel, vagy egérrel 3. ikonok alkalmazása 4. funkcióbillentyűk és forróbillentyűk használata 5. következetesség 6. hibakezelés - jelzés azonnal (indoklással) - hangjelzés kerülendő 7. help biztosítása 8. naplózás (fájlba írható: ki, mikor, mit csinált)


31

Programhelyességvizsgálat A program helyes, ha az előfeltételek teljesülése esetén a program futtatásának eredményeként az utófeltétel teljesül. A helyességvizsgálat módszerei: 1. Tesztelés (kipróbálás jellemző adatokkal) 2. Érvényesítés (valódi kipróbálás éles környezetben) 3. Bizonyítás (ez az elvi módszer a gyakorlatban nem mindig kivitelezhető) 4. Levezetés (formális módszer, a bizonyítás ellentettje) 5. Hibakeresés és -javítás

Tesztelés I. Statikus tesztelés: szg. nélküli forráskódellenőrzés 1. szintaktikai ellenőrzés - nyelvhelyesség - paraméterezés - típusellenőrzés 2. szemantikai ellenőrzés - ellentmondások keresése - kezdőérték hiánya - felhasználatlan változók - feltételek ellenőrzése II. Dinamikus tesztelés: programfuttatás 1. fekete doboz módszer (feladatorientált teszt): nem néz bele a prg. forráskódjába - ekvivalenciaosztályok módszere - határértékvizsgálat módszere 2. fehér doboz módszer (strukturavezérelt teszt): forráskód alapján - utasításlefedés elve minden utasítás kerüljön kipróbálásra - feltétellefedés elve minden feltétel legyen igaz is és hamis is - részfeltétellefedés elve minden elemi feltételrész külön-külön legyen igaz is és hamis is 3. speciális tesztek - volumenteszt: mennyiségi teszt nagy mennyiségű adattal - stresszteszt: gyorsan érkező bemenő adatokkal - biztonsági teszt: rossz adatokkal - hatékonysági teszt: futási idő és helyfoglalás mérése


32

Hibakeresés és -javítás Hibajelenségek: - fordítási hiba: szintaktikai hiba miatt a program el sem indul példák Pascalban: a., " ; " expected " ) " expected Boolean expression expected THEN expected A kurzor előtti helyen pontosvesszőnek, csukózárójelnek, logikai kifejezésnek vagy THEN parancsnak kell szerepelnie (pl. nem lett pontosvesszővel lezárva a kurzor előtti utasítás).

b., Unknown identifier A kurzor által mutatott kifejezés nem definiált azonosító.

c., Error in statement Pl. pontosvesszővel lezárt IF utasítás után ELSE parancs, vagy eljáráson belül a BEGIN után változódefiniálás.

d., Duplicate definition Két különböző dolog ugyanolyan néven definiálva (pl. a program neve megegyezik egy eljárás vagy változó nevével).

e., Type mismatch Típushiba (pl. két különböző típusú kifejezés egy műveletben).

f., String constant exceed line Hiányzik a szövegkonstanst (string) lezáró aposztrof.

g., Constant out of range Array out of range A konstans vagy tömbindex a megengedett tartományon kivül esik.

h., Invalid for controll variable Érvénytelen FOR-ciklus változó (pl. a ciklusváltozó valós szám).

i., Invalid variable reference Érvénytelen változó hivatkozás (pl. egy függvény vagy kifejezés utasításként történő használata esetén).

j., Line too long A programsor hosszabb 127 karakternél.

k., Unexpexted end of line Hiányzik a fájl-vége (end.) utasítás.


33

- futási hiba: a program elindul, de hiba miatt megszakad példák Pascalban: a., Division by zero Nullával való osztás. (Turbo Pascal 7.0 esetén a Newdelay unit hiányára is utalhat.)

b., File not found A megadott fájl nem található.

c., File access denied A megadott fájl nem hozzáférhető (pl. mert írásvédett, vagy mert más alkalmazás használja).

d., Invalid numeric format Érvénytelen számformátum (pl. számváltozó bekérése esetén a felhasználó betűket ad meg).

e., Stack overflow error Verem túlcsordulási hiba (pl. túl sok rekurzív hívás esetén).

- nem áll le a program futása (nem lehet üzemszerűen kilépni) - nem ír ki semmit (vagy nem mindent) - rosszat ír ki Hibajavítási alapelvek: - "érdemes" gondolkodni - miért nem azt csinálja, amit várunk? - miért azt csinálja, amit kapunk? - csak akkor javítsunk, ha megvan a hiba - javítani hibát kell, és nem a tüneteit - egy hiba több hibajelenséget is okozhat: minden egyes javítás után teszteljünk újra Módszerek: 1. feltételkeresés - mire ad jó és mire rossz eredményt? ez mitől függ? 2. visszalépéses hibakeresés - hiba helyéből kell kiindulni, és onnan haladni visszafelé a jó részig Hibakeresés (debug) eszközei: 1. Kiírás 2. Lépésenkénti végrehajtás (programnyomkövetés) - meghívott eljárások végrehajtása egy lépésként (step over - F8) - meghívott eljárások végrehajtása soronként (trace into - F7) 3. Töréspont (breakpoint - Ctrl+F8) 4. Adatnyomkövetés (watch)


34

Hatékonyságvizsgálat A hatékonyvizsgálat szempontjai: - végrehajtási idő - helyfoglalás - bonyolultság (ld. pl. Hanoi, területfestés) A hatékonyság megközelítése: - globális (algoritmushatékonyság - az algoritmust vizsgálja) - lokális (kódhatékonyság - elemi utasításokat, típusokat, műveleteket vizsgálja)

Globális hatékonyság Végrehajtási idő szempontjából Ciklus ⇒ ciklus ideje = lépésszám * egyszeri végrehajtási idő I. Ciklus lépésszámának csökkentés 1. sorozat elemszámának csökkentése pl.: prímszámvizsgálat N helyett N -ig 2. sorozat részekre bontása pl.: líneáris keresés helyett logaritmikus keresés 3. sorozatok párhuzamos feldolgozása pl.: összefuttatás, unió 4. gyakoriság szerinti elrendezés - gyakoriakat előre rakjuk egy sorozatban Eljárás Keresés i:=1 Ciklus amíg i<=N és nem X(i)=Y i:=i+1 Ciklus vége VAN:=(i<=N) Ha VAN és i>1 akkor csere (X(i),X(i-1)) Eljárás vége - lemezen: leggyakoribb adatok középen, ritkábbal széleken. II. Ciklusmag végrehajtási idejének csökkentése 1. elágazástranszformálás indexeléssé pl.: 100 kockadobás esetén miből hányat dobtak? 2. feltételek egyszerűsítése, szétválasztása 3. adatok előfeldolgozása pl.: sok keresés előtt rendezés 4. adatmozgatások megszüntetése pl.: buborékelvű rendezés helyett minimumkiválasztásos


Helyfoglalás szempontjából Adatok ⇒ elemszám * elemméret Programszöveg I.a., Elemszámcsökkentés 1. sorozatok elemeinek tárolása helyett azok számítása pl.: faktoriális pl.: pixelgrafika helyett vektorgrafika 2. hézagos strukturák pl.: x 23 + 3 ⋅ x 7 + 7 ⋅ x kétdimenziós tömbben pl.: mátrixok sok 0 elem esetén pl.: tömörítési eljárások I.b., Elemméretcsökkentés 1. elemek számítása 2. elemek kódolása II. Programszöveg csökkentése (fordítókhoz is!) 1. eljárások használata 2. programozási tételek összeépítése 3. kód adattá formálása (önálló adatállományok használata)

Lokális hatékonyság Végrehajtási idő szempontjából 1. gyors műveletek használata 2. gyors típusok használata 3. függvények megszüntetése pl.: i < N helyett i ⋅ i < N pl.: sin(x)/cos(x) helyett tg(x) 4. részkifejezések külön kiszámolása 5. konstanskifejezések 1 pl.: E = mv 2 helyett E = 0. 5 ⋅ mv 2 2 6. algebrai átalakítások pl.: kiemelés Helyfoglalás szempontjából 1. kis típusok használata 2. részeredmény megszüntetése 3. elágazás- és ciklusösszevonás 4. utasításkiemelés elágazásból

35


36

Dokumentálás 1. Felhasználói dokumentáció 1.1. A program célja és leglényegesebb funkciói - speciális elnevezések, fogalmak, kifejezések 1.2. Minimális és optimális konfiguráció (HW, SW) 1.3. Használat 1.3.1. Telepítés lépései - kiindulási állományok - opciók (meghajtó és könyvtár, teljes/részleges, ...) - helyes telepítés eredményének könyvtárai, állományai 1.3.2. Indítás - feltételei - lehetőségei 1.3.3. Átfogó ismertetés - menünként, képernyőnként, opciókként 1.3.4. Menüszerkezet (menüfa) - célszerűen egy oldalon megvalósítva, forróbillentyűk feltüntetésével 1.3.5. Gyakran ismétlődő kérdések (GyIK, FAQ, frequently askes questions) 1.4. Hibalehetőségek - helytelen használatból adódó hibajelzések magyarázata és lekezelése 1.5. Információkérés - saját help - könyvek - WEB-oldalak - a program készítőjének elérhetősége (pl. e-mail címe) - tájékozódás az újabb változatról

2. Fejlesztői dokumentáció 2.1. Célkitűzés, feladatmeghatározás 2.2. Fejlesztőkörnyezet (HW, SW) 2.3. Adatszerkezet, típusok, változók 2.4. Algoritmusok 2.5. Tesztelés (tesztdokumentáció) 2.6. Fejlesztési lehetőségek 2.7. Melléklet - forráskód - irodalomjegyzék - történeti áttekintés (korábbi verziók újdonságai)

3. Reklám / Demo


Pascal példaprogram program MotorCsonakAzas; uses crt; type kepernyo=array[1..25,1..80] of record alak: char; szin: byte; end; var kep: kepernyo absolute $B800:$0000; f,cs: byte; i,j,m: byte; ch: char; utkozes: boolean; Function sok(db: byte;k:char):string; var ii: byte; sz: string; begin sz:=''; for ii:=1 to db do sz:=sz+k; sok:=sz; end; Function Part:Boolean; begin if kep[25,cs].alak=chr(219) then part:=true else part:=false; end; Procedure FolyoSzelet(f:byte); begin gotoxy(1,1); insline; write(sok(f,chr(219))+sok(20,' ')+sok(60 -f,chr(219))); end; Procedure KezdoKep; begin TextColor(2); TextBackground(1); f:=30; cs:=40; utkozes:=false; for i:=1 to 25 do FolyoSzelet(f); end; Procedure Csonak; begin ch:=' '; while KeyPressed do ch:=ReadKey; if ch=#75 then cs:=cs-1; if ch=#77 then cs:=cs+1; utkozes:=Part; gotoxy(cs,25); write('A'); gotoxy(cs,25); end; Procedure Folyo; begin repeat m:=Random(2); if (m=0) and (f>2) then f:=f-1; if (m=1) and (f<58) then f:=f+1; FolyoSzelet(f); Csonak; Delay(2000); until utkozes or (ch=#27); end; begin ClrScr; Randomize; KezdoKep; Folyo; end.

37


38

Grafikus lehetőségek Pascalban program Grafika; uses newdelay,graph; const path='c:\tp70\bgi'; var grDriver, grMode: integer; procedure Rajz; begin {Ez a grfikus utasítások helye.} end; begin grDriver := Detect; InitGraph(grDriver, grMode, path); Rajz; ReadLn; CloseGraph; end.

Grafikus utasítások: pont megjelenítése

putpixel(x,y,szin);

vonalrajzolás

line(x1,y1,x2,y2); lineto(x2,y2); linerel(x2,y2);

vonaltipusállítás

setlinestyle(stílus,minta,vastagság);

graf. kurzor beállítás

moveto(x,y); moverel(x,y);

színállítás

setcolor(szín); setbkcolor(szín);

téglalap téglalap kitöltve

rectangle(x1,y1,x2,y2); bar(x1,y1,x2,y2);

kör körív elipszis körszelet kitöltve

circle(x,y,r); arc(x,y,k_szögfok,v_szögfok,r); ellipse(x,y,k_szögfok,v_szögfok,r1,r2); pieslice(x,y,k_szögfok,v_szögfok,r);

kitöltésállítás zárt terület kitöltése

setfillstyle(minta,szín); floodfill(x,y,határszín);

szövegírás

outtext(’szöveg’); outtextxy(x,y,’szöveg’); settextstyle(betűtipus,irány,méret); settextjustify(vízszintes, függőleges);

szövegformátumállítás szövegigazítás


Összetett adatszerkezetek megvalósítása Mutatótípus használata Pascalban: dinamikus memóriakezelés program MutatoTipus_Demo; type MemCim=^LongInt; var Cim: MemCim; begin If MaxAvail>=SizeOf(LongInt) Then Begin New(Cim); WriteLn(Seg(Cim)); WriteLn(Ofs(Cim)); Dispose(Cim); End; end. program dinamikus_tomb; type

var

MemCim elem

= ^elem; = record adat: word; mut: MemCim; end; dintomb = record fej, akt: MemCim; end;

t: uj: db: x:

dintomb; MemCim; byte; word;

begin writeln; writeln('Adj meg néhány poz. egész számot (vége:0)!'); db:=0; t.fej:=nil; t.akt:=nil; repeat db:=db+1; write(db); write('. '); readln(x); if x>0 then begin new(uj); if db=1 then t.fej:=uj else t.akt^.mut:=uj; uj^.adat:=x; uj^.mut:=nil; t.akt:=uj; end; until x=0; writeln; writeln('A megadott értékek:'); t.akt:=t.fej; while t.akt<>nil do begin writeln(t.akt^.adat); t.akt:=t.akt^.mut; end; end.

39


40

Statikus verem és műveletei Konstans

MaxHossz = X

Tipus

ElemTip Index Verem

: Y : 0..MaxHossz : Rekord tető : Index adat : [1..MaxHossz] tömbje ElemTipnek hiba : logikai Vége

Eljárás Üres(vált v:verem) v.tető:=0 v.hiba:=hamis Eljárás vége Függvény Üres-e?(v:verem):logikai Üres-e?:=(v.tető=0) Függvény vége Függvény Tele-e?(v:verem):logikai Tele-e?:=(v.tető=MaxHossz) Függvény vége Függvény Hibás-e?(vált v:verem):logikai Hibás-e?:=(v.hiba) v.hiba:=hamis Függvény vége Függvény TetőElem(vált v:verem):ElemTip Ha v.tető=0 akkor v.hiba:=igaz kül. TetőElem:=v.adat[v.tető] Függvény vége Eljárás Verembe(vált v:verem; konstans e:ElemTip) Ha Tele-e?(v) akkor v.hiba:=igaz kül. v.tető:=v.tető+1 v.adat[v.tető]:=e Elágazás vége Eljárás vége Eljárás Veremből(vált v:verem; e:ElemTip) Ha Üres-e?(v) akkor v.hiba:=igaz kül. e:=v.adat[v.tető] v.tető:=v.tető-1 Elágazás vége Eljárás vége


Dinamikus verem és műveletei Tipus

ElemTip : Y MemCim : ^VElem VElem : Rekord adat : ElemTip mut : MemCim Vége Verem

: Rekord tető : MemCim hiba : logikai Vége

Eljárás Üres(vált v:verem) v.tető:=Nil v.hiba:=hamis Eljárás vége Függvény Üres-e?(v:verem):logikai Üres-e?:=(v.tető=Nil) Függvény vége Függvény Tele-e?(v:verem):logikai Tele-e?:=(MaxSzabadBlokk<ElemMéret(VElem)) Függvény vége Függvény Hibás-e?(vált v:verem):logikai Hibás-e?:=(v.hiba) v.hiba:=hamis Függvény vége Függvény TetőElem(vált v:verem):ElemTip Ha v.tető=Nil akkor v.hiba:=igaz kül. TetőElem:=v.tető^.adat Függvény vége Eljárás Verembe(vált v:verem; konstans e:ElemTip) vált uj : MemCim Ha Tele-e?(v) akkor v.hiba:=igaz kül. Lefoglal(uj) uj^.adat:=e uj^.mut:=v.tető v.tető:=uj Elágazás vége Eljárás vége Eljárás Veremből(vált v:verem; vált e:ElemTip) vált sv : MemCim Ha Üres-e?(v) akkor v.hiba:=igaz kül. e:=v.tető^.adat sv:=v.tető v.tető:=v.tető^.mut Felszabadít(sv) Elágazás vége Eljárás vége

41


42

Statikus sor és műveletei Konstans

MaxHossz = X

Tipus

ElemTip : Y Index : 0..MaxHossz Sor : Rekord adat : [1..MaxHossz] tömbje ElemTipnek első : Index hossz : Index hiba : logikai Vége

Eljárás Üres(vált s:sor) s.első:=1 s.hossz:=0 s.hiba:=hamis Eljárás vége Függvény Üres-e?(s:sor):logikai Üres-e?:=(s.hossz=0) Függvény vége Függvény Tele-e?(s:sor):logikai Tele-e?:=(s.hossz=MaxHossz) Függvény vége Függvény Hibás-e?(vált s:sor):logikai Hibás-e?:=s.hiba s.hiba:=hamis Függvény vége Függvény ElsőElem(vált s:sor):ElemTip Ha Üres-e?(s) akkor s.hiba:=igaz kül. Első:=s.adat[s.első] Függvény vége Eljárás Sorból(vált s:sor; e:ElemTip) Ha Üres-e?(s) akkor s.hiba:=igaz kül. e:=s.adat[s.első] s.első:=(s.első mod MaxHossz)+1 s.hossz:=s.hossz-1 Elágazás vége Eljárás vége Eljárás Sorba(vált s:sor; konstans e:ElemTip) vált új:Index Ha Tele-e?(s) akkor s.hiba:=igaz kül. új:=első+hossz Ha új>MaxHossz akkor új:=új-MaxHossz s.adat[új]:=e s.hossz:=s.hossz+1 Elágazás vége Eljárás vége


43

Dinamikus sor és műveletei Tipus

ElemTip : Y MemCim : ^SElem SElem : Rekord adat : ElemTip mut : MemCim Vége Sor

{következőre mutat}

: Rekord első : MemCim utolsó : MemCim hiba : logikai Vége

Eljárás Üres(vált s:sor) s.első:=Nil s.utolsó:=Nil s.hiba:=hamis Eljárás vége Függvény Üres-e?(s:sor):logikai Üres-e?:=(s.első=Nil) Függvény vége Függvény Tele-e?(s:sor):logikai Tele-e?:=(MaxSzabadBlokk<ElemMéret(SElem)) Függvény vége Függvény Hibás-e?(vált s:sor):logikai Hibás-e?:=s.hiba s.hiba:=hamis Függvény vége Függvény ElsőElem(vált s:sor):ElemTip Ha Üres-e?(s) akkor s.hiba:=igaz kül. Első:=s.első^.adat Függvény vége Eljárás Sorból(vált s:sor; e:ElemTip) vált smut: MemCim Ha Üres-e?(s) akkor s.hiba:=igaz kül. e:=s.első^.adat smut:=s.első s.első:=s.első^.mut Felszabadít(smut) Ha s.első=Nil akkor s.utolsó:=Nil Elágazás vége Eljárás vége Eljárás Sorba(vált s:sor; konstans e:ElemTip) vált új: MemCim Ha Tele-e?(s) akkor s.hiba:=igaz kül. Lefoglal(új) új^.adat:=e új^.mut:=Nil Ha s.első=Nil akkor s.első:=új kül. s.utolsó^.mut:=új s.utolsó:=új Elágazás vége Eljárás vége


44

Statikus lista és műveletei Konstans

MaxHossz = X

Tipus

ElemTip Index LElem

: Y : 0..MaxHossz : Rekord adat : ElemTip mut : Index Vége

Lista

: Rekord fej, szfej, akt : Index elem : [1..MaxHossz] tömbje LElemnek hiba : logikai Vége

Eljárás Üres(vált l:lista) l.fej:=0 : l.hiba:=hamis : l.szfej:=1 : l.akt:=0 Ciklus i:=1-től MaxHossz-1-ig l.elem[i].mut:=i+1 Ciklus vége l.elem[MaxHossz].mut:=0 Eljárás vége Függvény Üres-e?(l:lista):logikai Üres-e?:=(l.fej=0) Függvény vége Függvény Tele-e?(l:lista):logikai Tele-e?:=(l.szfej=0) Függvény vége Függvény Hibás-e?(l:lista):logikai Hibás-e?:=(l.hiba=igaz) l.hiba:=hamis Függvény vége Függvény ElemÉrték(vált l:lista):ElemTip Ha l.akt=0 akkor l.hiba:=igaz kül. ElemÉrték:=l.elem[l.akt].adat Függvény vége Függvény Végén-e?(vált l:lista):logikai Ha l.akt=0 akkor l.hiba:=igaz kül. Végén-e?:=(l.elem[l.akt].mut=0) Függvény vége


Eljárás Elsőre(vált l:lista) l.akt:=l.fej Eljárás vége Eljárás Következőre(vált l:lista) Ha l.akt=0 akkor l.hiba:=igaz kül. l.akt:=l.elem[l.akt].mut Eljárás vége Eljárás ElemMódosit(vált l:lista; konstans e:ElemTip) Ha l.akt=0 akkor l.hiba:=0 kül. l.elem[l.akt].adat:=e Eljárás vége Eljárás BeszúrElsőnek(vált l:lista; konstans e:ElemTip) Ha tele-e?(L) akkor l.hiba:=igaz kül. l.elem[l.szfej].adat:=e sv:=l.szfej l.szfej:=l.elem[sv].mut l.elem[sv].mut:=ol.akt l.fej:=sv l.akt:=sv Elágazás vége Eljárás vége Eljárás BeszúrMögé(vált l:lista; konstans e:ElemTip) Ha tele-e?(L) akkor l.hiba:=igaz kül. Ha üres-e? akkor BeszúrElsőnek(l,e) kül. Ha l.akt=0 akkor l.hiba:=igaz kül. l.elem[l.szfej].adat:=e sv:=l.szfej l.szfej:=l.elem[l.szfej].mut sv2:=l.elem[l.akt].mut l.elem[l.akt].mut:=sv l.elem[sv].mut:=sv2 l.akt:=sv Elágazás vége Elágazás vége Elágazás vége Eljárás vége

45

46


Eljárás BeszúrElé(vált l:lista; konstans e:ElemTip) Ha tele-e?(L) akkor l.hiba:=igaz kül. Ha l.akt=l.fej akkor BeszúrElsőnek(l,e) kül. Ha l.akt=0 akkor l.hiba:=igaz kül. l.elem[l.szfej].adat:=e sv:=l.szfej l.szfej:=l.elem[l.szfej].mut l.elem[sv].mut:=l.akt előző:=l.fej Ciklus amig l.elem[előző].mut<>l.akt előző:=l.elem[előző].mut Ciklus vége l.elem[előző].mut:=sv l.akt:=sv Elágazás vége Elágazás vége Elágazás vége Eljárás vége Eljárás Előzőre(vált l:lista) Ha l.akt=0 akkor l.hiba:=igaz kül. sv:=l.akt l.akt:=l.fej Ciklus amig l.elem[l.akt].mut<>sv l.akt:=l.elem[l.akt].mut Ciklus vége Elágazás vége Eljárás vége Eljárás BeszúrEléV(vált l:lista, konstans e:ElemTip) Ha l.akt=l.fej akkor BeszúrElsőnek(l,e) kül. Előzőre(l) BeszúrMögé(l,e) Elágazás vége Eljárás vége Eljárás Töröl(vált l:lista) Ha l.akt=0 akkor l.hiba:=igaz kül. Ha l.akt=l.fej akkor l.elem[l.fej].mut:=l.szfej l.szfej:=l.fej l.fej:=l.elem[l.fej].mut l.akt:=l.fej Elágazás vége Eljárás vége


47

Dinamikus lista és műveletei Tipus

ElemTip MemCim LElem

Lista

: Y : ^LElem : Rekord adat : ElemTip mut : MemCim Vége : Rekord fej, akt hiba Vége

{következőre mutat}

: MemCim : logikai

Eljárás Üres(vált l:lista) l.fej:=Nil l.akt:=Nil l.hiba:=hamis Eljárás vége Függvény Üres-e?(l:lista):logikai Üres-e?:=(l.fej=Nil) Függvény vége Függvény Tele-e?(l:lista):logikai Ha MaxSzabadBlokk<ElemMéret(LElem) akkor Tele-e?:=igaz kül. Tele-e?:=hamis Függvény vége Függvény Hibás-e?(vált l:lista):logikai Hibás-e?:=(l.hiba=igaz) l.hiba:=hamis Függvény vége Függvény ElemÉrték(vált l:lista):ElemTip Ha l.akt=Nil akkor l.hiba:=igaz kül. ElemÉrték:=l.akt^.adat Függvény vége Függvény Végén-e?(vált l:lista):logikai Végén-e?:=(l.akt=Nil) Függvény vége

48


Eljárás Elsőre(vált l:lista) l.akt:=l.fej Eljárás vége Eljárás Következőre(vált l:lista) Ha l.akt=Nil akkor l.hiba:=igaz kül. l.akt:=l.akt^.mut Eljárás vége Eljárás ElemMódosit(vált l:lista; konstans e: ElemTip) Ha l.akt=Nil akkor l.hiba:=igaz kül. l.akt^.adat:=e Eljárás vége Eljárás BeszúrMögé(vált l:lista; konstans e: ElemTip) vált uj : MemCim Ha Tele-e?(l) vagy l.akt=Nil akkor l.hiba:=igaz kül. Lefoglal(uj) uj^.adat:=e Ha Üres-e?(l) akkor uj^.mut:=Nil l.fej:=uj kül. uj^.mut:=l.akt^.mut l.akt^.mut:=uj Elágazás vége l.akt:=uj Elágazás vége Eljárás vége Eljárás BeszúrElsőnek(vált l:lista; konstans e: ElemTip) vált uj: MemCim Ha Tele-e?(l) akkor l.hiba:=igaz kül. Lefoglal(uj) uj^.adat:=e uj^.mut :=l.fej l.fej:=uj l.akt:=uj Elágazás vége Eljárás vége


Eljárás BeszúrElé(vált l:lista; konstans e: ElemTip) {bárhová} vált uj: MemCim Ha Tele-e?(l) akkor l.hiba:=igaz kül. Lefoglal(uj) Ha Üres-e?(l) vagy Végén-e?(l) akkor uj^.adat:=e uj^.mut :=Nil Ha Üres-e(l) akkor l.fej:=uj kül. l.akt:=l.fej Ciklus amig l.akt^.mut<>Nil l.akt:=l.akt^.mut Ciklus vége l.akt^.mut:=uj Elágazás vége l.akt:=uj kül. uj^.adat:=l.akt^.adat l.akt^.adat:=e uj^.mut:=l.akt^.mut l.akt^.mut:=uj Elágazás vége Elágazás vége Eljárás vége Eljárás Töröl(vált l:lista) vált smut: MemCim Ha l.akt=Nil akkor l.hiba:=igaz kül. Ha l.akt=l.fej akkor l.fej:=l.akt^.mut Felszabadit(l.akt) l.akt:=l.fej kül. smut:=l.fej Ciklus amig smut^.mut<>l.akt smut:=smut^.mut Ciklus vége smut^.mut:=l.akt^.mut Felszabadit(l.akt) l.akt:=smut^.mut Elágazás vége Elágazás vége Eljárás vége

49


50

Bináris fa Bináris fa: speciális gráf, mely - irányított - összefüggő - körmentes - minden pontjába pontosan egy él fut be (kivéve gyökérelem, ahol nulla) - minden pontjából max. kettő él indul ki (két rákövetkezés) - levélelem: nem indul belőle él Statikus bináris fa Konstans

MaxHossz = X

Tipus

ElemTip Index BinFaElem

: Y : 0..MaxHossz : Rekord bal : Index adat : ElemTip jobb : Index Vége

BinFa

: Rekord fa fej szh hiba Vége

: : : :

tömbje[1..MaxHossz] BinFaElemnek Index Index logikai

Dinamikus bináris fa Tipus

ElemTip MemCim BinFaElem

: Y : ^BinFaElem : Rekord bal : MemCim adat : ElemTip jobb : MemCim Vége

BinFa

: Rekord fej, akt : MemCim hiba : logikai Vége

vagy egyszerűbben: BinFa

: MemCim


Eljárás Üres(vált f:BinFa) f=Nil Eljárás vége Függvény Üres-e?(f:BinFa):logikai Üres-e?:=(f=Nil) Függvény vége Függvény EgyelemüFa(e:ElemTip):BinFa vált f:BinFa Ha MaxSzabadBlokk<ElemMéret(BinFaElem) akkor EgyelemüFa:=Nil különben Lefoglal(f) f^.adat:=e f^.bal:=Nil f^.jobb:=Nil EgyelemüFa:=f Elágazás vége Függvény vége Eljárás BalraIlleszt(vált mihez:BinFa; konst mit:BinFa) Ha mihez^.bal=Nil akkor mihez^.bal:=mit Eljárás vége Függvény BalGyerek(f:BinFa):BinFa Ha f<>Nil akkor BalGyerek:=f^.bal kül. BalGyerek:=Nil Függvény vége Függvény GyökérElem(f:BinFa):ElemTip Ha f<>Nil akkor GyökérElem:=f^.adat kül. GyökérElem:=Y0 Függvény vége Eljárás GyökérMódosit(vált f:BinFa; konst e:ElemTip) Ha f<>Nil akkor f^.adat:=e Eljárás vége Eljárás FaTörlés(vált f:BinFa) Ha nem Üres-e?(f) akkor FaTörlés(BalGyerek(f)) FaTörlés(JobbGyerek(f)) Felszabadit(f) f:=Nil Elágazás vége Eljárás vége

51


52

Fabejárások Eljárás BKJ(f:BinFa) Ha nem Üres-e?(f) akkor BKJ(BalGyerek(f)) Feldolgoz(GyökérElem(f)) BKJ(JobbGyerek(f)) Elágazás vége Eljárás vége Eljárás BJK(f:BinFa) Ha nem Üres-e?(f) akkor BJK(BalGyerek(f)) BJK(JobbGyerek(f)) Feldolgoz(GyökérElem(f)) Elágazás vége Eljárás vége Eljárás KBJ(f:BinFa) Ha nem Üres-e?(f) akkor Feldolgoz(GyökérElem(f)) KBJ(BalGyerek(f)) KBJ(JobbGyerek(f)) Elágazás vége Eljárás vége


Rendezés bináris fával Be: X(N) Ki: X(N) rendezve Eljárás Rendezés_BinFával Üres(f) f:=EgyelemüFa(X(1)) Ciklus i:=2-töl N-ig HelyKeres(f,X(i)) Ciklus vége i:=1 BKJ(f) FaTörlés(f) Eljárás vége Eljárás HelyKeres(vált f:BinFa; e:ElemTip) Ha e<=GyökérElem(f) akkor Ha Üres-e?(BalGyerek(f)) akkor BalraIlleszt(f,EgyelemüFa(e)) kül. HelyKeres(BalGyerek(f),e) Elágazás vége kül. Ha Üres-e?(JobbGyerek(f)) akkor JobbraIlleszt(f,EgyelemüFa(e)) kül. HelyKeres(JobbGyerek(f),e) Elágazás vége Elágazás vége Eljárás vége Eljárás BKJ(f:BinFa) Ha nem Üres-e?(f) akkor BKJ(BalGyerek(f)) Feldolgoz(GyökérElem(f)) BKJ(JobbGyerek(f)) Elágazás vége Eljárás vége Eljárás Feldolgoz(e:ElemTip) X(i):=e i:=i+1 Eljárás vége

53


54

Postfix forma előállítása Infix alakból Tipus

Változó

LexEgys = Rekord fajta : (OPERANDUS,MUVJEL) adat : szöveg Vége InFix PostFix v le

: : : :

Sor ∈ LexEgys Sor ∈ LexEgys verem ∈ LexEgys LexEgys

ï bemenet ï kimenet

Eljárás PostFixKészít Üres(v) : Üres(PostFix) Ciklus amig nem Üres-e?(InFix) Sorból(InFix,le) Elágazás le.fajta = OPERANDUS esetén Sorba(PostFix,le) le.adat = '(' esetén Verembe(v,le) le.adat = ')' esetén NyitóigKivesz egyébként NemKisebbeketKiveszÉsEztBerak Elágazás vége Ciklus vége VeremÜrit Eljárás vége Eljárás NyitóigKivesz Ciklus amig Tetö(v)<>'(' Veremből(v,le) Sorba(PostFix,le) Ciklus vége Veremböl(v,le) Eljárás vége Eljárás NemKisebbeketKiveszÉsEztBerak vált s: LexEgys Ciklus amig nem Üres-e?(v) és Prec(Tetö(v))>=Prec(le.fajta) Veremböl(v,s) Sorba(PostFix,s) Ciklus vége Verembe(v,le) Eljárás vége Függvény Prec(jel: LexEgys):szám Elágazás jel.adat='+' vagy jel.adat ='-' esetén Prec:=1 jel.adat='*' vagy jel.adat ='/' esetén Prec:=2 jel.adat ='^' esetén Prec:=3 jel.adat ='(' esetén Prec:=4 Elágazás vége Függvény vége


55

Eljárás VeremÜrit Ciklus amig nem Üres-e?(v) Veremböl(v,le) Sorba(PostFix,le) Ciklus vége Eljárás vége

Postfix forma kiértékelése Tipus

Változó

LexEgys = Rekord fajta : (OPERANDUS,MUVJEL) adat : szöveg Vége PostFix Eredm v le op1,op2

: : : : :

Sor ∈ LexEgys valós verem ∈ valós LexEgys valós

ï bemenet ï kimenet

Eljárás PostfixÉrték Üres(v) Ciklus amig nem Üres-e?(PostFix) Sorból(PostFix,le) Ha le.fajta=OPERANDUS akkor Verembe(v,Érték(le.adat) kül. Veremböl(v,op2) Veremböl(v,op1) Verembe(v,KiSzámol(le.adat,op1,op2) Elágazás vége Ciklus vége Veremböl(v,Eredm) Eljárás vége Függvény Kiszámol(muv:szöveg; op1,op2:valós): valós Elágazás muv='+' esetén KiSzámol:=op1+op2 muv='-' esetén KiSzámol:=op1-op2 muv='*' esetén KiSzámol:=op1*op2 muv='/' esetén KiSzámol:=op1/op2 muv='^' esetén KiSzámol:=op1^op2 Elágazás vége Eljárás vége


56

Gráf Gráf: pontok (n) és élek (e) halmaza, ahol az élek ponttól pontig tartanak. Kapcsolódó fogalmak: út, kör, hurokél, párhuzamos élek, levegőben lógó él, irányított él, súlyozott él, fokszám, izolált pont, összefüggő gráf, irányított/irányítatlan gráf. Ábrázolás: 1., Csúcs- (szomszédsági) mátrix: n∗n-es logikai tömb hátrány: statikus 2., Éllista [+csúcslista]: Tipus Gráf: Rekord Él: lista ∈ ^él [Csúcs: lista ∈ ^pont] [hiba: logikai] Rekord vége

Műveletei: Eljárás Üres(vált g:gráf) Függvény Üres-e?(g:gráf):logikai Függvény Tele-e?(g:gráf):logikai Függvény Hibás-e?(vált g:gráf):logikai Függvény Pontszám?(g:gráf):egész Függvény Élszám?(g:gráf):egész Eljárás PontBeilleszt(vált g:gráf; p:pont) Eljárás ÉlBeilleszt(vált g:gráf; e:él) Eljárás PontTöröl(vált g:gráf; pp:^pont) Eljárás ÉlTöröl(vált g:gráf; pe:^él) Függvény VaneÉl?(g:gráf; pp1,pp2:^pont):logikai Függvény FokSzám(g:gráf; pp:^pont):egész Függvény KövetkezőPont(g:gráf; pp:^pont; e:élsorszám):^pont Kapcsolódó feladat: - Van-e út p1 és p2 között? - Melyik a legrövidebb út p1 és p2 között?


Gráfbejárások Eljárás SzélességiBejárás(g:gráf; x:^pont) vált s: sor ∈ ^pont h: halmaz ∈ ^pont p,sp: ^pont él: élsorszám ÜresSor(s) ÜresHalmaz(h) Sorba(s,x) Halmazba(h,x) Feldolgoz(g,x) Ciklus amig nem Üres-e?(s) Sorból(s,p) Ciklus él:=1-től FokSzám(g,p)-ig sp:=KövetkezőPont(g,p,él) Ha nem Eleme(h,sp) akkor Sorba(s,sp) Halmazba(h,sp) Feldolgoz(g,sp) Elágazás vége Ciklus vége Ciklus vége Eljárás vége Eljárás MélységiBejárás(g:gráf; x:^pont) vált v: verem ∈ (^pont,élsorszám) h: halmaz ∈ ^pont p,sp: ^pont él: élsorszám ÜresVerem(v) ÜresHalmaz(h) p:=x : él:=1 Halmazba(h,p) Feldolgoz(g,p) Ciklus Ciklus amig él<=FokSzám(g,p) sp:=Következőpont(g,p,él) Ha nem Eleme(h,sp) akkor Verembe(v,(p,él)) p:=sp : él:=1 Halmazba(h,p) Feldolgoz(g,p) különben él:=él+1 Elágazás vége Ciklus vége Veremből(v,(p,él)) él:=él+1 Mígnem Üres-e?(v) és él>FokSzám(g,x) Ciklus vége Eljárás vége

57


58

Objektumorientált programozás

Az objektum-orientált programozás (röviden OOP) a természetes gondolkodást, cselekvést közelítő programozási mód, amely a programozási nyelvek tervezésének természetes fejlődése következtében alakult ki. Az így létrejött nyelv sokkal strukturáltabb, sokkal modulárisabb és absztraktabb, mint egy hagyományos nyelv. Egy OOP nyelvet három fontos dolog jellemez. Ezek a következők: •

Az egységbezárás (encapsulation) azt takarja, hogy az adatstruktúrákat és az adott struktúrájú adatokat kezelő függvényeket (Smalltalk, illetve a TURBO Pascal terminológiával élve metódusokat) kombináljuk; azokat egy egységként kezeljük, és elzárjuk őket a külvilág elől. Az így kapott egységeket objektumoknak nevezzük. Az objektumoknak megfelelő tárolási egységek típusát a C++-ban osztálynak (class) nevezzük.

•

Az öröklés (inheritance) azt jelenti, hogy adott, meglévő osztályokból levezetett újabb osztályok öröklik a definiálásukhoz használt alaposztályok már létező adatstruktúráit és függvényeit. Ugyanakkor újabb tulajdonságokat is definiálhatnak, vagy régieket újraértelmezhetnek. Így egy osztályhierarchiához jutunk.

•

A többrétűség (polymorphism) alatt azt értjük, hogy egy adott tevékenység (metódus) azonosítója közös lehet egy adott osztályhierarchián belül, ugyanakkor a hierarchia minden egyes osztályában a tevékenységet végrehajtó függvény megvalósítása az adott osztályra nézve specifikus lehet. Az ún. virtuális függvények lehetővé teszik, hogy egy adott metódus konkrét végrehajtási módja csak a program futása során derüljön ki. Ugyancsak a többrétűség fogalomkörébe tartozik az ún. overloading, aminek egy sajátságos esete a C nyelv standard operátorainak átdefiniálása (operator overloading).

Ezek a tulajdonságok együtt azt eredményezik, hogy programkódjaink sokkal struktúráltabbá, könnyebben bővíthetővé, könnyebben karbantarthatóvá válnak, mintha hagyományos, nem OOP-technikával írnánk őket.


Objektum = adattagok + metódusok

tipus téglalap = objektum a,b: valós; függvény kerület: valós; függvény terület: valós; objektum vége függvény téglalap.kerület: valós; kerület:=2*(a+b); függvény vége; függvény téglalap.terület: valós; terület:=a*b; függvény vége; tipus téglatest = objektum t: téglalap; m: valós; függvény térfogat: valós; objektum vége; függvény téglatest.térfogat: valós; térfogat:=t.terület*m; függvény vége; vált. t1, t2: téglalap; tt: téglatest; Eljárás demo t1.a:= 5; t1.b:= 2; t2.a:=10; t2.b:=25; ki(t1.kerulet); ki(t1.terulet); ki(t2.kerulet); ki(t2.terulet); tt.t.a:=3; tt.t.b:=5; tt.m:=4; ki(tt.terfogat); Eljárás vége

59


60

program oop_teglalap; type teglalap = object a,b: real; function kerulet: real; function terulet: real; end; function teglalap.kerulet: real; begin kerulet:=2*(a+b); end; function teglalap.terulet: real; begin terulet:=a*b; end; type teglatest = object t: teglalap; m: real; function terfogat: real; end; function teglatest.terfogat: real; begin terfogat:=t.terulet*m; end; var t1, t2: teglalap; tt: teglatest; begin t1.a:= 5; t1.b:= 2; t2.a:=10; t2.b:=25; writeln(t1.kerulet); writeln(t1.terulet); writeln(t2.kerulet); writeln(t2.terulet); tt.t.a:=3; tt.t.b:=5; tt.m:=4; writeln(tt.terfogat); end.


#include <stdio.h> typedef class { public: float a,b; float kerulet(); float terulet(); } teglalap; float teglalap::kerulet() { return 2*(a+b); }; float teglalap::terulet() { return a*b; } typedef class { public: teglalap t; float m; float terfogat(); } teglatest; float teglatest::terfogat() { return t.terulet()*m; } teglalap teglatest

t1, t2; tt;

void main() { t1.a= 5; t1.b= 2; t2.a=10; t2.b=25; printf("%f\n",t1.kerulet()); printf("%f\n",t1.terulet()); printf("%f\n",t2.kerulet()); printf("%f\n\n",t2.terulet()); tt.t.a=3; tt.t.b=5; tt.m=4; printf("%f\n\n\n",tt.terfogat()); }

61


62

Egyéb témák Algoritmusok - Shell rendezés - tömörítési eljárások

Eljárások, függvények - paraméterezés összetett adatokkal

Grafika - képformátumok

Interrupt - fogalma, szerepe - használata - DOS interrupt - példa: hanggenerálás

Programozás-elmélet Oktatási segédlet

Recommend Documents