VIITMUUTUJA. ARVUTI MÄLU PAINDLIK KASUTAMINE

Transcription

1 VIITMUUTUJA. ARVUTI MÄLU PAINDLIK KASUTAMINE SISSEJUHATUS Selle teema raames tutvustan ma Teile üht omapärast andmeobjekti VIITMUUTUJAT. Selleks, et järgnevast jutust hästi aru saada, tuleb meelda tuletada teises teemas käsitletud jutt MÄLU kohta. Kõik senivaadeldud andmeobjektid on olnud STAATILISED. Staatiline andmeobjekt tuleb programmis kirjeldada: talle peab andma nime ja tüübi. Programmi täitmise ajaks eraldatakse muutuja väärtuse hoidmiseks teatud osa arvuti mälust ja seotakse muutuja sellega mäluaadressi abil. Muutuja tüüp määrab väärtuse esitamiseks vajaliku mäluhulga ning muutujaga teostatavad operatsioonid. Muutujale viitamiseks kasutatakse tema nime. Programmeerijal pole võimalust muuta nime ja mäluaadressi vahelist seost. VIITMUUTUJA OLEMUS Keeltes Pascal ja C on olemas võimalus tekitada andmeobjekte ka alles programmi täitmise käigus dünaamiliselt. DÜNAAMILISE muutuja seostamiseks mäluaadressiga kasutatakse viitmuutujat. VIITMUUTUJA ehk lühemalt öeldes VIIT on andmeobjekt, millesse saab salvestada mingi teise andmeobjekti mäluaadressi. Viitmuutuja kirjeldamisel peab määrama ka selle poolt viidatava andmeobjekti tüübi. Lisaks dünaamilistele muutujatele võib viit viidata ka harilike muutujate peale. Viitmuutuja väärtus võib olla üks kolmest võimalikust: 1) viit on väärtustamata ja väärtus on juhuslik suurus; 2) väärtuseks on omistatud mäluaadress; 3) väärtuseks on omistatud "TÜHI VÄÄRTUS". Vaatame järgnevat tabelit: Aadress Muutujanimi Tüüp Väärtus A Täisarv B Täisarv VA Viit TÜHI 0009 VB Viit Meil on defineeritud kaks täisarvulist muutujat ja kaks viitmuutujat. Esimesele viidale VA on omistatud väärtuseks "TÜHI", mis tähendab, et see viit ei viita mitte millelegi. Harilikult on selliseks "TÜHJAKS" väärtuseks 0, kuid see sõltub konkreetsest keelest. Teisel viitmuutujal VB on väärtuseks 0003, mis on samal ajal ka muutuja B aadressiks. Sellisel juhul võib öelda, et viit VB viitab muutujale B.

2 Kujutame kirjeldatud muutujaid joonisega: A B < VA VB Milleks on meil vaja viidata "tühjusesse" või teisele muutujale? Asi on nimelt selles, et kasutades viita võib viidatava muutujaga teha neid samu operatsioone, mis on lubatud hariliku muutuja korral. Lisaks sellele on samas programmilõigus viida väärtust muutes võimalik opereerida mitmete erinevate muutujatega. Selleks kasutatakse spetsiaalset viitamise operaatorit. Viitmuutujate olemuse selgitamiseks on kasutatav ka järgmine mudel: 1) kogu arvuti mälu on üks suur massiiv nimega M, mille väikseim indeks on 1; 2) viitmuutuja VM on selle massiivi indeksit hoidev muutuja; 3) meid huvitava mälupesa indeksi väärtuse omistame viidale VM; 4) meid huvitava mälupesa ehk massiivi element on seega M[VM]. VIITMUUTUJA KASUTAMINE Vaatame järgnevalt, kuidas saab viitmuutujat kasutada. Selleks teeme läbi sarnased tegevused keeles Pascal ja C. Keeles QBasic viitmuutujat ei ole. Viitmuutuja kasutamine keeles Pascal Kõigepealt tuleb viitmuutuja deklareerida, kusjuures märk '^' koos tüübinimetusega tähistab viitmuutuja tüüpi. Var lp : ^Integer; ^Integer - viit täisarvu peale Kui tegeletakse viitmuutujale mingi väärtuse omistamisega, siis toimitakse sarnaselt hariliku muutujaga, kuid väärtus peab olema aadress. lp := Nil; Nil - Pascali identifikaator TÜHJA väärtuse tähistamiseks Kui soovitakse omistada viitmuutujale mõne olemasoleva muutuja X aadressi, siis on selleks kaks võimalust: või lp := Addr(X); funktsioon Addr tagastab muutuja X aadressi - aadressi määramise operaator Viitmuutuja kasutamise näiteks kirjutame väikese programmi: Program N8_1_P;

