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

Átírás

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

2 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

3 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 Elemei: A feladat meghatározása 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: Y 12 R Ef: X >= 0 Uf: Y 12 = ± X 2. példa: másodfokú egyenlet megoldása Be: a,b,c R Ki: x 12 R Ef: a <> 0 és b 2-4ac >= 0 2 Uf: x 12 = b ± b 4ac 2a

4 4 Programozás-elmélet K.L. 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 word 2 B előjel nélküli shortint 1 B előjeles integer 2 B előjeles longint 4 B előjeles ± 2 milliárd Ábrázolás: Műveletei: kettes komplemens kódban +,,, DIV, MOD, INC, DEC; SHL, SHR, AND, OR, XOR. b., karakteres: char 1 B Ábrázolás: Műveletei: ASCII kódtábla alapján: vezérlő karakterek alapkarakterek kiegészítő karakterek (kódlap-függő) 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.

5 Programozás-elmélet K.L 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: Műveletei: lebegőpontos számként: mantissza+karakterisztika minden matematikai művelet és függvény - pl: abs(), int(), random() - pascalban nincs hatványozás, de a b = 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 6 Programozás-elmélet K.L. 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

7 Programozás-elmélet K.L. 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 8 Programozás-elmélet K.L. Példák: 1., Számrendszerváltás Be: Ki: Ef: Uf: Szam1 karaktersorozat SzR1, SzR2 [2..36] Szam2 karaktersorozat SzJ= ABCDEFGHIJKLMNOPQRSTUVWXYZ 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 Szam2:= Ciklus amig Tizes>0 Szam2:=SzJ[Tizes mod SzR2]+Szam2 Tizes:=Tizes div SzR2 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:= *t.óra + 60*t.perc + t.mp + t.mp100/100 v:= p+mp Ha v >= akkor Ciklus RendszerIdő?(t.óra,t.perc,t.mp,t.mp100) Mígnem t.óra = 0 v:= v Ciklus RendszerIdő?(t.óra,t.perc,t.mp,t.mp100) p:= *t.óra + 60*t.perc + t.mp + t.mp100/100 Mígnem p >= v

9 Programozás-elmélet K.L. 9 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)) 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 Ki: DB N - X nevű, N elemű tömb - tulajdonság - 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 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 ( d., e., f.) - a π értékének közelítése geometriai valószínűség alapján (10.50.)

10 10 Programozás-elmélet K.L. 3., Maximumkiválasztás Be: X(N) Ki: MAX N - X nevű, N elemű tömb - 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 Kapcsolódó feladat: - minimumkiválasztás - kockadobások: legtöbbször előforduló szám ( g.) - egy szöveg leghosszabb szavának hossza 4., Eldöntés Be: X(N) T Ki: VAN L - X nevű, N elemű tömb - tulajdonság - 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 VAN:=(i<=N) Kapcsolódó feladat: - prímszámvizsgálat (8.1.6.) - vizsgálódás mátrixokban (8.2.4., , )

11 Programozás-elmélet K.L , Keresés Be: X(N) T - X nevű, N elemű tömb - tulajdonság Ki: VAN L Ha VAN, akkor S N - logikai változó - 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 VAN:=(i<=N) Ha VAN, akkor S:=i Kapcsolódó feladat: - keresés szótárban (rekordokat tartalmazó tömbben) 6., Kiválasztás Be: X(N) T Ki: S N - X nevű, N elemű tömb - tulajdonság - 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 S:=i Kapcsolódó feladat: - legnagyobb közös osztó és legkisebb közös többszörös meghatározása (8.1.9., )

12 12 Programozás-elmélet K.L. 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)) 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., ) 8., Kiválogatás Be: X(N) T Ki: DB N Y(DB): - X nevű, N elemű tömb - tulajdonság - darabszám - 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) Kapcsolódó feladat: - szám összes osztójának meghatározása - Armstrong-számok keresése (10.22.)

13 Programozás-elmélet K.L , Szétválogatás a., Szétválogatás két tömbbe Be: X(N) T - X nevű, N elemű tömb - 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) b., Szétválogatás egy tömbbe Be: X(N) T Ki: DB N Y(N) - X nevű, N elemű tömb - tulajdonság - darabszám - 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)

