programozás-elméletprogramozás-elmélet k.l. 7 algoritmuskészítés algoritmus:...

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

Összeállította: Kovács László

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

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

Programozás-elmélet K.L. 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

Be: X ∈ R Ki: Y12 ∈ R Ef: X >= 0 Uf: Y12 = ± X

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

Be: a,b,c ∈ R Ki: x12 ∈ R Ef: a <> 0 és b2-4ac >= 0

Uf: x12 = − ± −b b 4ac2a2


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 Méret Előjel Tartomány byte 1 B előjel nélküli 0..255 word 2 B előjel nélküli 0..65535 shortint 1 B előjeles -128..+127 integer 2 B előjeles -32768..+32767 longint 4 B előjeles ± 2 milliárd Ábrázolás: kettes komplemens kódban Műveletei: +, −, ∗, DIV, MOD, INC, DEC; SHL, SHR, AND, OR, XOR. b., karakteres: char 1 B Á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: boolean / logical 1 B {false..true} Műveletei: NOT; AND, OR, XOR, EQU, NAND, NOR, implikáció. Hasonlító operátorok: =, >, <, <>, >=, <=, IN.


2. Valós típusosztály: real 5+1 B single 3+1 B double 6+2 B extended 7+3 B comp Á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)


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 Rekord 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


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


Példák: 1., Számrendszerváltás Be: Szam1 ∈ karaktersorozat SzR1, SzR2 ∈ [2..36] Ki: Szam2 ∈ karaktersorozat Ef: SzJ=‘0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ’ Uf: 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


Programozási tételek 1., Sorozatszámítás Be: X(N) - X nevű, N elemű tömb f - függvény F0 - 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) - X nevű, N elemű tömb T - 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.)


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) - X nevű, N elemű tömb T - tulajdonság 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.)


5., Keresés Be: X(N) - X nevű, N elemű tömb T - tulajdonság Ki: VAN ∈ L - logikai változó Ha VAN, akkor S ∈ N - sorszám 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)) 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) - X nevű, N elemű tömb T - tulajdonság 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.)


7., Másolás Be: X(N) - X nevű, N elemű tömb f - 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) - X nevű, N elemű tömb T - tulajdonság Ki: DB ∈ N - darabszám Y(DB): - Y nevű, DB elemű tömb Ef: -- Uf: DB : 0<=DB<=N, X-beli T tulajdonságú elemek száma Y(DB): 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) - X nevű, N elemű tömb T - tulajdonság Ki: DB ∈ N - darabszám Y(DB) - Y nevű, DB elemű tömb Z(N-DB): - Z nevű, N-DB elemű tömb Ef: -- Uf: DB : 0<=DB<=N, X-beli T tulajdonságú elemek száma Y(DB) : minden 1<=i<=DB esetén T(Y(i)) Z(N-DB) : 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) - X nevű, N elemű tömb T - tulajdonság Ki: DB ∈ N - darabszám Y(N) - Y nevű, N elemű tömb Ef: -- Uf: DB : 0<=DB<=N, X-beli T tulajdonságú elemek száma Y(N) : 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


c., Szétválogatás helyben Be: X(N) - X nevű, N elemű tömb T - tulajdonság Ki: DB ∈ N - darabszám X(N) - X nevű, N elemű tömb Ef: -- Uf: DB : 0<=DB<=N, X-beli T tulajdonságú elemek száma X(N) : 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<U Ciklus amíg E<U és nem T(X(U)) U:=U-1 Ciklus vége Ha E<U, akkor X(E):= X(U) : E:=E+1 Ciklus amíg E<U és T(X(E)) E:=E+1 Ciklus vége Ha E<U akkor X(U):=X(E) : U:=U-1 Feltétel vége Ciklus vége X(E):=Y Ha T(Y) akkor DB:=E különben DB:=E-1 Eljárás vége