3 Type PInt = ^Integer; defineerime viida tüübi Var A, B : Integer; P : PInt; P viit paigaldatakse muutuja A peale Write('Palun sisesta arv : '); Read(A); Writeln('Tore, sain kätte arvu ',P^); arvu saab kätte ka viida abil Write('Palun sisesta teine arv : '); Read(B); if P^ > B then ehk kui A > B P paigaldame viida muutuja B peale Writeln('Nendest arvudest väiksem on ',P^); end. Nagu näitest näha võis, kasutatakse aadressi järgi viitamiseks viitmuutujat, millele järgneb vahetult märk '^'. Selline programm on muidugi teostatav ka lihtsamalt, kuid see demonstreerib viida kasutamise võimalusi. Dünaamiliste muutujate kasutamine on aga ilma viitmuutujata raske kui mitte lausa võimatu. Aga sellest tuleb juttu allpool. Viitmuutuja kasutamine keeles C Viitmuutujate tähistamine keeles C on mõnevõrra segadusttekitav, sest selleks kasutatakse märki '*', mis langeb kokku korrutamise operaatoriga. Seega on oluline jälgida, et ei tekiks kahemõttelisust ja sinna, kus selline oht on olemas, tuleb panna sulud. Viitmuutuja deklareerimine käib järgmiselt: int *lp; /* lp on viit täisarvu peale */ Tühja väärtuse määramine viidale toimub kas arvu 0 või eeldefineeritud konstandi NULL (mis harilikult on pikk täisarv 0 ehk (long int)(0)) omistamisega: lp = NULL; Olemasoleva muutuja X aadressi omistamine viidale toimub operaatori '&' abil: lp = &X; Ja kirjutame eespool esitatud programmi keele C: /* N8_1_C */ #include <stdio.h> main() int A, B, *P; P = &A; /* viit paigaldatakse muutuja A peale */ printf("palun sisesta arv : "); scanf("%d", &A); /* ka sisestamise funktsioon kasutab aadressi! */ printf("tore, sain kätte arvu %d\n", *P); /* kasutame viita */ printf("palun sisesta teine arv : "); scanf("%d", &B); if (*P > B) /* ehk kui A > B */ P = &B; /* paigaldame viida muutuja B peale */ printf("nendest arvudest väiksem on %d\n", *P); return 0; /* lõpp */

4 MÄLU PAINDLIK KASUTAMINE Ei ole harvad sellised ülesanded, mida saab täita mitmes osas ja millest iga osa vajab suurt hulka mälu. Kui lahendada ülesanne staatiliste muutujatega, see tähendab selliste muutujatega, mille jaoks reserveeriti mälu programmi töö alguses ja nad eksisteerivad kuni programmi lõppemiseni, siis võib meil mälust puudus tulla. Üks võimalik lahendusvariant on selline, et vajaminevad muutujad luuakse vahetult enne seda, kui neid kasutama hakatakse ja siis, kui neid enam vaja ei ole, kaotatakse nad ära. Selliseid muutujaid nimetataksegi DÜNAAMILISTEKS MUUTUJATEKS. Mälu hõivamine Dünaamilise muutuja tekitamine algab muutuja jaoks mälu küsimisega. Mälu võib küsida, andes ette konkreetse arvu (baitides) või andmetüübi. Kui küsitud hulk vaba mälu on veel olemas, siis hõivatakse see ja vastav aadress omistatakse viitmuutujale. Mälu hõivamiseks on programmeerimiskeeles spetsiaalsed funktsioonid. Kindlasti eksisteerib konkreetse suurusega mäluala hõivamise funktsioon. Keeles Pascal on selleks protseduur GETMEM, mille deklaratsioon on järgmine: procedure GetMem(var P: Pointer; Suurus: Word); Kasutades seda protseduuri võib hõivata mälu 'Suurus' arv baite ja aadressi omistada viitmuutujale P. Tüüp 'Pointer' on puhas viidatüüp. Keeles C on selleks funktsioon MALLOC, mille deklaratsioon on järgmine: void *malloc( size_t suurus ); Funktsioon tagastab puhta viidatüüpi (void *) väärtuse 'suurus' arv baite sisaldavale mäluosale. Teine liik mälu hõivamise funktsioone on seotud konkreetse andmetüübiga. Keeles Pascal on selleks protseduur New: procedure New(var P: Pointer); See protseduur uurib järele viida P tegeliku tüübi ja eraldab mälu vastavalt tüübi suurusele. Näiteks täisarvu viida tüübi korral eraldatakse mälu ühe täisarvu hoidmiseks. Keeles C "tüübiga" mäluhõivamist ei ole, see on lisatud keele C++ süntaksile. Võib tekkida küsimus, et "mis saab siis, kui vaba mälu ei ole?". Programmi käitumine sellises situatsioonis sõltub keelest ja translaatori versioonist. Pascali puhul võib ette tulla nii väärtuse 'Nil' tagastamist kui ka veateadet. Keeles C on üldiselt tavaks tagastada tühi väärtus, mida saab sellisel juhul kontrollida ja valida vastav käitumine. Mälu vabastamine Kui dünaamilised muutujad on oma töö teinud, siis on ilus nad ära kaotada ja vabastada nende jaoks hõivatud mälu. Selle jaoks on olemas vastavad protseduurid. Keeles Pascal on nendeks:

5 procedure FreeMem(var P: Pointer; Suurus: Word); procedure Dispose(var P: Pointer ); FreeMem vabastab GetMem'iga hõivatud mälu, kusjuures arv 'Suurus' peab olema sama, ja Dispose vabastab protseduuriga New hõivatud mälu. Keeles C on mälu vabastamiseks funktsioon FREE: void free(void *viit); Vaatame siinkohal samasisulisi näiteprogramme nii Pascalis kui ka C s, kus toimub mälu hõivamine ja vabastamine. Ü l e s a n n e: Sisestada üks rida teksti ja leida reas olevate tühikute arv. Program N8_2_P; Var S : ^String; viitmuutuja i, n : Integer; Writeln('Palun sisesta üks rida teksti:'); GetMem(S, 81); küsime 81 baiti mälu Readln(S^); kasutades viita loeme sellesse mällu sisestatava rea n := 0; n on tühikute loendur, algväärtuseks on 0 For i := 1 to Length(S^) do vaatame kõiki märke reas If S^[i] = ' ' then ja kui märk on tühik n := n + 1; siis suurendame loendurit ühe võrra FreeMem(S, 81); vabastame eelnevalt hõivatud 81 baiti mälu Writeln('Selles reas on ', n, ' tühikut.'); end. /* N8_2_C */ #include <stdio.h> #include <malloc.h> #include <string.h> main() char *S; /* viitmuutuja */ unsigned i, n; /* märgita täisarvud */ printf("palun sisesta üks rida teksti:\n"); S = malloc(81); /* küsime 81 baiti mälu */ if(s == NULL) /* kontrollime, kas mälu saime */ printf("nii palju vaba mälu ei ole!\n"); else /* kui saime mälu, siis */ gets(s); /* sisestame ühe rea teksti */ n = 0; for(i=0; i<strlen(s); i++) /* loeme kokku tühikud */ if(s[i] == ' ') n++; free(s); /* vabastame mälu ja teatame tulemuse */ printf("selles reas on %d tühikut\n", n); return 0; Kes tahab, võib proovida funktsiooni scanf() rea sisestamiseks. Saate kogemuse võrra rikkamaks.