14 14 Programozás-elmélet K.L. c., Szétválogatás helyben Be: X(N) T Ki: DB N X(N) - X nevű, N elemű tömb - tulajdonság - darabszám - 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 Ha E<U, akkor X(E):= X(U) : E:=E+1 Ciklus amíg E<U és T(X(E)) E:=E+1 Ha E<U akkor X(U):=X(E) : U:=U-1 Feltétel vége X(E):=Y Ha T(Y) akkor DB:=E különben DB:=E-1

15 Programozás-elmélet K.L , Metszet Be: X(N) Y(M) Ki: DB N Z(DB) - X nevű, N elemű tömb - Y nevű, M elemű tömb - darabszám - Z nevű, DB elemű tömb Ef: X és Y halmazok Uf: DB : Z(DB) : 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 Ha j<=m akkor DB:=DB+1 : Z(DB):=X(i) 11., Unió Be: X(N) Y(M) Ki: DB N Z(DB) - X nevű, N elemű tömb - Y nevű, M elemű tömb - darabszám - Z nevű, DB elemű tömb Ef: X és Y halmazok Uf: DB : Z(DB) : 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 Ha j>m akkor DB:=DB+1 : Z(DB):=Y(i)

16 16 Programozás-elmélet K.L. 12., Összefuttatás, összefésülés Be: X(N) Y(M) Ki: Z(K) - X nevű, N elemű tömb - Y nevű, M elemű tömb - 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 Cilkus amíg i<=n k:=k+1 : Z(k):=X(i) : i:=i+1 Cilkus amíg j<=m k:=k+1 : Z(k):=Y(j) : j:=j+1 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

17 Programozás-elmélet K.L , 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 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 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 s:=x(min) : X(MIN):=X(i) : X(i):=s 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 X(j+1):=Y

18 18 Programozás-elmélet K.L. 14., Logaritmikus keresés Be: X(N) Y - X nevű, N elemű tömb - érték Ki: VAN L Ha VAN, akkor S N - logikai változó - 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 Mígnem E>U vagy X(k)=Y VAN:=(E<=U) Ha VAN, akkor S:=k Kapcsolódó feladat: - 2 x = x 3 egyenlet megoldása (10.45)

19 Programozás-elmélet K.L , Visszalépéses keresés (BackTrack) Be: N db sorozat M(1), M(2),... M(N) elemszámmal T - tulajdonság Ki: VAN L Ha VAN, akkor S(N) N - logikai változó - 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 VAN:=(i>N) 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)) VanJóElem:=(S(i)<=M(i)) Függvény ElemRendben(i,S(i)):logikai j:=1 Ciklus amig j<i és T(i,S(i),j,S(j)) j:=j+1 ElemRendben:=(j=i) 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 20 Programozás-elmélet K.L. 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 Végrehajtás: Függvény Fakt(n):szám Ha n<=1 akkor Fakt:=1 kül. Fakt:=n Fakt(n-1) 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

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

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

23 Programozás-elmélet K.L. 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 KochRajz(szint, hossz: egész) Ha szint=0 akkor x:=hossz cos(irány) y:=hossz sin(irány) VonalAktuálisPontból 2 (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) b., Sierpinski-csipke c., Cantor-halmaz 1 Pascalban: MoveTo 2 Pascalban: LineRel

24 24 Programozás-elmélet K.L. Fájltípusok hozzáférés szerint: Használat: a., Szekvenciális: b., Direkt Fájlkezelés -soros hozzáférés -pl.: szöveges fájl 1. Logikai fájlváltozó deklarálása -közvetlen hozzáférés -pl.: típusos és típus nélküli fájlok -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 -csak olvasásra -hozzáfűzésre -módosításra rewrite reset append reset Fájlműveletek: szöveges típusos típus nélküli -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 readln writeln read write blockread blockwrite seekeol,eoln seekeof eof ioresult filesize filepos seek truncate

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

26 26 Programozás-elmélet K.L. 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 5-6. futam rendezve 7-8. futam rendezve futam rendezve 1. segédfájl: 2. segédfájl: 1-4. futam rendezve 5-8. futam rendezve futam rendezve Végül előáll a rendezett fájl.