10., Metszet Be: X(N) - X nevű, N elemű tömb Y(M) - Y nevű, M elemű tömb Ki: DB ∈ N - darabszám Z(DB) - Z nevű, DB elemű tömb Ef: X és Y halmazok Uf: DB : 0<=DB<=min(N,M), X∩Y halmaz elemeinek száma Z(DB) : 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) - X nevű, N elemű tömb Y(M) - Y nevű, M elemű tömb Ki: DB ∈ N - darabszám Z(DB) - Z nevű, DB elemű tömb Ef: X és Y halmazok Uf: DB : 0<=DB<=N+M, X∪Y halmaz elemeinek száma Z(DB) : 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


12., Összefuttatás, összefésülés Be: X(N) - X nevű, N elemű tömb Y(M) - Y nevű, M elemű tömb 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):=X(i) : i:=i+1 X(i)=Y(j) esetén: Z(k):=X(i) : i:=i+1 : j:=j+1 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<N+1 vagy j<M+1 k:=k+1 Ha X(i)<=Y(j), akkor Z(k):=X(i) : i:=i+1 különben Z(k):=Y(j) : j:=j+1 Ciklus vége Eljárás vége


13., Rendezés Be: X(N) - X nevű, N elemű tömb Ki: X(N) - X nevű, N elemű tömb 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


14., Logaritmikus keresés Be: X(N) - X nevű, N elemű tömb Y - érték Ki: VAN ∈ L - logikai változó Ha VAN, akkor S ∈ N - sorszám 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) Eljárás Logaritmikus_keresés E:=1 : U:=N Ciklus k:=[(E+U)/2] Elágazás X(k)<Y esetén: E:=k+1 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)


15., Visszalépéses keresés (BackTrack) Be: N db sorozat M(1), M(2), ... M(N) elemszámmal T - tulajdonság Ki: VAN ∈ L - logikai változó Ha VAN, akkor S(N) ∈ N - sorszámokat tartalmazó sorozat 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 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<i és T(i,S(i),j,S(j)) másként: (i,S(i)) nem zája ki (j,S(j))-t j:=j+1 Ciklus vége pl: Sakktábla királynői esetén ElemRendben:=(j=i) S(i)<>S(j) és |i-j|<>|S(i)-S(j)| Függvény vége


Rekurzió Matematikai művelet:

Fakt(n) 1 ha n 1 n Fakt(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


2., Fibonacci sorozat

Fib(n)= 1 ha n=0 vagy n=1 Fib(n-1)+Fib(n-2) ha 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) akkor Festés(X-1,Y) Ha nem Festett(X,Y-1) akkor Festés(X,Y-1) Ha nem Festett(X+1,Y) akkor Festés(X+1,Y) Ha nem Festett(X,Y+1) akkor Festés(X,Y+1) Eljárás vége 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


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 - kristályok - jégvirág az ablakon - fa - felhők - penész - villámlás - korall - hullámok - tüdő - hegyek - idegsejt - partvonal - 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


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 Pascalban: MoveTo 2 Pascalban: LineRel


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

-szöveges fájl → text -típusos fájl → file of ... -típus nélküli fájl → file

2. Hozzárendelés(fájlváltozó,fájlnév) → assign

3. Megnyitás(fájlváltozó)

4. Fájlműveletek

5. Bezárás(fájlváltozó) → close

Fájl megnyitása: szöveges típusos típus nélküli -létrehozással → rewrite ü ü ü -csak olvasásra → reset ü -hozzáfűzésre → append ü -módosításra → reset ü ü Fájlműveletek: szöveges típusos típus nélküli -sor olvasása → readln ü -sor írása → writeln ü -adat olvasása → read ü -adat írása → write ü ü -blokk olvasása → blockread ü -blokk írása → blockwrite ü -sorvége? → seekeol,eoln ü -fájlvége? → seekeof ü → eof ü ü ü -hibakód? → ioresult ü ü ü -fájlméret? → filesize ü ü -fájlpozíció? → filepos ü ü -pozícionálás → seek ü ü -fájlcsonkítás → 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ó.


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 ⇒ 7. futam rendezve 8. futam rendezve 5. futam 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