6 TÜÜPILISED KOMISTUSKIVID Ka kõige kogenenumad programmeerijad teevad eksimusi (see on ju inimlik) ja suur osa nendest eksimustest langeb dünaamiliste muutujate kasutamise alale. Püüaks siinkohal üles loetleda tüüpilised komistuskivid, et Te teaksite nende eest hoiduda. 1. Hõivatud mälu ei vabastata. Seda juhtub mitmesugusel viisil: vabastatakse vähem kui hõivati; peale mälu hõivamist ja viidaga seostamist kasutatakse viita teisel otstarbel enne, kui mälu vabastatakse (üldiselt läheb see mittevabastamise kategooria alla); mälu vabastamine jääb üldse ära. Sellise vea tunnuseks on vaba mälu pidev vähenemine, kuni see lõpuks otsa saab. Paljudel juhtudel lõpeb see vastava veateatega. Muide, on täheldatud, et mõningaid laiatarbeprogramme ei saa mitu korda järjest välja kutsuda, sest iga kasutamisega läheb jupp mälu kaduma ja varsti on vaja arvuti algkäivitada. 2. Viitamisel püütakse kasutada väärtustamata või 'tühja' väärtusega viitmuutujat. Sõltub keskkonnast, kuid tulemuseks võib olla veateade "General protection fault" või midagi muud sellesarnast. Selline viga on tüüpiline programmidele, kus ei kontrollita mälu hõivamise õnnestumist. 3. Ei jälgita hõivatud mälu piire ja minnakse "üle ääre". Selline võimalus on viitade kasutamise korral täiesti olemas ja võib põhjustada väga raskesti leitavaid vigu, kuna vea põhjus asub ühes ja tagajärg hoopis teises kohas ning tagajärjed on väga erinevad. 4. Püütakse vabastada mälu, mis on juba vabastatud. See on küll veider viga, aga siiski tuleb seda ette. Tihtipeale on põhjuseks see, et pärast mälu vabastamist ei omistata viidale 'tühja' väärtust ja mingil hilisemal hetkel püütakse vabastamise protseduuri läbi viia sellepärast, et viit ei oma 'tühja' väärtust. DÜNAAMILISED ANDMESTRUKTUURID Eespool toodud näiteprogrammid olid rohkem viitmuutuja ja mäluga opereerimise olemuse selgitamiseks. Selliste lihtsate ülesannete jaoks dünaamilisi muutujaid harilikult ei kasutata. Tegelik vajadus tekib siis, kui hakata kasutama dünaamilisi andmestruktuure. Mis need on? Toome ühe elulise näite. Oletame, et eksisteerib järjekord arsti juurde ja meil on vaja opereerida selle järjekorra andmetega. Iga inimese andmed moodustavad selles järjekorras ühe ühiku. Inimese seisukohast vaadatuna toimub järjekorras olemine niimoodi, et inimene tuleb vastuvõturuumi ja nähes seal teisi inimesi, esitab küsimuse "Kes on viimane?". Seejärel jätab talle vastanud inimese näo meelde ja on valmis järgmisele küsimuse esitajale vastama, et tema ongi viimane selles järjekorras. Pärast seda, kui tema järele tuleb vähemalt üks inimene, jälgib ta ainult seda, millal tema ees olev isik vastu võetakse. Kui see juhtub, siis ta teab, et on nüüd järjekorras esimene. Kui arsti ukse vahelt hõigatakse "Järgmine!", siis on tema kord sisse minna. Kui järjekorda pidada arvuti abil, siis tuleb inimese saabudes küsida tema nimi ja arsti juurde kutsumine toimub nime järgi. Või teine võimalus, igale saabunule antakse number ja sisse

7 kutsutakse numbrite järgi (mis ei pea tingimata olema järjestikulised). Ahel ja järjekord Põhilised probleemid sellise ülesande jaoks programmi kirjutamisel on seotud sellega, et järjekord võib teoreetiliselt olla lõpmatult pikk ja igasugune massiiv võib täis saada. On olemas muidugi füüsiline piir arvuti vaba mälu näol, millest ei saa kuidagi üle ega ümber, kuid olemasoleva mälu optimaalne ärakasutamine on siiski võimalik. Selleks on vaja kasutada andmestruktuuri, mida nimetatakse AHELAKS. Lisades andmestruktuurile mõned tegevused, saab formeerida ühe ahela erikuju JÄRJEKORRA. Mida saab järjekorraga teha? Millised on need tegevused, mis teevad lihtsast ahelast järjekorra? Need tegevused on järjekorda lisamine ja järjekorrast väljavõtmine, kusjuures lisatakse alati järjekorra lõppu ning välja võetakse järjekorra algusest. Teeme mõned joonised: <--- 1 <--- 2 < See on esialgne järjekord. Iga LÜLI selles ahelas "teab", millise lüli järel ta on. Ainult esimene lüli ei ole ühegi teise järel. Lisame sellele järjekorrale ühe lüli juurde (olukord: saabus uus inimene): <--- 1 <--- 2 <--- 3 < Uus lüli lisati järjekorra lõppu. Võtame nüüd järjekorrast ühe lüli välja (olukord: inimene kutsuti arsti juurde): <--- 2 <--- 3 < Selleks, et leida kiiresti järjekorra esimene või viimane lüli, tuleb andmestruktuuril nende asukohad meeles pidada ning iga tegevuse juures tuleb neid kasutada ja vastavalt muuta <--- 2 <--- 3 < ^ ^ esimene viimane Eksisteerib veel üks eriline olukord, mida peab spetsiaalselt käsitlema. See on olek, kus järjekorras ei ole ühtegi inimest järjekord on tühi. Järgnevalt esitan ma programmi, mis aitab pidada järjekorda numbrite abil. Program N8_3_P; Type PLyli = ^Lyli; Järjekorra lüli viidatüüp Lyli = record Kirje järjekorra lüli info hoidmiseks Number : LongInt; Järjenumber Eelmine : PLyli; Viit eelmisele lülile Jarjekord = record Kirje järjekorra info hoidmiseks