27 Programozás-elmélet K.L. 27 I. Felhasználó szerinti csoportosítás Programozási nyelvek osztályozása 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: = 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: B E C0 26 A DF 26 A CD 20

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

30 30 Programozás-elmélet K.L. I. Stratégiai elvek Programkészítési 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 Programozás-elmélet K.L. 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 32 Programozás-elmélet K.L. 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 Programozás-elmélet K.L 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: Módszerek: - "é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 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 34 Programozás-elmélet K.L. 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 VAN:=(i<=N) Ha VAN és i>1 akkor csere (X(i),X(i-1)) - 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

35 Programozás-elmélet K.L. 35 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 23 7 pl.: x + 3 x + 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 pl.: E = 1 2 mv helyett E = 0. 5 mv 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 2

36 36 Programozás-elmélet K.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 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 Indítás - feltételei - lehetőségei Átfogó ismertetés - menünként, képernyőnként, opciókként Menüszerkezet (menüfa) - célszerűen egy oldalon megvalósítva, forróbillentyűk feltüntetésével 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. 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

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

38 38 Programozás-elmélet K.L. Grafikus lehetőségek Pascalban program Grafika; uses newdelay,graph; const path='c:\tp70\bgi'; var grdriver, grmode: integer; procedure Rajz; begin end; {Ez a grfikus utasítások helye.} begin grdriver := Detect; InitGraph(grDriver, grmode, path); Rajz; ReadLn; CloseGraph; end. Grafikus utasítások: pont megjelenítése vonalrajzolás vonaltipusállítás graf. kurzor beállítás színállítás téglalap téglalap kitöltve kör körív elipszis körszelet kitöltve kitöltésállítás zárt terület kitöltése szövegírás szövegformátumállítás szövegigazítás putpixel(x,y,szin); line(x1,y1,x2,y2); lineto(x2,y2); linerel(x2,y2); setlinestyle(stílus,minta,vastagság); moveto(x,y); moverel(x,y); setcolor(szín); setbkcolor(szín); rectangle(x1,y1,x2,y2); bar(x1,y1,x2,y2); 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); setfillstyle(minta,szín); floodfill(x,y,határszín); outtext( szöveg ); outtextxy(x,y, szöveg ); settextstyle(betűtipus,irány,méret); settextjustify(vízszintes, függőleges);

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

40 40 Programozás-elmélet K.L. 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 Függvény Üres-e?(v:verem):logikai Üres-e?:=(v.tető=0) Függvény Tele-e?(v:verem):logikai Tele-e?:=(v.tető=MaxHossz) Függvény Hibás-e?(vált v:verem):logikai Hibás-e?:=(v.hiba) v.hiba:=hamis 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ő] 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 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

41 Programozás-elmélet K.L. 41 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 Függvény Üres-e?(v:verem):logikai Üres-e?:=(v.tető=Nil) Függvény Tele-e?(v:verem):logikai Tele-e?:=(MaxSzabadBlokk<ElemMéret(VElem)) Függvény Hibás-e?(vált v:verem):logikai Hibás-e?:=(v.hiba) v.hiba:=hamis 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 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 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)

42 42 Programozás-elmélet K.L. 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 Függvény Üres-e?(s:sor):logikai Üres-e?:=(s.hossz=0) Függvény Tele-e?(s:sor):logikai Tele-e?:=(s.hossz=MaxHossz) Függvény Hibás-e?(vált s:sor):logikai Hibás-e?:=s.hiba s.hiba:=hamis 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ő] 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 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

43 Programozás-elmélet K.L. 43 Dinamikus sor és műveletei Tipus ElemTip : Y MemCim : ^SElem SElem : Rekord adat : ElemTip mut : MemCim Vége {következőre mutat} 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 Függvény Üres-e?(s:sor):logikai Üres-e?:=(s.első=Nil) Függvény Tele-e?(s:sor):logikai Tele-e?:=(MaxSzabadBlokk<ElemMéret(SElem)) Függvény Hibás-e?(vált s:sor):logikai Hibás-e?:=s.hiba s.hiba:=hamis Függvény ElsőElem(vált s:sor):elemtip Ha Üres-e?(s) akkor s.hiba:=igaz kül. Első:=s.első^.adat 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 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