9-10. futam rendezve

1. segédfájl: 2. segédfájl:


9-12. futam rendezve

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


Programozási nyelvek osztályozása I. Felhasználó szerinti csoportosítás a., amatőr nyelv - párbeszédesség - gyors fejlődés - sok nyelvi elem - egyszerű programszerkezet - gépfüggőség

b., professzionális nyelv - modularitás - stabilitás - kevés nyelvi elem - összetett programszerkezet - gépfüggetlensé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 AX,40H mov ES,AX mov AL,ES:[17H] and AL,0dfH mov ES:[17H],AL int 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


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ó


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 '50s - beolvasás, kiírás, műveletek 2GL: - kifejezések, szintaxis '60s - zárójelezés - összetett típusok - fájlkezelés 3GL: - stukturált programozás '70s - programozási tételek 4GL: - moduláris programozás '80s - objektumorientált programozás - programkódgenerátor 5GL: - párhuzamosság '90s


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)


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


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.


- 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)


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 x x23 73 7+ ⋅ + ⋅ 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

pl.: E mv=12

2 helyett E mv= ⋅0 5 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


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.


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 rectangle(x1,y1,x2,y2); téglalap kitöltve bar(x1,y1,x2,y2); kör circle(x,y,r); körív arc(x,y,k_szögfok,v_szögfok,r); elipszis ellipse(x,y,k_szögfok,v_szögfok,r1,r2); körszelet kitöltve pieslice(x,y,k_szögfok,v_szögfok,r); kitöltésállítás setfillstyle(minta,szín); zárt terület kitöltése floodfill(x,y,határszín); szövegírás outtext(’szöveg’); outtextxy(x,y,’szöveg’); szövegformátumállítás settextstyle(betűtipus,irány,méret); szövegigazítás settextjustify(vízszintes, függőleges);


Ö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 MemCim = ^elem; elem = record adat: word; mut: MemCim; end; dintomb = record fej, akt: MemCim; end; var t: dintomb; uj: MemCim; db: byte; x: 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.


Statikus verem és műveletei Konstans MaxHossz = X Tipus ElemTip : Y Index : 0..MaxHossz Verem : 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


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


Dinamikus sor és műveletei Tipus ElemTip : Y MemCim : ^SElem SElem : Rekord adat : ElemTip mut : MemCim {következőre mutat} Vége Sor : 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


Statikus lista és műveletei Konstans MaxHossz = X Tipus ElemTip : Y Index : 0..MaxHossz LElem : 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


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


Dinamikus lista és műveletei Tipus ElemTip : Y MemCim : ^LElem LElem : Rekord adat : ElemTip mut : MemCim {következőre mutat} Vége Lista : Rekord fej, akt : MemCim hiba : logikai Vége 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


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


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 : Y Index : 0..MaxHossz BinFaElem : Rekord bal : Index adat : ElemTip jobb : Index Vége BinFa : Rekord fa : tömbje[1..MaxHossz] BinFaElemnek fej : Index szh : Index hiba : logikai Vége Dinamikus bináris fa Tipus ElemTip : Y MemCim : ^BinFaElem 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


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


Postfix forma előállítása Infix alakból Tipus LexEgys = Rekord fajta : (OPERANDUS,MUVJEL) adat : szöveg Vége Változó InFix : Sor ∈ LexEgys ï bemenet PostFix : Sor ∈ LexEgys ï kimenet v : verem ∈ LexEgys le : LexEgys 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


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 LexEgys = Rekord fajta : (OPERANDUS,MUVJEL) adat : szöveg Vége Változó PostFix : Sor ∈ LexEgys ï bemenet Eredm : valós ï kimenet v : verem ∈ valós le : LexEgys op1,op2 : valós 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


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


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


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 t1, t2; teglatest 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()); }


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életprogramozás-elmélet k.l. 7 algoritmuskészítés algoritmus:...

Documents