8 Esimene : PLyli; Viit järjekorras esimesele Viimane : PLyli; Viit järjekorras viimasele Var JK : Jarjekord; V : Char; LV : PLyli; Viit lülile N : LongInt; JK.Esimene := Nil; Alguses ei ole järjekorras ühtegi lüli JK.Viimane := Nil; Writeln('Alustame järjekorra pidamist'); Repeat Write('Järgmine tegevus [L-Lisada, V-Välja vôtta, Q-Lôpetada]: '); Readln(V); Loeme sisse tegevuse valiku V := UpCase(V); Muudame sisseloetud tähe suureks täheks Case V Of 'L' : Kui oli valitud lisamine New(LV); teeme uue lüli tüüpi dünaamilise muutuja Write('LISAMINE. Palun järgmine number : '); Readln(LV^.Number); loeme sisse uue lüli numbri, LV^.Eelmine := JK.Viimane; "näitame" seni viimast lüli JK.Viimane := LV; ja paneme ta järjekorda viimaseks If JK.Esimene = Nil Then Juhul, kui järjekorras esimest JK.Esimene := LV; ei ole, paneme ta ka esimeseks 'V' : Kui oli valitud väljavõtmine If JK.Esimene <> Nil Then ja kui järjekorras on lülisid, siis ütleme esimese lüli numbri Writeln('VÄLJAVôTMINE. Number on ', JK.Esimene^.Number); If JK.Esimene = JK.Viimane Then Kui esimene on ühtlasi viimane LV := JK.Viimane; siis jätame selle meelde ja JK.Esimene := Nil; kuulutame järjekorra tühjaks JK.Viimane := Nil; end Else Kui aga järjekorras on veel lülisid, siis otsime üles järjekorras teise LV := JK.Viimane; liikudes viimase suunast While LV^.Eelmine <> JK.Esimene Do LV := LV^.Eelmine; ettepoole. JK.Esimene := LV; Paneme teise esimeseks ja LV := LV^.Eelmine; jätame esimese meelde. JK.Esimene^.Eelmine := Nil; Esimesel ei ole eelmist! Dispose(LV); Meeldejäetud lüli vabastame end ja saame mälu tagasi. Else Writeln('VÄLJAVôTMINE. Järjekord on tühi.'); 'Q' : Kui on valitud lõpetamine, siis LV := JK.Viimane; If JK.Esimene <> Nil Then kontrollime, kas järjekord on tühi ja kui ei ole, siis N := 0; While LV <> Nil Do loeme lülid kokku N := N + 1; LV := LV^.Eelmine;