44 44 Programozás-elmélet K.L. 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 l.elem[maxhossz].mut:=0 Függvény Üres-e?(l:lista):logikai Üres-e?:=(l.fej=0) Függvény Tele-e?(l:lista):logikai Tele-e?:=(l.szfej=0) Függvény Hibás-e?(l:lista):logikai Hibás-e?:=(l.hiba=igaz) l.hiba:=hamis 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é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)

45 Programozás-elmélet K.L. 45 Eljárás Elsőre(vált l:lista) l.akt:=l.fej 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 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 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 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

46 46 Programozás-elmélet K.L. 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 l.elem[előző].mut:=sv l.akt:=sv 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 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) 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

47 Programozás-elmélet K.L. 47 Dinamikus lista és műveletei Tipus ElemTip : Y MemCim : ^LElem LElem : Rekord adat : ElemTip mut : MemCim Vége {következőre mutat} 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 Függvény Üres-e?(l:lista):logikai Üres-e?:=(l.fej=Nil) 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 Hibás-e?(vált l:lista):logikai Hibás-e?:=(l.hiba=igaz) l.hiba:=hamis 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égén-e?(vált l:lista):logikai Végén-e?:=(l.akt=Nil)

48 48 Programozás-elmélet K.L. Eljárás Elsőre(vált l:lista) l.akt:=l.fej 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 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 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 l.akt:=uj 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

49 Programozás-elmélet K.L. 49 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 l.akt^.mut:=uj l.akt:=uj kül. uj^.adat:=l.akt^.adat l.akt^.adat:=e uj^.mut:=l.akt^.mut l.akt^.mut:=uj 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 smut^.mut:=l.akt^.mut Felszabadit(l.akt) l.akt:=smut^.mut

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

51 Programozás-elmélet K.L. 51 Eljárás Üres(vált f:binfa) f=nil Függvény Üres-e?(f:BinFa):logikai Üres-e?:=(f=Nil) 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 Eljárás BalraIlleszt(vált mihez:binfa; konst mit:binfa) Ha mihez^.bal=nil akkor mihez^.bal:=mit Függvény BalGyerek(f:BinFa):BinFa Ha f<>nil akkor BalGyerek:=f^.bal kül. BalGyerek:=Nil Függvény GyökérElem(f:BinFa):ElemTip Ha f<>nil akkor GyökérElem:=f^.adat kül. GyökérElem:=Y0 Eljárás GyökérMódosit(vált f:binfa; konst e:elemtip) Ha f<>nil akkor f^.adat:=e 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

52 52 Programozás-elmélet K.L. 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)) Eljárás BJK(f:BinFa) Ha nem Üres-e?(f) akkor BJK(BalGyerek(f)) BJK(JobbGyerek(f)) Feldolgoz(GyökérElem(f)) Eljárás KBJ(f:BinFa) Ha nem Üres-e?(f) akkor Feldolgoz(GyökérElem(f)) KBJ(BalGyerek(f)) KBJ(JobbGyerek(f))

53 Programozás-elmélet K.L. 53 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)) i:=1 BKJ(f) FaTörlés(f) 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) kül. Ha Üres-e?(JobbGyerek(f)) akkor JobbraIlleszt(f,EgyelemüFa(e)) kül. HelyKeres(JobbGyerek(f),e) Eljárás BKJ(f:BinFa) Ha nem Üres-e?(f) akkor BKJ(BalGyerek(f)) Feldolgoz(GyökérElem(f)) BKJ(JobbGyerek(f)) Eljárás Feldolgoz(e:ElemTip) X(i):=e i:=i+1

54 54 Programozás-elmélet K.L. 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 VeremÜrit Eljárás NyitóigKivesz Ciklus amig Tetö(v)<>'(' Veremből(v,le) Sorba(PostFix,le) Veremböl(v,le) 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) Verembe(v,le) 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

55 Programozás-elmélet K.L. 55 Eljárás VeremÜrit Ciklus amig nem Üres-e?(v) Veremböl(v,le) Sorba(PostFix,le) 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) Veremböl(v,Eredm) 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

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

57 Programozás-elmélet K.L. 57 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) 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 Veremből(v,(p,él)) él:=él+1 Mígnem Üres-e?(v) és él>fokszám(g,x)

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