9 ja küsime lõpetamise kinnitust. Write('LôPETAMINE.'); Writeln(' Järjekorda on jäänud veel ',N,' inimest.'); Write('Kas tahad tôesti lôpetada [J/E]? '); Readln(V); V := UpCase(V); If V = 'J' Then Kui kinnitati lõpetamist, siis V := 'Q'; lõpetamise tunnus püsti. If V = 'Q' Then Kui lõpetamine ja LV := JK.Viimane; While LV <> JK.Esimene Do järjekorras on veel lülisid, JK.Viimane := LV^.Eelmine; Dispose(LV); siis tuleb ka need vabastada. LV := JK.Viimane; Dispose(LV); See viimane ka! end Until V = 'Q'; Writeln('Lôpetame järjekorra pidamise'); end. Sama programm keeles C : /* P r o g r a m m i a l g u s */ #include <stdio.h> #include <malloc.h> #include <ctype.h> struct lyli /* kirje järjekorra lüli info hoidmiseks */ int number; /* järjenumber */ struct lyli *eelmine; /* viit eelmisele lülile */ ; struct jarjekord /* kirje järjekorra info hoidmiseks */ struct lyli *esimene; /* viit järjekorras esimesele */ struct lyli *viimane; /* viit järjekorras viimasele */ ; int main() struct jarjekord jk; jk.esimene = NULL; /* alguses ei ole järjekorras ühtegi lüli */ jk.viimane = NULL; int n; struct lyli *lv; /* viit lülile */ printf("alustame järjekorra pidamist\n"); char v; do printf("järgmine tegevus [L-Lisada, V-Välja võtta, Q-Lõpetada]: "); scanf("%s", &v); /* loeme sisse tegevuse valiku */ v = toupper(v); /* muudame sisseloetud tähe suureks täheks */ if (v == 'L') /* kui on valitud lisamine */ lv = (lyli*)malloc(sizeof(struct lyli)); /* teeme uue lüli tüüpi dünaamilise muutuja */ printf("lisamine. Palun järgmine number : "); scanf("%d", &lv->number); /* loeme sisse uue lüli, */ lv->eelmine = jk.viimane; /* "näitame" seni viimast lüli */ jk.viimane = lv; /* ja paneme ta järjekorda viimaseks */

10 */ if (jk.esimene == NULL) /* juhul kui järjekorras esimest ei ole, */ jk.esimene = lv; /* siis paneme ta esimeseks */ else if (v == 'V') /* kui on valitud väljavõtmine */ if (jk.esimene!= NULL) /* ja kui järjekorras on lülisid, */ /* siis ütleme esimese lüli numbri */ printf("väljavõtmine. Number on %d\n", jk.esimene->number); if (jk.esimene == jk.viimane) /* Kui esimene on ühtlasi viimane, */ lv = jk.viimane; /* siis jätame selle meelde */ jk.esimene = NULL; /* kuulutame järjekorra tühjaks */ jk.viimane = NULL; else /* Kui aga järjekorras on veel lülisid, siis /* otsime üles järjekorras teise */ lv = jk.viimane; /* liikudes viimase suunast */ while (lv->eelmine!= jk.esimene) lv = lv->eelmine; /* ettepoole */ jk.esimene = lv; /* paneme teise esimeseks ja */ lv = lv->eelmine; /* jätame esimese meelde */ jk.esimene->eelmine = NULL; /* esimesel ei ole eelmist */ free(lv); /* meeldejäetud lüli vabastame ja saame mälu tagasi */ else printf("väljavõtmine. Järjekord on tühi.\n"); else if (v == 'Q') /* Kui on valitud lõpetamine, siis */ lv = jk.viimane; if (jk.esimene!= NULL) /* kontrollime, kas järjekord on tühi */ /* ja kui ei ole, siis */ n = 0; while (lv!= NULL) /* loeme lülid kokku */ n++; /* suurendame n ühe võrra */ lv = lv->eelmine; printf("lõpetamine."); /* küsime lõpetamisele kinnituse */ printf(" Järjekorda on jäänud veel %d inimest.\n", n); printf("kas tõesti tahad lõpetada [J/E]? "); scanf("%s", &v); v = toupper(v); if (v == 'J') v = 'Q'; if (v == 'Q') /* Kui lõpetamine ja */ lv = jk.viimane; while (lv!= jk.esimene) /* järjekorras on veel lülisid */ jk.viimane = lv->eelmine; free(lv); /* siis tuleb ka need vabastada */ lv = jk.viimane; free(lv); /* see viimane ka */ while (v!= 'Q'); printf("lõpetame järjekorra pidamise");

11 return 0; /* P r o g r a m m i l õ p p */ Pinumälu ehk magasinmälu Teine AHELA eriliik on PINUMÄLU, mida nimetatakse ka MAGASINIKS. See tuleneb sarnasusest automaadi magasiniga. Kes pole magasini näinud, siis selgituseks kõlbab ka selline mündihoidja, millel on vedru all ja kuhu saab münte pealtpoolt sisse panna ja samuti välja võtta. Sellisel "mündimagasinil" ja automaadimagasinil on üks ühine omadus selle mündi või padruni, mis sinna esimesena sisse pandi, saadakse kätte kõige viimasena ja vastupidi. Viimane ese jääb kõige peale ja saadakse esimesena kätte. See on magasini põhimõte. Pinumälu kui andmestruktuur on kasutusel väga mitmete ülesannete lahendamisel. Lihtsaimaks ülesandeks, mille jaoks võib kirjutada programmi, on andmejada ümberpööramise ülesanne. Oletame, et sisestatakse järjest uusi andmeid ning arv 0 tähistab andmejada lõppu. Seejärel on vaja väljastada kõik sisestatu vastupidises järjekorras. Jada liikmete arv ei ole ette teada. /* N8_4_C */ #include <stdio.h> #include <malloc.h> #include <string.h> struct Lyli char *Liige; struct Lyli *Jargmine; ; main() struct Lyli *Pinu, *LV; char S[80]; Pinu = NULL; printf("jada liikmeteks võivad olla suvalised tekstiread.\n"); printf("lõpu tunnuseks on 0.\n\n"); printf("alustan jada sisestamist\n"); do printf(">"); gets(s); /* loeme sisse jada liikme */ if (strcmp(s, "0")) /* kontrollime, ega see pole lõpp */ LV = malloc(sizeof(struct Lyli)); /* võtame lüli jaoks mälu */ if (LV!= NULL) /* kui saime, siis */ /* küsime ka liikme jaoks mälu */ LV->Liige = malloc(strlen(s)+1); if (LV->Liige!= NULL) strcpy(lv->liige, S); /* salvestame liikme info */ LV->Jargmine = Pinu; /* ja paneme lüli kõige "pealmiseks" */ Pinu = LV; else /* kui liikme info jaoks mälu ei jätkunud */ free(lv); /* siis vabastame ka lüli */ LV = NULL;

12 while (strcmp(s, "0") && LV!= NULL); if (LV == NULL) printf("mälu sai otsa.\n"); printf("alustan väljastamist\n"); LV = Pinu; while (LV!= NULL) printf("%s\n", LV->Liige); /* väljastame liikme info, */ Pinu = LV->Jargmine; /* võtame järgmise pealmiseks */ free(lv->liige); /* ja vabastame juba väljastatud lüli */ free(lv); LV = Pinu; printf("see on kõik!\n"); return 0; Selles näites on kasutatud kaheetapilist mäluvõtmist kõigepealt pinumälu lülile ja siis jadaliikme infole. Järgmine joonis annab sellisest struktuurist hea ülevaate: Pinu V > 3 ---> 2 ---> 1 ---> V V V V Info Info Info Info Ja nüüd sama programm keeles Pascal : P r o g r a m m i a l g u s Program N8_4_P; type PLyli = ^Lyli; Lyli = record Liige : ^string; Jargmine : PLyli; var Pinu, LV : PLyli; S : string[80]; Pinu := nil; Writeln('Jada liikmeteks võivad olla suvalised tekstiread.'); Writeln('Lõpu tunnuseks on 0.');writeln; Writeln('Alustan jada sisestamist'); Repeat Write('>');Readln(s); loeme sisse jada liikme If S <> '0' then kontrollime, ega see pole lõpp New(LV); võtame lüli jaoks mälu if LV <> nil then kui saime, siis küsime ka liikme jaoks mälu GetMem(LV^.Liige, length(s)); If LV^.Liige <> nil then LV^.Liige^ := S; salvestame liikme info

13 pealmiseks jätkunud LV^.Jargmine := Pinu; ja paneme lüli kõige Pinu := LV; end else kui liikme info jaoks mälu ei Dispose(LV); siis vabastame ka lüli LV := nil; Until (S = '0') or (LV = nil); If LV = nil then Writeln('Mälu sai otsa!'); Writeln('Alustan väljastamist'); LV := Pinu; While LV <> nil do Writeln(LV^.Liige^); väljastame liikme info, Pinu := LV^.Jargmine; võtame järgmise pealmiseks FreeMem(LV^.Liige, length(lv^.liige^)); ja vabastame juba väljastatud lüli Dispose(LV); LV := Pinu; Writeln('See on kõik.'); end. P r o g r a m m i l õ p p Selle peatüki materjalide peale on "Kodutöö nr. 8"