C++ permbledhje detyrash-v-neziri-r-dervishi-fiek

Përmbledhe detyrash në C++ (2)

Vehbi Neziri Ramadan Dervishi

Prishtinë, 2013 www.e-Libraria.com

Vehbi Neziri & Ramadan Dervishi Përmbledhje detyrash në C++

1

UNIVERSITETI I PRISHTINËS

Fakulteti i Inxhinierisë Elektrike dhe Kompjuterike

Vehbi Neziri Ramadan Dervishi

Përmbledhje detyrash në C++ (2)

Prishtinë, 2013 www.e-Libraria.com


2

Vehbi Neziri ka një përvojë të gjatë në programim, dhe tashmë ka realizuar një mori projektesh kombëtare dhe ndërkombëtare në fushën e programimit. Vehbiu mban titullin Master i Shkencave të Inxhinierisë Kompjuterike dhe është asistent i angazhuar në Fakultetin e Inxhinierisë Elektrike dhe Kompjuterike në Universitetin e Prishtinës. Ramadan Dervishi ka një përvojë të gjatë në fushën e programimit, dhe si autor dhe bashkautor ka realizuar një mori projektesh kombëtare dhe ndërkombëtare që lidhen me teknologjinë e informacionit. Ramadani mban titullin Master i Shkencave të Inxhinierisë Kompjuterike dhe është mësimdhënës në kolegjin Riinvest.

www.e-Libraria.com


3

Na thoni mendimin tuaj! Si lexues i kësaj përmbledhjeje, ju jeni kritik dhe komentues i rëndësishëm për ne. Ne vlerësojmë mendimin tuaj dhe duam të dimë, se: çfarë kemi bërë drejt, çfarë mund ta bëjmë më mirë, cilat janë fushat e interesit tuaj që ne të publikojmë ose edhe sugjerime të tjera. Komentet juaja janë të mirëpritura. Ju mund të na shkruani drejtpërdrejt në adresën tonë të emailit duke na e bërë të qartë, se: çfarë kemi bërë mirë dhe çfarë nuk ju pëlqen e që mund ta bëjmë më mirë në mënyrë që edicionet e ardhshme të jenë më të mira. Kontakti: Vehbi Neziri: vehbi.neziri@uni-‐pr.edu Ramadan Dervishi: [email protected]

www.e-Libraria.com

mailto:[email protected]

mailto:[email protected]


4

Kjo përmbledhje detyrash elektronike është përgatitur duke u bazuar në

struktura e të dakademik 2012/2013 në Fakultetin e Inxhinierisë Elektrike dhe Kompjuterike të Universitetit të Prishtinës. Përmbledhja, në rend të parë, do t ju shërbejë studentëve të këtij fakulteti, por gjithsesi që mund të jetë ndihmesë edhe për të tjerët. Dua të shpreh mirënjohjen për studentët e Fakultetit të Inxhinierisë Elektrike dhe Kompjuterike të Universitetit të Prishtinës të cilët kanë ndjekur ushtrimet në Algoritmet dhe struktura e të dhënave gjatë semestrit veror (2012/2013). Me një pjesë prej tyre pata fatin të mbaj ushtrimet bashkërisht , prandaj i falënderoj për sugjerimet dhe reagimet pozitive që kanë bërë, si në takimet e përbashkëta e po ashtu edhe përmes emailit.

Vehbi Neziri Prishtinë, maj 2013.

www.e-Libraria.com


5

Pasqyrë e shkurtër e secilit kapitull Funksionet Në këtë pjesë janë përfshirë shembuj të përgjithshëm të funksioneve, të funksioneve të paracaktuara, të funksioneve të caktuara nga përdoruesi, të funksioneve që kthejnë vlerë dhe atyre që nuk kthejnë vlerë, të funksioneve inline, makrofunksioneve dhe funksioneve të mbingarkuara. . Sinonimet Në këtë pjesë ka shembuj përmes të cilëve tregohet se si mund të deklarohen sinonimet për tipat e të dhënave. Numërimet (enumerations) Në këtë pjesë janë përfshirë shembuj të zgjidhur të detyrave me grupime/numërime. Është treguar se si të përcaktohet dhe të shfrytëzohet një grup, pastaj degëzimi i vlerave të numëruara, shoqërimi i vlerave të mënyrës direkte, operimi me variabla të numëruara dhe të dhënat e numëruara në funksione. Strukturat Në këtë pjesë tregohet se si të krijohet një strukturë e zakonshme, deklarimi i variablave të tipit të strukturës, qasja në anëtarët e strukturës, deklarimi dhe inicimi direkt i variablave. Tregohet dhe ka shembuj se si të ruhen rezultatet e ndryshme në strukturë, si dhe shembuj me operatorët e shoqërimit dhe ata relacionalë. Ka shembuj për strukturat e ndërthurura, strukturat si parametra të funksioneve, fushat në struktura dhe fushat e strukturave. Klasat Ky kapitull përmban shembuj të ndryshëm për klasat duke filluar prej krijimit të një klase të zakonshme, deklarimin e objekteve, mënyrat e qasjes tek anëtarët e klasës dhe format e përgjithshme të klasave. Po ashtu tregohet se si të përdoren funksionet brenda klasave, tregohet dhe ka shembuj për konstruktorët dhe destruktorët e klasës. Trashëgimia zë një vend të rëndësishëm tek klasat, prandaj është trajtuar edhe trashëgimia, shfrytëzimi i anëtarëve të mbrojtur ose protected, operatorët e shoqërimit, krahasimi i objekteve, fushat brenda klasave dhe krijimi i fushave duke përdorur objektet.

www.e-Libraria.com


6

Pointerët Në këtë kapitull ka shembuj dhe ilustrime se si të deklarohet një pointer, adresat e pointerëve, përdorimi dhe shoqërimi i vlerës së pointerit, operimet e ndryshme me pointerë, operatori new dhe delete. Po ashtu ka shembuj për fushat e pointerëve, pointerët në funksione, pointerët në anëtarët e strukturave dhe klasave/ Referencat Në këtë kapitull gjenden shembuj të ndryshëm se çka janë referencat, për çka nevojiten dhe si përdoren. Tregohet për referencat e zakonshme, parametrat referentë, si parametra formalë të funksioneve, fushat referente, parametrat referentë brenda anëtarëve të strukturave dhe të klasave. Fajllat Ky kapitull ka shembuj të ndryshëm për punën me fajlla. Tregohet se çka janë fajllat me qasje sekuenciale dhe çka janë fajllat me qasje direkte. Tregohet se si të ruhen të dhënat e tipave të ndryshëm në këta fajlla dhe si të lexohen të dhënat nga fajllat. Përmes shembujve është demonstruar se cilët janë dhe si mund të hapet fajlli në mode të ndryshme të punës.

www.e-Libraria.com


7

Përmbajtja Ambientet dhe veglat e punës ....................................................................................................... 11 Krijimi i një projekti të zbrazur në Visual C++ ......................................................... 11 Shtimi i një skedari të ri .cpp në projekt ............................................................... 14

Krijimi i një projekti të ri në CodeBlocks .................................................................... 16 1. Funksionet .................................................................................................................................. 20 1.1. Funksionet e paracaktuara ......................................................................................... 21 1.2. Funksionet e caktuara nga përdoruesi ................................................................. 24

1.2.1. Funksionet që kthejnë vlerë ................................................................................. 25 1.2.2. Funksionet që nuk kthejnë vlerë ........................................................................ 31 1.3. Funksionet Inline ........................................................................................................... 34

1.4. Makro funksionet ............................................................................................................. 36 1.5. Funksionet e mbingarkuara ......................................................................................... 37

2. Sinonimet .................................................................................................................................... 42 3. Numërimet (enumerations) ................................................................................................... 45

3.1. Përcaktimi dhe shfrytëzimi i grupit ................................................................... 45 3.2. Degëzimi përmes vlerave të numëruara ................................................................. 47 3.3. Disa variabla të numëruara të tipit të njëjtë.............................................. 51 3.4. Përcaktimi dhe deklarimi njëkohësisht ............................................................... 52

3.5. Shoqërimi direkt i vlerave ....................................................................................... 54 3.6. Operimi me variabla të numëruara dhe leximi .................................................. 55 3.7. Krijimi i disa grupeve njëkohësisht ................................................................... 56 3.8. Të dhënat e numëruara në nënprograme ................................................................. 57

4. Strukturat .................................................................................................................................. 60 4.1. Krijimi i strukturave të zakonshme ...................................................................... 60 4.2. Deklarimi i variablave të strukturës ................................................................. 61 4.3. Qasja në anëtarët e strukturës .............................................................................. 61

4.4. Deklarimi direkt i variablës së strukturës .................................................... 62 4.5. Inicimi direkt i variablave ..................................................................................... 63 4.6. Llogaritje me variablat e strukturës ................................................................. 65 4.7. Ruajtja e të dhënave në strukturë ........................................................................ 68

4.8. Disa variabla të një strukture .............................................................................. 69 4.9. Përdorimi i operacionit të shoqërimit ............................................................... 71 4.10. Përdorimi i operatorëve relacionalë ............................................................... 73 4.11. Disa struktura njëkohësisht ................................................................................. 74

www.e-Libraria.com


8

4.12. Strukturat e ndërthurura........................................................................................ 75

4.13. Strukturat si parametra të funksioneve ......................................................... 78 4.14. Disa nënprograme njëkohësisht ............................................................................. 80 4.15. Funksionet në komponentët e strukturave ....................................................... 82 4.15.1. Pa parametra formalë ............................................................................................ 82

4.15.2. Me parametra formalë ............................................................................................ 83 4.16. Fushat në struktura .................................................................................................. 86 4.17. Fushat e strukturave ................................................................................................ 88

5. Klasat ........................................................................................................................................... 89

5.1. Krijimi i klasave të zakonshme .............................................................................. 89 5.2. Deklarimi i objekteve .................................................................................................. 89 5.3. Qasja në komponentët e klasës ................................................................................. 90 5.4. Forma e përgjithshme e klasave .............................................................................. 92

5.5. Shfrytëzimi i funksioneve brenda klasës ........................................................... 94 5.6. Forma të tjera të inicimit të variablave ........................................................ 95 5.7. Shfrytëzimi i vlerave të variablave private .................................................. 98 5.8. Llogaritjet me variabla të klasës ...................................................................... 100

5.9. Shfrytëzimi i funksioneve brenda klasës ......................................................... 101 5.10. Konstruktorët .............................................................................................................. 108 5.10.1. Konstruktorët pa parametra formalë ............................................................ 108 5.10.2. Konstruktorët me parametra formalë ............................................................ 110

5.11. Llogaritjet brenda konstruktorëve .................................................................. 112 5.12. Disa konstruktorë njëkohësisht ........................................................................ 115 5.13. Destruktorët ................................................................................................................ 116 5.14. Trashëgimia .................................................................................................................. 117

5.15. Anëtarët statik të klasës ................................................................................... 123 5.16. Shfrytëzimi i anëtarëve të mbrojtur protected ................................... 126 5.17. Shfrytëzimi i anëtarëve gjatë trashëgimisë .............................................. 128 5.18. Operatori i shoqërimit tek objektet ............................................................. 131

5.19. Krahasimi i objekteve të klasës ...................................................................... 132 5.20. Fushat brenda klasave ............................................................................................ 133 5.21. Krijimi i fushave duke përdor objektet ....................................................... 134

6. Pointerët .................................................................................................................................. 137

6.1. Deklarimi i pointerëve .............................................................................................. 137 6.2. Adresat e pointerëve .................................................................................................. 138 6.3. Përdorimi i vlerës së pointerit .......................................................................... 139 6.4. Shoqërimi i vlerave .................................................................................................... 140 6.5. Llogaritjet përmes pointerëve ............................................................................... 141 6.6. Operimi me pointerë .................................................................................................... 143

www.e-Libraria.com


9

6.7. Operatori new dhe delete.......................................................................................... 146

6.8. Pointerët const ............................................................................................................. 148 6.9. Pointerët dhe fushat .................................................................................................. 149 6.10. Ponterët stringje ..................................................................................................... 153 6.11. Fusha pointerësh ....................................................................................................... 153

6.12. Pointerët si parametra të funksioneve ......................................................... 155 6.13. Pointerët në funksione .......................................................................................... 157 6.14. Pointerët në struktura .......................................................................................... 159 6.15. Pointerët në objekte .............................................................................................. 161

7. Referencat ................................................................................................................................ 164 7.1. Referencat e zakonshme .............................................................................................. 164 7.2. Parametrat referentë .................................................................................................. 165 7.3. Fushat referente ........................................................................................................... 168

7.4. Parametrat referentë brenda anëtarëve të strukturave ............................ 169 7.5. Parametrat referentë brenda anëtarëve të klasave ..................................... 172 7.6. Objektet referente ....................................................................................................... 174

8. Fajllat ....................................................................................................................................... 176

8.1. Fajllat me qasje sekuenciale ................................................................................. 176 8.2. Qasja të fajllat në unazë ....................................................................................... 177 8.3. Tekstet dhe numrat në fajlla ................................................................................. 179 8.4. Shkrimi dhe leximi i karaktereve ........................................................................ 182

8.5. Leximi i rreshtave ....................................................................................................... 183 8.6. Mode të hapjes së fajllave ..................................................................................... 184 8.7. Pozita në fajll ............................................................................................................. 186 8.8. Fajllat me qasje direkte.......................................................................................... 187

8.9. Vlerat e fushave në fajlla ..................................................................................... 189 8.10. Objektet në fajlla ................................................................................................... 191

9. Pyetje dhe shembuj vetë-‐testues .................................................................................. 196 9.1. Funksionet ........................................................................................................................ 196

9.2. Numerimet .......................................................................................................................... 198 9.3. Sinonimet .......................................................................................................................... 199 9.4. Strukturat ........................................................................................................................ 199 9.5. Klasat ................................................................................................................................. 201

9.6. Pointerët .......................................................................................................................... 203 9.7. Referencat ........................................................................................................................ 204 9.8. Fajllat ............................................................................................................................... 205

Literatura ............................................................................................................................................ 208

www.e-Libraria.com


10

www.e-Libraria.com


11

Ambientet dhe veglat e punës Ekzistojnë vegla dhe programe të ndryshme që mundësojnë shkrimin e kodit burimor dhe kompajlimin e tij. Në këtë përmbledhje do të tregohet se si të punohet me Visual Studio.Net dhe me CodeBlocks. Krijimi i një projekti të zbrazur në Visual C++ Për ta hapur një projekt të ri në Visual Studio C++, duhet ta keni të instaluar ndonjërin nga versionet e Visual Studios. Shembulli i mëposhtëm tregon se si krijohet një projekt i ri në Visual Studio 2012 (është e ngjashme edhe në versionet e tjera) 1. Klikoni në ikonën e Visual Studios (menyja Start ose desktop)

2. Pasi të keni klikuar ikonën e Visual Studios do të hapet Visual Studio si

në pamjen e mëposhtme.

3. Në këndin e lartë majtas klikoni në menynë File/New/Project ose përmes

shkurtesave Ctrl+Shift+N dhe do të shfaqet një dritare dialoguese.

www.e-Libraria.com


12

4. Në kutinë dialoguese duhet të zgjidhni Win32 Console Application për të

krijuar një aplikacion të bazuar në konzolë.

5. Pasi të keni zgjedhur Win32 Console Application, duhet të emërtoni

projektin me një emër (tek fusha Name) dhe më pas klikoni butonin OK. 6. Visual Studio do të krijojë projektin në shtegun i cili është zgjedhur në

fushën Location. Do të shfaqet një dritare e cila ju dëshiron mirëseardhje. Klikoni butonin Next> për të vazhduar.

www.e-Libraria.com


13

7. Pasi keni klikuar Next do të shfaqet dritarja e mëposhtme. Në mënyrë që të

krijoni një projekt të zbrazur duhet të zgjidhni "Empty Project", në të kundërtën Visual Studio do të shtojë skedarë (file) të panevojshëm për ju.

8. Klikoni butonin Finish për të përfunduar me krijimin e projektit. Tani

ambienti punues do të duket si në dritaren e mëposhtme.

www.e-Libraria.com


14

Shtimi i një skedari të ri .cpp në projekt 1. Klikoni me tastin e djathtë mbi Source Files dhe zgjidhni Add / New Item.

2. Programi do të ju pyes se çfarë skedari dëshironi të shtoni. Zgjidhni që

dëshironi të shtoni C++ File (.cpp) dhe më pas klikoni butonin Add.

www.e-Libraria.com


15

3. Tashmë siç shihet në dritaren e mëposhtme, kutitë dialoguese janë hequr

dhe ju jeni të lirë për të filluar programin e parë në C++.

www.e-Libraria.com


16

Krijimi i një projekti të ri në CodeBlocks Për ta hapur një projekt të ri në CodeBlocks, duhet ta keni të instaluar njërin nga versionet e programit. Më poshtë janë përshkruar hapat se si të krijohet një projekt i ri. 1. Klikoni në ikonën e CodeBlocks (menyja Start ose desktop)

2. Pasi të keni klikuar ikonën e CodeBlocks do të hapet programi si në pamjen

e mëposhtme.

3. Në këndin e lartë majtas klikoni në menynë File/New/Project ose përmes

ikonës e cila gjendet në hapësirën punuese (Create a new Project) dhe do të hapet dritarja dialoguese.

4. Në kutinë dialoguese, zgjidhet Console application për të krijuar një aplikacion të bazuar në konzolë.

www.e-Libraria.com


17

9. Pasi është zgjedhur Console application, klikohet butoni butoni Go dhe do

të shfaqet dritarja e mëposhtme, e cila është një lloj magjistrati i cili na ndihmon për të krijuar një projekt të ri. Nëse dëshirohet që kjo faqe

Skip thus page next time

10. Në dritaren e mëposhtme zgjedhet opsioni i dëshiruar, në rastin tonë

zgjidhet C++.

www.e-Libraria.com


18

11. Pasi të jetë zgjedhur C++, klikohet butoni Next dhe më pas do të

shfaqet dritarja në të cilën duhet të jepen emri i projektit dhe shtegu se ku ku dëshirirojmë të ruhet projekti.

12. Pasi të jetë shkruar emri i projektit dhe të jetë zgjedhur shtegu duhet të klikohet butoni Next. Do të hapet dritarja në të cilën ka mundësi të zgjidhet kompajleri, të bëhet konfigurimi për modin Debug dhe Relase.

www.e-Libraria.com


19

13. Pas zgjedhjes së kompjalerit dhe konfigurimit klikohet butoni Finish

dhe tashmë projekti është krijuar.

www.e-Libraria.com


20

1. Funksionet Funksioni është një grup i shprehjeve dhe komandave të ndryshme që kur ekzekutohet kryen një punë të caktuar. Funksioni pas kryerjes së punës mund të kthejë rezultat për punën e kryer apo edhe mund të mos kthejë rezultat (void). Forma abstrakte e funksionit është dhënë në figurën 1. Rezultati/dalja e një funksioni mund të jetë hyrje e një funksioni tjetër.

Përvojat tregojnë që mënyra më e mirë për të zhvilluar dhe mirëmbajtur programe të mëdha është konstruktimi i tyre nga pjesë të vogla (module/nënprograme). Figura 2 paraqet se si një program i shkruar i tëri në funksionin main është ndarë në pjesë të vogla (funksione).

Përdorimi i funksioneve lehtëson dizajnin, ndërtimin, debugimin, zgjerimin, modifikimin, ripërdorim dhe organizmin më të mirë të programit. Mënyra se si funksioni main i thirr funksionet e tjera ka një analogji sikurse shefi me punëtorët. Shefi (funksioni thirrës) i kërkon punëtorit (funksioni i thirrur) për të kryer një punë dhe për të kthyer përgjigje kur të kryhet puna.

www.e-Libraria.com


21

Një nga arsyet kryesore për përdorimin e funksioneve është ndarja e programit në punë të vogla dhe nëse diçka nuk shkon mirë, atëherë është më e lehtë të identifikohet se ku është problemi.

1.1. Funksionet e paracaktuara Funksionet paracaktuara janë funksione që janë ndërtuar në C + + për të kryer disa operacione standarde. Funksionet e paracaktuara janë të grupuara në librari të ndryshme të bazë të kategorive. Në C + +, koncepti i një funksioni është i ngjashëm me atë të një funksioni në algjebër. Për shembull, çdo funksion ka një emër dhe në varësi të vlerave të përcaktuara nga përdoruesi, ai bën llogaritjet e duhura. Disa nga funksionet e paracaktuara në C++ janë abs(x), pow(x,y), sin(x), cos(x), log(x) etj. Funksioni pow (x, y), llogarit xy, që është, vlera e x e ngritur në fuqinë y. Për shembull, pow (2, 4) = 24 = 16. 1. Të shkruhet funksioni për llogaritjen e vlerës absolute për një vlerë të

caktuar.

#include <iostream> #include <cmath> using namespace std;; int main () cout<< "Vlera absolute e 3.1416 sht " << abs (3.1416) << endl;; cout<< "Vlera absolute e -2.89 sht " << abs (-2.89) << endl;; system("pause");; return 0;;

www.e-Libraria.com


22

2. Të shkruhet funksioni për llogaritjen e gjatësisë së hipotenuzës për trekëndëshin kënddrejtë, nëse dihen gjatësia e brinjës a dhe brinjës b.

#include <iostream> #include <cmath> using namespace std;; int main() double a, b;; cout<<"Llogaritja e hipotenuzës për trekëndshin këndrejt\n";; cout << "Shëno gjatësinë e brinjës a:";; cin >> a ;; cout << "Shëno gjatësiën e brinjës b:";; cin >>b;; cout << "Gjatësia e hipotenuzës: " << hypot(a, b) << '\n';; system("pause");; return 0;; 3. Të shkruhet programi për llogaritjen e sipërfaqes së rrethit duke përdorur

funksionin pow. #include<iostream > using namespace std;; int main() float r, s;; const float pi=3.14159;; cout<< "Vlera e rrezes r = ";; cin >> r;; s = pi*pow(r,2);; //pow(r,2) e ngrit ne katror rrezen r cout<< "\nSiperfaqja e rrethit: s = " << s << endl;; return 0;; 4. Të shkruhet programi për llogaritjen e rrënjës katrore të një numri të

dhënë, duke e përdorur funksionin sqrt. #include <iostream> #include <cmath> using namespace std;; int main() double x = 25;; cout<<"Rrenja katrore e "<<x <<" eshte " <<sqrt(x);; system("pause");; return 0;;

www.e-Libraria.com


23

5. Të shkruhet programi për llogaritjen e sinusit të një këndi të caktuar duke përdorur funksionin sin.

#include <iostream> #include <cmath> using namespace std;; #define PI 3.14159265 int main () double kendi;; kendi = 30.0;; cout<<"Sinusi i " << kendi << " shkalleve eshte " << sin (kendi*PI/180) <<endl;; system("pause");; return 0;; 6. Të shkruhet programi për llogaritjen e kosinusit të një këndi të caktuar

duke përdorur funksionin cos.

#include <iostream> #include <cmath> using namespace std;; #define PI 3.14159265 int main () double kendi;; kendi = 45.0;; cout<<"Kosinusi i " << kendi << " shkalleve është << cos (kendi*PI/180) <<endl;; system("pause");; return 0;; 7. Të shkruhet programi për llogaritjen e tangjentit për një vlerë të

caktuar, duke përdorur funksionin tan. #include <iostream> #include <cmath> using namespace std;; int main() double x = 0.3333;; cout<<"Tangjenti i " <<x <<" është " << tan(x);; system("pause");; return 0;;

www.e-Libraria.com


24

8. Të shkruhet programi për llogaritjen e shprehjes y=ex duke përdorur funksionin exp.

#include <iostream> #include <cmath> using namespace std;; int main() double x = 2.7;; cout<<"'e' e ngritur ne fuqinë 2.7 është " <<exp(x) <<endl;; system ("pause");; return 0;; 9. Të shkruhet programi për llogaritjen e ln(x) për një vlerë të caktuar duke

e përdorur funksionin log.

#include <iostream> #include <cmath> using namespace std;; int main () double x=5.8;; cout<<"ln("<<x<<") = " <<log (x);; system("pause");; return 0;;

1.2. Funksionet e caktuara nga përdoruesi C + + nuk ofron të gjitha funksionet e mundshme që i nevojiten përdoruesit, sepse nevojat e secilit përdorues mund të jenë të ndryshme dhe specifike, prandaj për këtë arsye duhet të shkruhen funksionet e caktuara nga përdoruesi. Funksionet e caktuara nga përdoruesi, në C++ klasifikohen në dy kategori:

Funksione që kthejnë vlerë këto funksione kanë një tip kthyes dhe duke përdorur deklaratën return e kthejnë rezultatin e llojit të caktuar të të dhënave.

Funksione boshe (që nuk kthejnë vlerë) këto funksione nuk kanë tip kthyes të të dhënave. Këto funksione nuk e përdorin deklaratën return për të kthyer rezultat.

www.e-Libraria.com


25

1.2.1. Funksionet që kthejnë vlerë Sintaksa e deklarimit të një funksioni të caktuar nga përdoruesi dhe i cili kthen rezultat është si më poshtë: tipi emri_funksionit(tipi1 par1, tipi2 par3 ...) deklarimet dhe shprehjet tjera_ emri_funksionit secili identifikator valid tipi tipi i të dhënave për funksionin/rezultatin tipi1, tipi2 tipi i të dhënave për parametrat par1, par2 emrat e parametrave Figura 4 paraqet deklarimin dhe implementimin e funksionit ngritjaNeFuqi i cili parametrin e parë (baza) e ngrit në fuqi me parametrin e dytë (eksponenti)

10. Të shkruhet programi i cili përmes funksionit max e kthen si rezultat numrin më të madh në mes numrave x dhe y.

#include <iostream> using namespace std;; double max(double x, double y) double max;; if (x >= y) max = x;; else max = y;; return max;; int main() double a,b;; a=42;; b=567;; cout<< "Numri më i madh është: " <<max(a,b) <<endl;; system("pause");; return 0;;

www.e-Libraria.com


26

11. Krijo funksionin hipotenuza i cili llogarit gjatësinë e hipotenuzës së trekëndëshit kur dihet dihen gjatësitë e dy krahëve tjerë. Funksioni duhet të ketë dy parametra hyrës të tipit double dhe të kthejë hipotenuzën të tipit double.

#include <iostream> #include <iomanip> using namespace std;; double hypotenuza( double, double );; int main() double brinja1, brinja2;; cout << setiosflags( ios::fixed | ios::showpoint );; cout << "Jep gjatsinë e brinjës b1= ";; cin >> brinja1;; cout << "Jep gjatsinë e brinjës b2= ";; cin >> brinja2;; cout << "Hypotenuza: " << setprecision(2) << hypotenuza( brinja1, brinja2 ) << endl<<endl;; system("pause");; return 0;; double hypotenuza( double b1, double b2 ) return sqrt(b1 * b1 + b2 * b2 );; 12. Të shkruhet funksioni shumëfishi i cili përcakton për çiftin e numrave

të plotë nëse numri i dytë është shumëfish i numrit të parë. Funksioni duhet të ketë dy parametra të tipit të plotë dhe të kthejë si rezultat true ose false.

#include <iostream> using namespace std;; bool shumefishi( int, int );; int main() int x, y;; for ( int i = 1;; i <= 3;; ++i ) cout << "Shtyp dy numra të plotë: ";; cin >> x >> y;; if ( shumefishi( x, y ) ) cout << y << " ëshët shumëfish i " << x << "\n\n";; else cout << y << " nuk ëshët shumëfish i " << x << "\n\n";; cout << endl;; system("pause");; return 0;;

www.e-Libraria.com


27

bool shumefishi( int a, int b ) return !( b % a );; 13. Të shkruhet funksioni sekondat i cili merr tre parametra të tipit int

(meqenëse koha është pozitive, parametrat dhe funksioni të jenë të unsigned int). Funksioni të llogaris diferencën në mes dy kohëve të dhëna dhe ta kthejë rezultatin në sekonda.

#include <iostream> using namespace std;; unsigned int sekondat(unsigned, unsigned, unsigned );; int main() unsigned ora, minuta, sekonda, temp;; cout << "Jep kohën e parë në formatin hh mm ss (p.sh 12 15 20): ";; cin >> ora >> minuta >> sekonda;; temp = sekondat( ora, minuta, sekonda );; cout << "Jep kohën e dytë në formatin hh mm ss (p.sh 12 15 20): ";; cin >> ora >> minuta >> sekonda;; cout << "Diferenca në mes kohës 1 dhe 2 është " << sekondat( ora, minuta, sekonda ) - temp << " sekonda" << endl;; system("pause");; return 0;; unsigned int sekondat( unsigned ora, unsigned min, unsigned sec) return 3600 * ( ora >= 12 ? ora - 12 : ora ) + 60 * min + sec;; 14. Të shkruhet funksioni perfekt i cili përcakton nëse parametri i tij

është numër perfekt. (Numri është perfekt nëse shuma e faktorëve/plotpjesëtuesve të tij duke përfshirë edhe 1, por jo vetveten është baras me numrin. p.sh 6=1+2+3). Duke shfrytëzuar funksionin perfekt të shtypen të gjithë numrat perfekt nga 1 deri në 5000.

#include <iostream> using namespace std;; bool perfekt(int numri ) int shuma = 1;; for ( int i = 2;; i <= numri / 2;; ++i ) if ( numri % i == 0 ) shuma += i;; return shuma == numri ? true : false;; int main() cout << "Për numrat e plotë nga 1 deri 5000:\n";; for ( int j = 2;; j <= 5000;; ++j )

www.e-Libraria.com


28

if ( perfekt( j ) ) cout << j << " është perfekt\n";; cout << endl;; system("pause");; return 0;; 15. Të shkruhet funksioni distanca i cili llogarit distancën në mes dy

pikave. Funksioni të ketë 4 parametra të tipit double dhe si rezultat të kthejë distancën e tipit double.

#include <iostream> #include <iomanip> using namespace std;; double distanca( double, double, double, double );; int main() double x1, y1, x2, y2, dist;; cout << "Shtyp koordinatat e pikës 1: ";; cin >> x1 >> y1;; cout << "Shtyp koordinatat e pikës 2: ";; cin >> x2 >> y2;; dist = distanca( x1, y1, x2, y2 );; cout << setiosflags( ios::fixed | ios::showpoint ) << "Distanca në mes (" << setprecision(2) << x1 << ", " << y1 << ") dhe (" << x2 << ", " << y2 << ") sht " << dist << endl;; system("pause");; return 0;; double distanca( double x1, double y1, double x2, double y2 ) return sqrt( pow( x1 - x2, 2 ) + pow( y1 - y2, 2 ) );; 16. Të shkruhet funksioni shumezimi i cili gjeneron në mënyrë të

rastësishme dy numra nga 0-‐10 dhe pyet për prodhimin në mes e tyre. Përmes një unaze të përsëritet procesi për më shumë numra dhe në fund të shtypet se sa tentime kanë qenë të sakta dhe sa të pasakta.

#include <iostream> #include <ctime> using namespace std; void shumezimi(); void mesazhi(bool rasti); int main() srand(time(0)); shumezimi();

www.e-Libraria.com


29

system("pause"); return 0; void shumezimi() int x, y, pergjigja, sakte = 0, gabim = 0, m=5; for ( int i = 1; i <= m; ++i ) x = rand() % 10; //numër i rastit 0-‐9 y = rand() % 10; //numër i rastit 0-‐9 cout << "Sa bejne: " << x << " x " << y << "? "; cin >> pergjigja; while (pergjigja != x * y ) ++gabim; cout << "Gabim. Provo përseri\n"; cout << "Sa bëjnë: " << x << " x " << y << "? "; cin >> pergjigja; ++sakte; cout << "Sakte. Urime!\n"; cout<< "Pyetje: "<<m << "\nTentime të sakta: " <<sakte << "\nTentime gabim: "<<gabim; 17. Të shkruhet programi i cili përmes funksionit aritmetika kryen veprimet

e mbledhjes, zbritjes, shumëzimit dhe pjesëtimit për dy numra të gjeneruar në mënyrë të rastësishme. Përmes funksionit menyja të pyetet për veprimin që duhet të kryhet (mbledhje, zbritje, shumëzim, pjesëtim apo kombinim i rastësishëm). Veprimi të përsëritet disa herë dhe në fund të shtypet se sa tentime kanë qenë të sakta dhe sa të pasakta.

#include <iostream> #include <ctime> using namespace std; int menyja(); void aritmetika(); void mesazhi_sakte(); void mesazhi_gabim(); char v[]="\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; int main() srand(time(0)); aritmetika(); system("pause"); return 0;

www.e-Libraria.com


30

int menyja() int opsioni; do cout<< "Zgjidh një opsion nga 1-‐5." <<v << "\nShtyp: 1 për mbledhje." << "\nShtyp: 2 për zbritje" << "\nShtyp: 3 për shumëzim." << "\nShtyp: 4 për pjesëtim." << "\nShtyp: 5 për kombinim të opsioneve nga 1 deri 4. " <<v <<"op = "; cin >> opsioni; while (opsioni < 1 || opsioni > 5 ); return opsioni; void mesazhi_gabim() cout << "Gabim. Provo edhe njëherë."; void mesazhi_sakte( void ) cout << "Mire. Vazhdo tutje."; void aritmetika() int x, y, pergjigjeLexuar, pergjigjeSakte, sakte = 0, gabim = 0, perseritje=5; char shenja; int zgjedhja = menyja(); for (int i = 1; i <= perseritje; ++i ) x = rand() % 10; y = rand() % 10; if (zgjedhja == 5) //nese zgjidhet opsioni 5 zgjidh ne menyre te rastit zgjedhja = 1 + rand() % 4; switch ( zgjedhja ) case 1: // mbledhja shenja = '+'; pergjigjeSakte = x + y; break; case 2: // zbritja shenja = '-‐'; pergjigjeSakte = x -‐ y; break; case 3: // shumezimi shenja = '*'; pergjigjeSakte = x * y; break; case 4: // pjesetimi

www.e-Libraria.com


31

shenja = '/'; if (y == 0) y = 1; // pjesetimi me zero pergjigjeSakte = x / y; else x *= y; pergjigjeSakte = x / y; break; cout << "\nSa bëjnë: " << x << " " << shenja << " " << y << "? "; cin >> pergjigjeLexuar; while (pergjigjeLexuar != pergjigjeSakte) ++gabim; mesazhi_gabim(); cout << "\nSa bëjnë: " << x << " x " << y << "? "; cin >> pergjigjeLexuar; ++sakte; mesazhi_sakte(); cout<< v <<"\nPyetje: "<<perseritje << "\nTentime të sakta: " <<sakte << "\nTentime gabim: "<<gabim <<endl;

1.2.2. Funksionet që nuk kthejnë vlerë Funksionet boshe (që nuk kthejnë vlerë) dhe funksionet që kthejnë vlerë e kanë strukturën e njëjtë. Të dy llojet e kanë edhe kokën (heading) dhe trupin (body). Funksionet boshe nuk kthejnë rezultat, por vetëm e kryejnë një punë të caktuar dhe nuk e përdorin deklaratën return. Megjithatë edhe tek këto funksione mund të përdoret return pa ndonjë vlerë kthyese. Për të deklaruar një funksion bosh përdoret fjala void para emrit të funksionit, për tipin kthyes të të dhënave. Sintaksa e deklarimit është si në vijim: void emri_funksionit(tipi1 par1, tipi2 par3 ...) deklarimet dhe shprehjet tjera_ Edhe funksionet që kthejnë vlerë edhe funksionet boshe, mund të kenë apo mos të kenë parametra formalë. Figura 5 paraqet deklarimin dhe implementimin e funksionit printoNumrin i cili shtyp vlerën e parametrit.

www.e-Libraria.com


32

18. Të shkruhet funksioni void shtyp_numrin i cili shtyp vlerën e

parametrit të tij. #include <iostream> using namespace std;; void shtyp_numrin(int numri) cout << numri << '\n';; int main() cout<<"Thirja e funksionit void\n";; shtyp_numrin(10);; system("pause");; return 0;; 19. Të shkruhet funksioni void max i cili gjen dhe shtyp numrin më të madh

nga dy parametrat formal të tipit double. #include <iostream> using namespace std;; void max(double x, double y) double m;; if (x >= y) m = x;; else m = y;; cout<<"Numri më madh është" <<m;; int main() double a=42,b=55;; max(a,b);; //thirrja e funksionit void system("pause");; return 0;;

www.e-Libraria.com


33

20. Të shkruhet funksioni void shtypja i cili shtyp numrat e plotë nga 1 deri në n. Funksioni le ta ketë një parametër formal të tipit int.

#include <iostream> using namespace std;; void shtypja(int);; //prototipi i funksionit int main () shtypja(5);; //thirrja e funksionit system("pause");; return 0;; void shtypja (int n) cout << "Shtypa e numrave nga 1 deri n <<n<< endl;; for (int i=1;;i<=n;;i++) cout<<i<<endl;; 21. Të shkruhet programi për printimin e numrave të thjeshtë nga 1 deri në

n duke përdorur funksionin i cili nuk kthen rezultat (void). #include <iostream> using namespace std;; void numriThjeshte(int numri) int i,j,kontrolli;; cout<<"Numrat e thjesht eri "<<numri <<"\n";; for(i = 1;; i <= numri;; i++) kontrolli = 0;; for(j = i-1;; j > 1 ;; j--) if(i%j == 0) kontrolli++;; break;; if(kontrolli == 0) cout.width(3);; cout<<i;; cout<<"\n";; int main() numriThjeshte(50);; system("pause");; return 0;;

www.e-Libraria.com


34

1.3. Funksionet Inline Janë funksione në të cilin kompajleri kërkon që të kryhet një zgjerim, pra kodi i funksionit e zëvendëson vendin ku thirret funksioni.

Figura 5 paraqet thirrjen e funksionit inline, kurse figura 6 paraqet zgjerimin e kodit të pjesa ku thirret funksioni.

22. Të shkruhet programi i cili përdor një funksion inline të quajtur

sipRrethi i cili e llogarit sipërfaqen e rrethit.

#include <iostream> using namespace std;; double const pi = 3.14159;; inline double sipRrethi(double r) return pi * r * r;; int main() double rrezja;; cout << "Shtyp rrezen e rrethit: ";; cin >> rrezja;;

www.e-Libraria.com


35

cout<< "Siperfaqja e rrethit është " << sipRrethi(rrezja) << endl;; system("pause");; return 0;; 23. Të shkruhet programi i cili përdor një funksion inline të quajtur

vellKubi i cili e llogarit vëllimin e kubit. #include <iostream> using namespace std;; inline double vellKubi(double brinja ) return brinja * brinja * brinja;; int main() double brinja;; cout << "Shëno gjatësinë e brinjës së kubit: ";; cin >> brinja;; cout << "Vëllimi i kubit është: " << vellKubi(brinja) << endl;; system("pause");; return 0;; 24. Të shkruhet funksioni inline max i cili kthen vlerën më të madhe në mes

dy vlerave të dhëna. #include <iostream> using namespace std;; inline int max(int a, int b) return a > b ? a : b;; int main( void) int x1, x2;; cout<<"Jep dy vlera ";; cin>>x1>>x2;; cout<< "Maksimumi i numrit " <<x1<<" dhe " << x2 << " është " <<max(x1, x2) << endl;; system("pause");; return 0;;

www.e-Libraria.com


36

25. Të shkruhet programi i cili shkronjën e vogël e kthen në shkronjë të madhe. Kjo të realizohet duke përdorur operatorin e kushtëzuar ? dhe funksionin inline.

#include <iostream> using namespace std;; inline char shkronja_madhe( char a ) return ((a >= 'a' && a <= 'z') ? a-('a'-'A') : a );; int main() cout<<("Shëno një shkronjë: ");; char shkronja;; cin>> shkronja;; shkronja= shkronja_madhe( shkronja);; cout<<"Shkronja e madhe: " <<shkronja <<endl;; system("pause");; return 0;;

1.4. Makro funksionet Më së shpeshti përdoren për të deklaruar konstante të cilat mund të përdoren në vend të konstanteve të deklaruara dhe variablave. Për deklarimin e makro-‐funksioneve përdoret direktiva #define. Disa shembuj të deklarimit të makro-‐funksioneve janë dhënë në figurën 7.

Avantazhi i makro-‐funksioneve është se interpretohen gjatë kohës së kompajlimit. Janë jashtëzakonisht të dobishme kur blloqe të njëjta të kodit duhet të ekzekutohen disa herë.

www.e-Libraria.com


37

26. Të shkruhet makro funksioni max i cili kthen vlerën më të madhe në mes dy vlerave të dhëna.

#include <iostream> using namespace std;; #define max (a, b) ((a > b)? a: b) int main( void) int x1, x2;; cout<<"Jep dy vlera ";; cin>>x1>>x2;; cout<< "Maksimumi i numrit " <<x1<<" dhe " << x2 << " është " <<max(x1, x2) << endl;; system("pause");; return 0;;

27. Të krijohet makroja e funksionit llogaritja e cila llogarit shprehjen e mëposhtme, nëse dihet vlera e x-‐it.

#include<iostream> using namespace std;; #define llogaritjaY(x) ((x>0) ? (6*x-2):(2*x+6)) int main() double y=0, x=5;; y=llogaritjaY(x);; cout<< "\nVlera e llogaritur për x=" <<x <<" është y=" <<y << "\n\n";; system("pause");; return 0;;

1.5. Funksionet e mbingarkuara Funksionet e mbingarkuara janë dy ose më shumë funksione me të njëjtin emër, por me parametra të ndryshëm për nga numri i parametrave ose tipi i të dhënave të parametrave. C++ lejon disa funksione me emër të njëjtë deri sa e kanë nënshkrimin e ndryshëm. Kompajleri i C++ zgjedh funksionin e duhur për ta thirrur, duke u bazuar në numrin, tipin dhe rendin e parametrave. Zakonisht funksionet e mbingarkuara përdoren për të kryer punë të ngjashme por me tipa të ndryshëm të të dhënave.

www.e-Libraria.com


38

Një shembull i funksionit të mbingarkuar shihet në figurën e mëposhtme.

28. Të shkruhet programi i cili llogarit sipërfaqen e rrethit dhe

drejtkëndëshit përmes funksionit të mbingarkuar siperfaqja().

#include<iostream> using namespace std;; #define pi 3.14159265359 void siperfaqja(int r) cout<<"Sipërfaqja e rrethit:"<<pi*r*r;; void siperfaqja(int a,int b) cout<<"Sipërfaqja e drejtkëndëshit:"<<a*b;; int main() int a,b,r;; cout<<"Rrezja r= ";; cin>>r;; siperfaqja(r);; cout<<"\nKrahet a=?b=?";; cin>>a>>b;; siperfaqja(a,b);; cout<<endl;; system("pause");; return 0;;

www.e-Libraria.com


39

29. Të shkruhet programi për llogaritjen e shprehjes së mëposhtme përmes funksionit të mbingarkuar shuma().

#include <iostream> using namespace std;; double shuma(int n) double s;; int i;; s=0;; for (i=0;;i<=n;;i++) s=s+(4*i+2);; return s;; double shuma(int n,double x) double s;; int i;; s=0;; for (i=3;;i<=2*n;;i++) s=s+(3*i-2*x);; return s;; int main() double x,y1,y2;; int n=10;; cout << "Vlera x=";; cin >> x;; cout << "\nVlerat e llogaritura\n\n";; y1=shuma(n);; cout << " y=" << y1;; y2=pow(x+3,2)+shuma(n,x);; cout << "\n z="<< y2 << "\n\n";; system("pause");; return 0;; 30. Të shkruhen 2 funksione me emrin maksimumi(). Njëri funksion të gjejë

dhe ta shtyp numrin më të madh në vektorin A(m), kurse funksioni tjetër numrin më të madh në matricën B(m,m). Vektori dhe matrica gjatë deklarimit të iniciohen me vlera fillestare.

#include <iostream> using namespace std;; const int m=3;;

www.e-Libraria.com


40

int maksimumi(int v[], int m) int max = v[0];; for (int i = 1;; i < m;; i++) if (v[i] > max) max = v[i];; return max;; int maksimumi(int a[m][m], int m) int max=a[0][0];; for (int i = 0;; i < m;; i++) for (int j = 0;; j < m;; j++) if (max < a[i][j]) max = a[i][j];; return max;; int main() int a[m] = 3,-7,8;; int Z[m][m] = 3,7,4,-6,2,-3,6,1,5;; cout<<"Vlera maksimale e vektorit: "<< maksimumi(a,m);; cout<<"\nVlera maksimale e matricës: "<< maksimumi(Z,m);; cout<<endl;; system("pause");; return 0;; 31. Të shkruhen 3 funksione me emrin siperfaqja() të cilat llogarisin

sipërfaqen e kubit, sferës dhe konit. Funksionet të thirren për vlera të lexuara përmes tastierës.

#include<iostream> using namespace std;; #define pi 3.14159265359 void siperfaqja(int a) cout<<"Sipërfaqja e kubit:"<<6*a*a;; void siperfaqja(double r) cout<<"Sipërfaqja e sferes:"<<4*pi*r*r;; void siperfaqja(double r,double h) cout<<"Sipërfaqja e konit:"<<pi*r*sqrt(r*r+h*h);; int main() int a=10;; double r=12.56,h=8.26;;

www.e-Libraria.com


41

cout<<"Llogaritja e sipërfaqes se kubit, sferës dhe konit\n";; siperfaqja(a);; cout<<endl;; siperfaqja(r);; cout<<endl;; siperfaqja(r,h);; cout<<endl;; system("pause");; return 0;;

www.e-Libraria.com


42

2. Sinonimet Për tipat e të dhënave mund të krijohen sinonime ose pseudonime duke përdorur deklaratën typedef. Sintaksa e krijimit të sinonimeve është dhënë në figurën 9.

typedef nuk krijon tip të ri të dhënave, por krijon një sinonim për tipin ekzistues. Sinonimet mund të jenë lokale dhe globale. 32. Të shkruhet programi për llogaritjen e faktorielit (n!) duke përdorur

funksionin faktorieli. Për tipin int të krijohet sinonimi plote, kurse për double të krijohet sinonimi decimal.

#include <iostream> using namespace std;; double faktorieli(int n) typedef int plote;; //sinonim lokal typedef double decimal;; //sinonim lokal plote i;; decimal F=1;; for (i=1;;i<=n;;i++) F=F*i;; return F;; int main() typedef int plote;; //sinonim lokal typedef double decimal;; //sinonim lokal plote n=0;; decimal fakt;; cout<<"Vlera n = ";; cin>>n;; fakt = faktorieli(n);; cout<< "Faktorieli F= " << fakt<<"\n";; system("pause");; return 0;;

www.e-Libraria.com


43

33. Të shkruhet programi i cili përmes funksionit vektori() e llogarit prodhimin e anëtarëve negativ të vektorit A(m). Për tipin int dhe double të krijohen sinonimet globale, plote respektivisht decimal.

#include <iostream> using namespace std;; typedef int plote;; //sinonim global typedef double decimal;; //sinonim global decimal vektori(decimal v[], plote m) decimal p=1;; for (int i = 0;; i < m;; i++) if (v[i] < 0) p=p* v[i];; return p;; int main() const plote m=8;; plote i;; decimal A[m]=-12,3,22,6,-8,33,-18,4;; cout<<"Prodhimi i antarve negativ S= " << vektori(A,m) <<endl;; system("pause");; return 0;; 34. Të shkruhet programi i cili përmban një funksion të mbingarkuar i cili

shtyp vlerat e secilit parametër. Njëri funksion të ketë dy, kurse tjetri tre parametra të tipit të çfarëdoshëm. Për tipat e të dhënave të krijohen sinonime.

#include<iostream> using namespace std;; typedef int plote;; typedef double decimal;; void funMbingarkuar(plote a, plote b, decimal c) cout<<"\nHyrja në funksionin 1" <<"\nVlera e a="<<a <<"\nVlera e b="<<b <<"\nVlera e c="<<c <<"\nDalja nga funksioni 1" <<endl;; void funMbingarkuar(plote a, decimal b, decimal c) cout<<"\nHyrja në funksionin 2" <<"\nVlera e a="<<a

www.e-Libraria.com


44

<<"\nVlera e b="<<b <<"\nVlera e c="<<c <<"\nDalja nga funksioni 2" <<endl;; int main() funMbingarkuar(2,5,11);; funMbingarkuar(2,5.5,11.5);; funMbingarkuar(2,5,11.5);; cout<<endl;; system("pause");; return 0;;

www.e-Libraria.com


45

3. Numërimet (enumerations) Numërimet janë lista të konstanteve me të gjitha vlerat e mundshme. Konstantet e emëruara ruhen në memorie si numra të plotë (integer) duke filluar nga 0, 1 e kështu me radhë, nëse nuk përcaktohet ndryshe.

3.1. Përcaktimi dhe shfrytëzimi i grupit Një grup përcaktohet duke e shfrytëzuar komandën enum. Anëtarët e grupit quhen edhe numërues (ang. enumerator). Sintaksa për deklarimin e një grupi të numëruar është: enum emri_grupit vlera1, vlera2, ...; enum -‐ fjala çelës emir_grupit emri i grupit të numëruar vlera1, vlera2 Në figurën 11 është dhënë një shembull i deklarimit të grupit dhe shpjegimi për sintaksën e grupit.

Sintaksa e deklarimit të variablave të grupit është g v; g emri i grupit v variabla e deklaruar e grupit Në figurën 12 është dhënë grupi sportet. Më pas është deklaruar variabla e grupit dhe është iniciuar me njërën nga vlerat e numëruara të grupit.

www.e-Libraria.com


46

35. Të krijohet grupi shtetet i cili përmban anëtarët: Kosova, Shqiperia, Maqedonia, Gjermania dhe Suedia. Më pas të deklarohet një variabël e tipit shtetet dhe të shtypet vlera e paracaktuar (default) për Gjermaninë.

#include <iostream> using namespace std;; enum shtetet Kosova, Shqiperia, Maqedonia, Gjermania, Suedia ;; int main() shtetet shteti;; shteti = Gjermania;; cout << "\nGjermania e ka vlerën e paracaktuar (default) = " << shteti <<endl ;; system("pause");; return 0;; 36. Të shkruhet programi në të cilin është i deklaruar një grup me emrin

veturat. Grupi të përmbajë disa lloje të veturave dhe më pas të shtypet vlera e paracaktuar për veturën e preferuar.

#include <iostream> using namespace std;; enum veturat bmw, mercedes, fiat, audi, kia, mazda, nissan, toyota ;; int main() veturat veturaIme;; veturaIme = audi;; cout << "\nVetura e preferuare ka vleren e paracaktuar (default) = " << veturaIme <<endl ;; system("pause");; return 0;;

www.e-Libraria.com


47

37. Të shkruhet programi në të cilin është i deklaruar një grup me emrin stinet i cili përmban katër stinët e vitit. Më pas të shtypen vlerat e nënkuptuara (default) për secilën stinë të vitit.

#include <iostream> using namespace std;; enum stinet pranvera, vera, vjeshta, dimri ;; int main() cout << "\nStinet e vitit janë:\n" << pranvera << ". Pranvera\n " << vera << ". Vera\n" << vjeshta << ". Vjeshta\n" << dimri << ". Dimri \n";; system("pause");; return 0;;

3.2. Degëzimi përmes vlerave të numëruara Vlerat e numëruara mund të shfrytëzohen për realizimin e degëzimeve duke përdorur komandën if, ose switch. 38. Nëse është dhënë grupi gjendjet, të shkruhet programi në të cilin

deklarohet variabla e numëruar nota dhe përmes komandës if të shtypet rezultati.

enum gjendjet dobet, mire, shumemire, shkelqyeshem ;; #include<iostream> using namespace std;; enum gjendjet dobet, mire, shumemire, shkelqyeshem ;; int main()

www.e-Libraria.com


48

gjendjet nota;; nota=shkelqyeshem;; if (nota==dobet) cout << "\nKeni arritur sukses t dobët\n";; else if (nota==mire) cout << "\nKeni arritur sukses të mirë\n";; else if (nota==shumemire) cout << "\nKeni arritur sukses shumë të mirë\n";; else if (nota==shkelqyeshem) cout << "\nKeni arritur sukses të shkëlqyeshëm\n";; system("pause");; return 0;; 39. Nëse është dhënë grupi java, të shkruhet programi i cili përmes

komandës switch dhe variablës së numëruar dita, shtyp rezultatin për ditën e zgjedhur.

enum java hene, marte, merkure, enjte, premte, shtune, diel ;; #include <iostream> using namespace std;; enum java hene, marte, merkure, enjte, premte, shtune, diel ;; int main() java dita;; dita=enjte;; cout << "\nDita që u zgjodh është dita e ";; switch (dita) case hene: cout << "hëne";;break;; case marte: cout << "marte";;break;; case merkure: cout << "mërkure";;break;; case enjte: cout << "ënjte";;break;; case premte: cout << "premte";;break;; case shtune: cout << "shtune";;break;; case diel: cout << "diel";;break;;

www.e-Libraria.com


49

cout << "\n\n";; system("pause");; return 0;; 40. Të shkruhet programi dhe të deklarohet një grup me emrin nota i cili

si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të i shoqërohet vlera numerike. Më pas të shtypet rezultati për notat në algoritme, programim dhe matematikë si dhe të tregohet se në cilën lëndë është nota më e lartë.

#include <iostream> using namespace std;; enum nota pese=5, gjashte=6, shtate=7, tete=8, nente=9, dhjete=10 algoritme, matematike, programim;; int main() matematike=shtate;; programim=tete;; algoritme=nente;; cout << "\nNota në Matematikë është " << matematike << "\nNota në Algoritme është " << algoritme << "\nNota në Programim është " << programim << "\n";; if (algoritme >programim && algoritme>matematike) cout << "\nNota më e lart është n Algoritme";; else if (programim >algoritme && programim>matematike) cout << "\nNota më e lartë është në Programim";; else cout << "\nNota më e lartë është në Matematikë";; cout << "\n\n";; system("pause");; return 0;; 41. Të shkruhet programi dhe të deklarohet një grup me emrin nota i cili

si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të i shoqërohet vlera numerike. Vlera fillestare për notën në programim të lexohet nga tastiera. Përmes komandës if të shtypet nota e lexuar nga tastiera, më pas të rritet nota për 1 dhe të shtypet përsëri.

www.e-Libraria.com


50

#include <iostream> using namespace std;; enum nota pese=5, gjashte=6, shtate=7, tete=8, nente=9, dhjete=10 programim;; int main() int vlera;; cout << "\nSa është nota në Programim: ";; cin >> vlera;; cout << "\nNota në Programim është ";; if (vlera=6) programim=gjashte;; cout << programim;; else if (vlera=7) programim=shtate;; cout << programim;; else if (vlera=8) programim=tete;; cout << programim;; else if (vlera=9) programim=nente;; cout << programim;; else if (vlera=10) programim=dhjete;; cout << programim;; else cout << "Jo kaluese";; programim=static_cast<nota>(programim+1);; cout<< "\nNota në Programim është rritur për 1 " <<"dhe tani është:" << programim << "\n";; system("pause");; return 0;;

www.e-Libraria.com


51

42. Të shkruhet programi në të cilin deklarohen dy grupe me emrin ekzekutuar dhe funksionimi. Grupi ekzekutuar të përmbajë gjendjet: PO dhe JO; kurse grupi funksionimi të përmbajë: rregull dhe gabim. Duke përdorur komandën if të kontrollohet se a është ekzekutuar programi dhe a është në rregull apo ka gabime.

#include <iostream> using namespace std;; enum ekzekutuar PO, JO ekz;; enum funksionimi rregull, gabim fun;; int main() ekz=PO;; fun=rregull;; if (ekz ==PO && fun== rregull) cout<<"Programi sht ekzekutuar dhe po funksionon n rregull\n";; else if (ekz ==PO && fun== gabim) cout<<"Programi sht ekzekutuar, por nuk po funksionon n rregull\n";; else if (ekz ==JO && fun== rregull) cout<<"Programi nuk sht ekzekutuar, dhe po funksionon n rregull\n";; else if (ekz ==JO && fun== gabim) cout<<"Programi nuk sht ekzekutuar, prandaj nuk po funksionon n rregull\n";; system("pause");; return 0;;

3.3. Disa variabla të numëruara të tipit të njëjtë

Sikurse të variablat e tipave standard, brenda një programi mund të deklarohen edhe disa variabla të numëruara të tipit të njëjtë. Sintaksa e deklarimit të variablave është:

www.e-Libraria.com


52

g v1, v2, v3, . . . ; g emri i grupit v1, v2, v3 ...-‐ emrat e variablave të grupit 43. Të shkruhet programi në të cilin deklarohet grupi java me ditët e

javës. Përmes variablave punuese dhe pushuese, të tregohet se me cilin numër fillojnë ditët e punës dhe me cilin numër fillojnë ditët e pushimit (fundjavës).

#include <iostream> using namespace std;; enum java hene, marte, merkure, enjte, premte, shtune, diel ;; int main() java punuese;; java pushuese;; punuese=hene;; pushuese=shtune;; cout << "\nDitët e punës fillojnë me numrin: " << punuese << "\n\nDitët e pushimit fillojnë me numrin: " << pushuese << "\n\n";; system("pause");; return 0;;

3.4. Përcaktimi dhe deklarimi njëkohësisht Gjatë përcaktimit të grupit me të dhëna të numëruara, mund të bëhet edhe deklarimi i variablës përkatëse. Në figurën 13 shihet sintaksa dhe një shembull i përcaktimit dhe deklarimit të variablës njëkohësisht. Në këtë figurë emri i variablës së grupit g është var.

www.e-Libraria.com


53

44. Të shkruhet programi në të cilin përcaktohet grupi viti me vlera stinët e vitit. Gjatë përcaktimit të deklarohet variabla stina. Variabla të iniciohet në funksionin main dhe me pas në varësi të vlerës së iniciuar të shfaqet mesazhi i formuar

#include <iostream> using namespace std;; enum viti pranvera, vera, vjeshta, dimri stina;; int main() stina=pranvera;; if (stina==pranvera) cout << "\nStina e pranverës";; else if (stina==vera) cout << "\nStina e verës";; else if (stina==vjeshta) cout << "\nStina e vjeshtës";; else cout << "\nStina e dimrit";; cout << "\n\n";; system("pause");; return 0;;

www.e-Libraria.com


54

3.5. Shoqërimi direkt i vlerave Gjatë përcaktimit të grupit, mund të bëhet edhe shoqërimi me vlera të caktuara për anëtarët e grupit.

45. Të shkruhet programi dhe të deklarohet një grup me emrin nota i cili

si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të i shoqërohet vlera numerike. Më pas të shtypet rezultati për notat në algoritme, programim dhe matematikë.

#include <iostream> using namespace std; enum nota pese=5, gjashte=6, shtate=7, tete=8, nente=9, dhjete=10 algoritme, matematike, programim; int main() matematike=shtate; programim=tete; algoritme=nente; cout << "\nNota në Matematikë është " << matematike << "\nNota në Algoritme është " << algoritme << "\nNota në Programim është " << programim << "\n"; cout << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


55

3.6. Operimi me variabla të numëruara dhe leximi Variabla e numëruar mund t'i shoqërohet një variable tjetër të numëruar, përmes operatorit të barazimit (=), p.sh v1=v2. Për të shfrytëzuar variablat e numëruara në shprehje të ndryshme duhet të bëhet konvertimi eksplicit përmes static_cast. Nëse është deklaruar grupi nota dhe variabla e grupit algoritme: Nëse variabla algoritme është iniciuar me njërën nga vlerat dhe më pas dëshirohet të rritet vlera për dy, atëherë kjo bëhet përmes konvertimit si më poshtë: Vlerat e të dhënave të numëruara lexohen në mënyrë indirekte përmes variablave. 46. Të shkruhet programi dhe të deklarohet një grup me emrin nota i cili

si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të i shoqërohet vlera numerike. Vlera fillestare për notën në algoritme të lexohet nga tastiera dhe përmes komandës switch të shtypet nota, më pas të rritet nota për 2 dhe të shtypet përsëri.

#include <iostream> using namespace std; enum nota pese=5, gjashte=6, shtate=7, tete=8, nente=9, dhjete=10 algoritme; int main46() int vlera; cout << "\nSa është nota në Algoritme: "; cin >> vlera; cout << "\nNota në Algoritme është "; switch (vlera) case 6: algoritme=gjashte; cout << algoritme;break; case 7:

algoritme=static_cast<nota>(algoritme+2);;

enum nota

//... algoritme;;

www.e-Libraria.com


56

algoritme=shtate; cout << algoritme;break; case 8: algoritme=tete; cout << algoritme;break; case 9: algoritme=nente; cout << algoritme;break; b 10: algoritme=dhjete; cout << algoritme;break; default: cout << "Jo kaluese";break; algoritme=static_cast<nota>(algoritme+2); cout<< "\nNota n Algoritme është rritur për 2 " <<"dhe tani sht:" << algoritme << "\n"; system("pause"); return 0;

3.7. Krijimi i disa grupeve njëkohësisht Në një program mund të krijohen dhe të shfrytëzohen disa grupe në të njëjtën kohë dhe njëkohësisht të kombinohen vlerat e tyre.

Në një program nuk lejohen grupime në të cilat përfshihen të dhëna të njëjta:

47. Të shkruhet programi në të cilin deklarohen dy grupe me emrin moti dhe

koha. Grupi moti të përmbajë gjendjet: kthjellet, vranet, ere, ftohte dhe diell; kurse grupi koha të përmbajë: mjegull, shi dhe bore. Duke përdorur komandën if të kontrollohen disa gjendje dhe të shtypet mesazhi sipas modelit të mëposhtëm. Moti është i ftohtë dhe me shi

www.e-Libraria.com


57

#include <iostream> using namespace std; enum moti kthjellet, vranet, ere, ftohte, diell mt; enum koha mjegull, shi, bore kh; int main() mt=ftohte; kh=bore; if (mt ==ftohte && kh== shi) cout<<"Moti është i ftohtë dhe me shi\n"; else if (mt ==ftohte && kh== bore) cout<<"Moti është i ftohtë dhe me borë\n"; system("pause"); return 0;

3.8. Të dhënat e numëruara në nënprograme Të dhënat e numëruara mund të përdoren në nënprograme (funksione), qoftë brenda tyre apo edhe si parametra të funksioneve. 48. Të shkruhet programi në të cilin deklarohet një grup me emrin Motori

si dhe funksioni Kontrollo i cili ka si parametër hyrës grupin Motori. Grupi përmban dy vlera ON dhe OFF. Funksioni Kontrollo të thirret për ON dhe për OFF.

#include <iostream> using namespace std; enum Motori OFF, ON statusi;

www.e-Libraria.com


58

void Kontrollo(enum Motori); int main() statusi = OFF; Kontrollo( statusi); statusi = ON; Kontrollo( statusi); system("pause"); return 0; void Kontrollo(Motori gjendja) if (gjendja==ON) cout<<"Motori është i ndezur\n"; else cout<<"Motori është i fikur\n"; 49. Nëse është dhënë grupi pozita, të shkruhet programi i cili i mundëson

përdoruesit të shtyp shkronjën e parë (a, s, m, k, p), dhe tipin e zgjedhur ta ruajë si vlerë të variablës së tipit enum. Në fund përmes funksionit shtypja i cili si parametër ka grupin të shtypet emri i plotë e pozitës.

#include <iostream> using namespace std; enum pozita asistent, sekretar, menagjer, kontabilist, programues puna; void shtypja(pozita vendi) if (vendi==asistent) \n"; else if (vendi==sekretar) \n"; else if (vendi==menagjer) \n"; else if (vendi==kontabilist) \n"; else if (vendi==programues) \n"; int main() char sh;

www.e-Libraria.com


59

\n" <<"a:asistent\n" <<"s:sekretar\n" <<"m:menagjer\n" <<"k:kontabilist\n" <<"p:programues\n"; cin >>sh; switch (sh) case 'l': puna=asistent; break; case 's': puna=sekretar; break; case 'm': puna=menagjer; break; case 'k': puna=kontabilist; break; case 'p': puna=programues; break; default: break; shtypja(puna); system("pause"); return 0;

www.e-Libraria.com


60

4. Strukturat Fushat numerike janë shfrytëzuar për mbajtjen e të dhënave homogjene apo të dhënave të tipit të njëjtë.

Në disa situata, paraqitet nevoja për të grupuar të dhëna heterogjene apo të llojeve të ndryshme, duke krijuar tipa të ri, të cilët njihen si struktura.

Struktura (ang. structure) është një koleksion i të dhënave me tipa të ndryshëm, përkatësisht të dhëna heterogjene. Struktura paraqet një tip të dhënash të përcaktuar nga përdoruesi i cili përcaktohet duke përdorur fjalën çelës struct.

4.1. Krijimi i strukturave të zakonshme Strukturat, para se të shfrytëzohen, duhet të krijohen duke e përdorur komandën struct.

Një shembull i krijimit të strukturës është dhënë në figurën e mëposhtme

www.e-Libraria.com


61

50. Të deklarohet një strukturë me emrin personi e cila përmban emrin,

mbiemrin, qytetin dhe vitin e lindjes. struct personi char emri[15]; char mbiemri[20]; char qyteti[20]; int vitilindjes; ;

4.2. Deklarimi i variablave të strukturës Sintaksa e deklarimit të variablës me tip të strukturës

51. Për strukturën e krijuar në shembullin paraprak të deklarohet variabla

me emrin personi1 e tipit personi.

#include <iostream> using namespace std; struct personi char emri[15]; char mbiemri[20]; char qyteti[20]; int vitilindjes; ; int main() personi personi1; return 0;

4.3. Qasja në anëtarët e strukturës Për të iu qasur anëtarëve të strukturës përdoret emri i variablës së strukturës dhe emri i anëtarit të strukturës të ndarë me pikë.

www.e-Libraria.com


62

52. Për strukturën e dhënë struct pjesa int modeli;int nrpjeses; float kosto;; të deklarohet variabla pjesa1 dhe të vendosen vlera për secilin anëtar të strukturës. Më pas të shtypen vlerat e secilit anëtar.

#include <iostream> using namespace std; struct pjesa //deklarimi i strukturës int modeli; int nrpjeses; float kosto; ; int main() //****** Deklarimi i variablës së strukturës pjesa pjesa1; //****** Vendosja e vlerave për anëtarët e strukturës pjesa1.modeli = 5060; pjesa1.nrpjeses = 135; pjesa1.kosto = 217.55; //****** Shfaqja e anëtarëve cout << "Modeli " << pjesa1.modeli << ", numri i pjesës " << pjesa1.nrpjeses << ", kostoja " << pjesa1.kosto << endl; system("pause"); return 0;

4.4. Deklarimi direkt i variablës së strukturës Gjatë krijimit të strukturës, njëkohësisht mund të deklarohet edhe variabla e strukturës.

53. Të krijohet struktura orari e cila ruan kohen e fillimit (float) dhe

kohën e mbarimit (float). Për strukturën orari të bëhet deklarimi direkt i variablës, me emrin koha. Më pas të lexohet nga tastiera, koha e fillimit dhe e mbarimit si dhe të shtypen vlerat e anëtarëve të strukturës.

www.e-Libraria.com


63

#include <iostream> using namespace std; struct orari float fillimi; float mbarimi; koha; int main() cout << "\nShfrytëzimi i variablës koha\n" << "-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐"; cout << "\n\nJep kohën e fillimit: "; cin >> koha.fillimi; cout << "Jep kohën e mbarimit: "; cin >> koha.mbarimi; cout << "\n\nKoha e fillimit:" << koha.fillimi; cout << "\nKoha e mbarimit:" << koha.mbarimi << "\n\n"; system ("pause"); return 0;

4.5. Inicimi direkt i variablave Variabla e strukturës mund të iniciohet direkt me vlera gjatë deklarimit të strukturës.

54. Të krijohet struktura koordinata e cila ruan koordinatat e pikës A.

Variabla pika, e strukturës të iniciohet direkt gjatë deklarimit dhe më pas të shtypen vlerat e anëtarëve të strukturës.

www.e-Libraria.com


64

#include <iostream> using namespace std; struct koordinata float x; float y; ; int main() koordinata pika=9.5, 4.8; cout<< "Koordinatat e pikes janë:\nx=" <<pika.x << "\ny=" << pika.y << endl; system("pause"); return 0; 55. Të shkruhet programi për krijimin e strukturës llogaria_bankare e cila

ruan të dhënat: emri dhe mbiemri i mbajtësit të llogarisë (char), numri i llogarisë (int), bilanci (double) dhe interesi (double). Për strukturën llogaria_bankare të bëhet deklarimi direkt i variablës, me emrin klienti. Vlerat të lexohen përmes tastierës dhe më pas të shtypen vlerat e lexuara.

#include <iostream> using namespace std; struct llogaria_bankare char emri[15]; char mbiemri[20]; int numri; double bilanci; double interesi; klienti; int main() cout<< "\nSheno emrin: "; cin>>klienti.emri; cout<< "Sheno mbiemrin: "; cin>>klienti.mbiemri; cout<< "Shëno numrin e llogarisë"; cin>>klienti.numri; cout<< "Shëno bilancin: "; cin>>klienti.bilanci; cout<< "Shëno interesin: "; cin>>klienti.interesi; cout<<klienti.emri <<" " <<klienti.mbiemri << " me numër të llogarisë" <<klienti.numri

www.e-Libraria.com


65

<<"\nka të deponuara në bankë " <<klienti.bilanci <<"Euro me interes " <<klienti.interesi; system("pause"); return 0;

4.6. Llogaritje me variablat e strukturës Variablat e përfshira në strukturë mund të shfrytëzohen për llogaritje ashtu siç shfrytëzohen edhe variablat e zakonshme. Para variablave duhet të shënohet emri i strukturës dhe pika si operator për qasje në anëtarë të strukturës.

Për llogaritje më të lehtë, vlerat e variablave të strukturës mund të ruhen edhe në variabla të zakonshme, p.sh x1=art.sasia; 56. Të krijohet struktura drejtkendeshi, e cila ruan gjatësinë e brinjës a

dhe b. Më pas të llogaritet dhe të shtypet sipërfaqja e drejtkëndëshit duke shfrytëzuar variablat e strukturës.

#include <iostream>; using namespace std; struct drejtkendeshi double a, b; ; int main() drejtkendeshi brinja = 5, 8; double s; cout<< "\nVlerat e variablave të strukturës" <<"\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐" << "\nVlera e brinjës a: " << brinja.a << "\nVlera e brinjës b: " << brinja.b; s=brinja.a*brinja.b; cout << "\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐"

www.e-Libraria.com


66

<< "\nSipërfaqja e drejtkënëshit s=" << s << "\n\n"; system("pause"); return 0; 57. Numri i telefonit mund të ndahet në tre pjesë, p.sh (44) 181-‐906. Të

shkruhet programi i cili përdor strukturën telefoni për të ruajtur këto tri pjesë të numrit si të ndara. Krijo një variabël të strukturës dhe lexo numrin përmes tastierës. Në fund të shtypet numri i lexuar.

#include <iostream> using namespace std; struct telefoni int prefiksi; //prefiksi (2 shifra) int pjesa1; //pjesa1 (3 shifra) int pjesa2; //numri (3 shifra) ; int main() telefoni tel; cout<< "\nSheno numrin e telefonit\n" <<"prefiksi (2 shifra), pjesa e parë (3 shifra), pjesa e dytë (3 shifra)."; cin >> tel.prefiksi >> tel.pjesa1 >> tel.pjesa2; cout << "\nNumri im është " << "(" << tel.prefiksi << ") " << tel.pjesa1 << "-‐" << tel.pjesa2 << endl; system("pause"); return 0; 58. Të shkruhet programi dhe të krijohet struktura vellimi, e cila ruan

sipërfaqen e bazës dhe lartësinë e piramidës. Duke shfrytëzuar variablat e strukturës të llogaritet vëllimi i piramidës.

#include <iostream>; using namespace std; struct vellimi double siperfaqja, lartesia; ; int main() vellimi vell = 50.80, 12.5; double v; cout<< "\nVlerat e variablave t truktures"

www.e-Libraria.com


67

<<"\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐" << "\nSiperfaqja e piramides : " << vell.siperfaqja << "\nLartesia e piramides : " << vell.lartesia; v=(vell.siperfaqja*vell.lartesia)/3; cout << "\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐" << "\nVellimi i piramides V=" << v << "\n\n"; system("pause"); return 0; 59. Të shkruhet programi dhe të krijohet struktura studentet, e cila ruan

ID-‐në dhe notat në programim, algoritme, matematikë dhe fizikë. Duke shfrytëzuar variablat e strukturës të llogaritet nota mesatare e studentit.

#include <iostream>; using namespace std; struct studentet int id; int matematike; int programim; int fizike; int algoritme; studenti; int main() studenti.id=12345; cout<< "Nota ne matematikë: "; cin >>studenti.matematike; cout<< "Nota ne programim: "; cin >>studenti.programim; cout<< "Nota ne fizike: "; cin >>studenti.fizike; cout<< "Nota ne algoritme: "; cin >>studenti.algoritme; cout<<"\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐" << "\nNota mesatare e studentit " << studenti.id << "\nështë " << (studenti.matematike + studenti.programim + studenti.fizike+studenti.algoritme)/4 << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


68

4.7. Ruajtja e të dhënave në strukturë Për ruajtjen e rezultateve të ndryshme mund të shfrytëzohen edhe variablat e komponentëve/anëtarëve të strukturës.

60.

Vlerat e m, n dhe F të ruhen në strukturën alfa. #include <iostream> using namespace std; struct alfa int m,n; double F; ; int main() alfa fakt; int i; cout << "\nVlerat hyrese" << "\nVariabla m: "; cin >> fakt.m; cout << "\nVariabla n: "; cin >> fakt.n; fakt.F=1; for (i=1;i<=(2*fakt.m-‐fakt.n+1);i++) fakt.F=fakt.F*i; cout << "\nVlera e llogaritur F=" << fakt.F << "\n\n"; system("pause"); return 0; 61. Të shkruhet programi për llogaritjen e shprehjes së mëposhtme. Vlerat e

x, n dhe y të ruhen në strukturën shuma.

www.e-Libraria.com


69

#include <iostream> using namespace std; struct shuma int x,n; double y; ; int main() shuma vlera; int i; cout << "\nVlerat hyrëse" << "\nVlera x= "; cin >> vlera.x; cout << "Variabla n: "; cin >> vlera.n; vlera.y=0; for (i=1;i<=vlera.n;i++) vlera.y=vlera.y+ (vlera.n+2*i); cout << "\nVlera e llogaritur y=" << 4*pow((vlera.x+1),2.)-‐2* vlera.y << "\n\n"; system("pause"); return 0;

4.8. Disa variabla të një strukture Sintaksa e deklarimit të variablave të strukturës është si më poshtë:

Më poshtë shihet se si për strukturën me emrin fiek janë deklaruar dy variabla me emrin profesori dhe studenti.

www.e-Libraria.com


70

62. Të shkruhet programi për leximin dhe shtypjen e emrit dhe qytetit të

profesorit dhe të studentit duke shfrytëzuar strukturën personi. Të deklarohen dy variabla, një profesori dhe një studenti.

#include <iostream> using namespace std; struct personi char emri[8],qyteti[10]; int viti; ; int main() personi profesori,studenti; cout << "\nTë dhenat nga tastiera\n\n"; cout << "Qyteti i profesorit ...: "; cin >> profesori.qyteti; cout << "Qyteti i studentit ....: "; cin >> studenti.qyteti; cout << "\n\nTe dhënat e lexuara\n"; cout << "\nProfesori është nga " << profesori.qyteti; cout << "\nStudenti është nga " << studenti.qyteti << "\n\n"; system("pause"); return 0; 63. Nëse është dhënë struktura: struct filmat string titulli; int viti;

imi, juaji; Të shkruhet programi i cili lexon nga tastiera filmin e preferuar dhe vitin. Përmes funksionit printo të shtypet filmi i preferuar për ju dhe për shokun tuaj.

www.e-Libraria.com


71

#include <iostream> #include <string> using namespace std; struct filmat string titulli; int viti; imi, juaji; void printo(filmat filmi); int main() string mystr; imi.titulli = "Avatar"; imi.viti = 2009; cout << "Titulli i filmit të preferuar: "; getline(cin,juaji.titulli); cout << "Viti: "; cin>>juaji.viti; cout << "Filmi im i preferuar është:\n"; printo (imi); cout << "kurse i juaji është:\n"; printo (juaji); system("pause"); return 0; void printo (filmat filmi) cout << filmi.titulli; cout << " (" << filmi.viti << ")\n";

4.9. Përdorimi i operacionit të shoqërimit Nëse janë deklaruar dy variabla v1 dhe v2 të strukturës s, përmes operacionit të shoqërimit: Të gjitha vlerat e anëtarëve (variablave) të variablës v1 u shoqërohen anëtarëve përkatëse të variablës v2.

v2= v

1;

www.e-Libraria.com


72

64. Të shkruhet programi dhe të krijohet struktura produkti e cila ruan

peshën dhe çmimin e produktit. Të deklarohet variabla e strukturës molla dhe të iniciohet me vlera. Këto vlera të vendosen në variablen e re të strukturës të quajtur dardha. Në fund të printohen vlerat e të dy variablave të strukturës.

#include <iostream> using namespace std; struct produkti float pesha, cmimi; ; int main() produkti molla = 5.5,6.4; produkti dardha; dardha=molla; cout << "\nVlerat e variablave pas shoqërimit "; cout << "\n\nMollat: " << molla.pesha << " kg kushtojnë " << molla.cmimi; cout << "\nDardhat: " << dardha.pesha << " kg kushtojnë " << dardha.cmimi << "\n\n"; system ("pause"); return 0; 65. Të shkruhet programi dhe të krijohet struktura telefoni e cila ruan id-‐

në dhe çmimin e telefonit. Të deklarohen variablat e strukturës samsung dhe iphone. Çmimi i variablës samsung të lexohen nga tastiera, kurse çmimi i variablës iphone është për 25% më i lartë se çmimi i samsung. Të shtypen id-‐të dhe çmimet e të dy telefonave duke i shfrytëzuar variablat e strukturës.

#include <iostream> using namespace std; struct telefoni

www.e-Libraria.com


73

int id; float cmimi; ; int main() telefoni samsung, iphone; samsung.id=1010; iphone.id=2020; cout << "\nSa kushton telefoni Samsung?= "; cin >> samsung.cmimi; iphone.cmimi=samsung.cmimi+0.25*samsung.cmimi; cout << "\n\nTelefoni Samsung <" <<samsung.id <<"> kushton " <<samsung.cmimi; cout<< " Euro\n\nTelefoni Iphone<" <<iphone.id <<"> kushton " <<iphone.cmimi << " Euro\n\n"; system ("pause"); return 0;

4.10. Përdorimi i operatorëve relacionalë Operatorët relacionalë nuk mund të zbatohen direkt mbi strukturat, por vetëm mbi komponentët përkatëse të tyre.

66. Të shkruhet programi dhe të krijohet struktura brinjet, e cila ruan

brinjën a dhe b. Më pas të llogaritet sipërfaqja e katërkëndëshit dhe nëse brinja a dhe b

www.e-Libraria.com


74

#include <iostream> using namespace std; struct brinjet double a,b; ; int main64() brinjet kater; double s; cout << "Vlera e brinjës a: "; cin >> kater.a; cout << "Vlera e brinjës b: "; cin >> kater.b; s=kater.a*kater.b; if (kater.a==kater.b) cout<< "\nSipërfaqja e katrorit s=" << s << "\n\n"; else cout<< "\nSipërfaqja e drejtkëndëshit s=" << s << "\n\n"; system("pause"); return 0;

4.11. Disa struktura njëkohësisht Në një program njëkohësisht mund të krijohen edhe disa struktura. Gjatë kësaj çdo strukturë duhet ta ketë emrin dhe komponentët me variablat që përfshihen brenda saj. Dy struktura të ndryshme mund të kenë variabla me emërtime të njëjta. 67. Të shkruhet programi dhe të krijohen strukturat brinjet dhe rrezja. Më

pas të llogaritet dhe të shtypet sipërfaqja dhe perimetri i katërkëndëshit dhe rrethit.

#include <iostream> using namespace std; struct brinjet double a,b; ;

www.e-Libraria.com


75

struct rrezja double r; ; int main() brinjet kater = 4,5; rrezja rrethi = 6; double sk,pk,sr,pr; const double pi=3.1415926; cout << "Vlerat e variablave në dy strukturat" << "\n\nVlera e brinjes a: " << kater.a; cout << "\nVlera e brinjës b: " << kater.b; cout << "\nVlera e rrezës: " << rrethi.r; sk=(kater.a*kater.b); pk=2*kater.a+2*kater.b; cout << "\n\nSiperfaqja e katërkëndëshit \tsk=" << sk << "\nPerimetri i katërkëndëshit \tpk=" << pk; sr=pi*(rrethi.r*rrethi.r); pr=2*pi*rrethi.r; cout << "\nSipërfaqja e rrethit \t\tsr=" << sr << "\nPerimetri i rrethit \t\tpr=" << pr << "\n\n"; system("pause"); return 0;

4.12. Strukturat e ndërthurura Strukturat mund të jenë anëtarë të strukturave të tjera -‐ struktura të ndërthurura. Ky lloj i përdorimit krijon pemën e strukturave -‐ struktura hierarkike.

www.e-Libraria.com


76

Personi është strukturë prind për Studenti dhe Profesori. Çdo strukturë fëmijë ka të gjithë anëtarët e prindit dhe përveç kësaj, zakonisht ka edhe anëtarët e vet. 68. Të shkruhet programi përmes së cilit tregohet shfrytëzimi i strukturave

provimi (nr, nota) dhe personi (emri, mbiemri, lenda). Struktura provimi le të jetë anëtar i strukturës personi.

#include <iostream> using namespace std; struct lenda int nr; unsigned short nota; ; struct personi char emri[10]; char mbiemri[15]; lenda algoritme; ; int main() personi studenti; cout << "Emri dhe mbiemri: "; cin >> studenti.emri >> studenti.mbiemri; cout << "Numri i lendes: "; cin >> studenti.algoritme.nr; cout << "Nota ne provim: "; cin >> studenti.algoritme.nota; cout<< "\n\nTe dhenat e lexuara\n" <<"*****************************" << "\nStudenti: " << studenti.emri <<" " <<studenti.mbiemri << "\nNumri i lendes: " <<studenti.algoritme.nr << "\nNota ne provim: " << studenti.algoritme.nota << "\n\n"; system("pause"); return 0; 69. Të shkruhet programi në të cilin deklarohet struktura punetori. Për

datën e pagesës të deklarohet struktura data e cila deklarohet brenda strukturës punetori.

#include <iostream> using namespace std; struct punetori

www.e-Libraria.com


77

char emri[20]; int id; float paga; struct data int dita; int muaji; int viti; dt; pun = "Peon Neziri",50,1250,27,02,2012; int main() cout<<"Punetori: " <<pun.emri <<"\nID: " <<pun.id <<"\nPaga: " <<pun.paga <<"\nData e pageses: " <<pun.dt.dita <<"/"<<pun.dt.muaji <<"/"<<pun.dt.viti <<endl; system("pause"); return 0; 70. Të shkruhet programi në të cilin deklarohet struktura Kosto (derivate,

mirembjatje, regjistrim, tjera) dhe Vetura (emri, targa, prodhuar, kosto). Kosto është strukturë e deklaruar brenda strukturës Vetura. Tek struktura Vetura të përdoret konstruktori për inicimin e vlerave të klaës Kosto dhe Vetura. Në funksionin main të deklarohet një veturë, të inicohet me vlera si dhe të shtypen shënimet e veturës dhe shpenzimet vjetore.

#include <iostream> #include <iomanip> #include <string> using namespace std; struct Kosto double derivate, //derivate për një vit mirembajtje, //mirembajtje vjetore regjistrim, tjera; ; struct Vetura string emri; string targa; int prodhuar; Kosto kosto; //struktura Brenda strukturës Vetura() // konstruktori i nënkuptuar emri = ""; targa = ""; prodhuar = 2000; kosto.derivate = kosto.mirembajtje = kosto.regjistrim = kosto.tjera = 0.00;

www.e-Libraria.com


78

; int main() Vetura vet1; vet1.emri = "Audi"; vet1.targa = "01-‐000-‐AB"; vet1.prodhuar = 2010; vet1.kosto.derivate = 1500; vet1.kosto.mirembajtje = 300; vet1.kosto.regjistrim = 289.50; cout << fixed << showpoint << setprecision(2); cout << "Shpenzimet vjetore për << vet1.emri << " me targa "<< vet1.targa << " e prodhuar me "<<vet1.prodhuar << " janë " << (vet1.kosto.derivate + vet1.kosto.mirembajtje + vet1.kosto.regjistrim + vet1.kosto.tjera) << " Euro." << endl; system("pause"); return 0;

4.13. Strukturat si parametra të funksioneve Variablat e strukturave mund të paraqiten edhe si parametra të funksioneve.

Parametrat formalë dhe ata aktualë duhet të përputhen mes vete për nga: numri tipi radha

71. Të shkruhet programi në të cilin deklarohet struktura student(emri,

indeksi, seksioni dhe semestri). Më pas të deklarohet variabla e strukturës dhe të iniciohet me vlera. Shtypja e shënimeve të studentit të bëhet përmes funksionit shtyp i cili si parametër ka strukturën studenti.

#include<iostream>

www.e-Libraria.com


79

using namespace std; struct studenti char emri[20]; int indeksi; char seksioni; int semestri; ; void shtyp(studenti); int main( ) studenti stud="Eugen",902012,'K',3; cout<<"\nShenimet për studentin e zgjedhur janë:\n"<<endl; shtyp(stud); system("pause"); return 0; void shtyp(studenti st) cout<<"Emri:\t\t "<<st.emri<<endl; cout<<"Indeksi:\t "<<st.indeksi<<endl; cout<<"Seksioni:\t "<<st.seksioni<<endl; cout<<"Semester:\t "<<st.semestri<<endl; 72. Të shkruhet programi në të cilin deklarohet struktura pikat. Kjo

strukturë të jetë parametër i funksionit distanca i cili kthen si rezultat distancën në mes dy pikave.

#include <iostream> using namespace std; struct pikat double x1, y1, x2, y2 ; pika; double distanca(pikat p) return sqrt(pow(p.x2 -‐ p.x1, 2) + pow(p.y2 -‐ p.y1, 2)); int main() pika.x1=3; pika.y1=4; pika.x2=6; pika.y2=7; cout<<"Distanca ne mes pikave (" << pika.x1 <<"," << pika.x2 <<") dhe ("<< pika.y1<<","<< pika.y2 <<") = "

www.e-Libraria.com


80

<<distanca (pika) << endl ; system("pause"); return 0;

4.14. Disa nënprograme njëkohësisht Variablat e strukturave pa ndonjë kufizim mund të përdoren njëkohësisht në shumë nënprograme.

73. Të shkruhet programi për llogaritjen e shprehjes vijuese

h=3max(a,b)+(2m+n)!-‐5. Vlerat a dhe b të ruhen në strukturën alfa, kurse vlerat m dhe n të ruhen në strukturën beta. Për llogaritjen e maksimumit të përdoret funksioni max() i cili si parametër hyrës ka strukturën alfa, kurse funksioni fakt() i cili si parametër hyrës ka strukturën beta të përdoret për llogaritjen e faktorielit.

#include <iostream> using namespace std; struct alfa double a,b;; struct beta int m,n;; double max(alfa m) if (m.a>m.b) return m.a; else return m.b; double fakt(beta fa) int i; double F=1;

www.e-Libraria.com


81

for (i=1;i<=(2*fa.m+fa.n);i++) F=F*i; return F; int main() int m=2,n=1; double h; alfa al=5,6; beta be=m,n; h=3*max(al)+fakt(be)-‐5; cout << "\nVlera e funksionit h="<< h << "\n\n"; system("pause"); return 0; 74. Të shkruhet programi dhe të krijohet struktura artikulli (emri, cmimi,

sasia). Struktura të iniciohet me vlera të çfarëdoshme në funksionin main. Më pas, çmimi dhe sasia të rriten përmes funksionit ndrysho(), kurse totali të llogaritet përmes funksionit totali(). Në fund të shtypen vlerat e ndryshuara të artikullit.

#include <iostream> using namespace std; struct artikulli char emri[20]; float cmimi; int sasia; ; artikulli ndrysho (artikulli art, float cm, int sas); float totali(artikulli stoku); int main() float c_rritja, tot; int s_rritja; artikulli art = "Buka", 0.40, 120; cout<<"\nPër sa don ta rritesh çmimin?:"; cin >>c_rritja; cout<<"Për sa don ta shtosh sasine?:"; cin >>s_rritja; art = ndrysho(art, c_rritja, s_rritja); cout<<"\nShënimet e artikullit pas ndryshimeve\n" <<"-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐" <<"\nEmri :"<<art.emri <<"\nmimi :"<<art.cmimi <<"\nSasia :"<<art.sasia; tot = totali(art);

www.e-Libraria.com


82

cout<<"\nTotali :"<< tot<<endl; system("pause"); return 0; artikulli ndrysho(artikulli art, float cm, int sas) art.cmimi += cm; art.sasia += sas; return(art); float totali(artikulli stoku) return(stoku.cmimi * stoku.sasia);

4.15. Funksionet në komponentët e strukturave Përveç variablave, në komponentët e strukturave mund të paraqiten edhe funksionet. Forma e përgjithshme e strukturës është:

4.15.1. Pa parametra formalë

Nëse brenda funksioneve shfrytëzohen vetëm variablat e komponentëve të strukturës ku ato krijohen, në kllapat e tyre nuk shënohet asnjë parametër formal.

www.e-Libraria.com


83

75. Të shkruhet programi përmes të cilit llogaritet distanca në mes dy pikave. Për llogaritje të shfrytëzohet struktura pika dhe funksioni distanca i cili është i deklaruar brenda strukturës pika.

#include <iostream> using namespace std; struct pika int x1,x2; int y1,y2; double distanca() return sqrt(pow(x2-‐x1,2.)+pow(y2-‐y1,2.)); p; int main() pika p; double d; cout<< "\nPika 1:\nx1= "; cin >> p.x1; cout<< "y1= "; cin >> p.y1; cout<< "\nPika 2:\nx2= "; cin >> p.x2; cout<< "y2= "; cin >> p.y2; d=p.distanca(); cout << "\nDistanca d=" << d << "\n\n"; return 0;

4.15.2. Me parametra formalë Nëse funksionet që paraqiten në komponentët e strukturave shfrytëzojnë variabla që nuk përfshihen në strukturë, ato duhet të shënohen si parametra formalë.

www.e-Libraria.com


84

76. Të shkruhet programi përmes të cilit llogaritet shprehja e mëposhtme. Për llogaritje të shfrytëzohen struktura alfa dhe funksioni beta i cili është i deklaruar brenda strukturës alfa.

#include <iostream> using namespace std; struct alfa int a,b; double beta(double x,double y) int i; if (x>y) return a*x+y; else return 6*x-‐2*b; ; ; int main() alfa str; double x,y,z; cout << "Vlera x= "; cin >> x; cout << "Vlera a= "; cin >> str.a; cout << "Vlera b= "; cin >> str.b; cout << "Vlera y: "; cin >> y; z=str.beta(x,y); cout << "\nVlera e llogaritur z=" << z << "\n\n"; system("pause"); return 0;

77. Të shkruhet programi përmes të cilit llogaritet shprehja e mëposhtme. Për llogaritje të shfrytëzohen struktura alfa dhe funksioni beta i cili është i deklaruar jashtë strukturës alfa.

#include <iostream> using namespace std; struct alfa int a,b;

www.e-Libraria.com


85

double beta(double x,double y); ; double alfa::beta(double x,double y) int i; if (x>y) return a*x+y; else return 6*x-‐2*b; ; int main() alfa str; double x,y,z; cout << "Vlera x= "; cin >> x; cout << "Vlera a= "; cin >> str.a; cout << "Vlera b= "; cin >> str.b; cout << "Vlera y: "; cin >> y; z=str.beta(x,y); cout << "\nVlera e llogaritur z=" << z << "\n\n"; system("pause"); return 0; 78. Të shkruhet programi përmes të cilit llogaritet shprehja e mëposhtme.

Për llogaritje të shfrytëzohen struktura gama dhe funksioni shuma i cili është i deklaruar jashtë strukturës gama.

#include <iostream> using namespace std; struct gama double x; int n; double shuma(); ; double gama::shuma() int i; double s=0; for (i=1;i<=(n-‐1);i++) s=s+(2*i-‐1); return x/3+s; ;

www.e-Libraria.com


86

int main() gama str; double y; cout << "\nx= "; cin >> str.x; cout << "n= "; cin >> str.n; y=str.shuma(); cout << "\nVlera e llogaritur y=" << y << "\n\n"; system("pause"); return 0;

4.16. Fushat në struktura Në komponentët e strukturave mund të vendosen edhe fusha numerike (vektor, matrica...). Rezervimi i vendeve të nevojshme për fushat bëhet përmes deklarimit të një konstanteje para krijimit të strukturave.

79. Të shkruhet programi në të cilin krijohet struktura vleresimi e cila si

komponentë e ka vektorin notat të madhësisë m. Vektori notat të iniciohet me vlera dhe më pas të shtypen vlerat e tij.

#include <iostream> #include <iomanip> using namespace std; const int m=10; struct vleresimi int notat[m]; ; int main() int i; double x; vleresimi vlera = 8,6,9,10,5,10,9; cout << "\nAnetaret e vektorit notat\n"; for (i=0;i<m;i++) cout<< setw(4)

www.e-Libraria.com


87

<< i << setw(10) << vlera.notat[i] << "\n"; system("pause"); return 0; 80. Të shkruhet programi në të cilin krijohet struktura fiek e cila si

komponentë e ka vektorin notat me madhësi m. Duke përdorur funksionin mesatare i cili është i deklaruar brenda strukturës, të gjendet nota mesatare. Në fund të shtypen notat dhe nota mesatare.

#include <iomanip> #include <iostream> using namespace std; const int m=6; struct fiek int notat[m]; float mesatare(); ; int main() int i; fiek Vlera = 10,9,8,9,10,7; cout<< "\nNotat" << "\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; for (i=0;i<m;i++) cout << setw(4) << i << setw(10) << Vlera.notat[i] <<endl; cout<< "\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n" << "Nota mesatare nm= " << Vlera.mesatare() << "\n\n"; system("pause"); return 0; float fiek::mesatare() float nm=notat[0]; int i; for (i=1;i<m;i++) nm=nm+notat[i]; nm=nm/m; return nm; ;

www.e-Libraria.com


88

4.17. Fushat e strukturave Mund të krijohen edhe fusha të strukturave, ngjashëm si fushat e zakonshme. Në një element të fushës përfshihen të dhënat e të gjitha komponentëve përkatëse të strukturës.

81. Të shkruhet programi në të cilin deklarohet vektori i strukturës,

studenti[n], i tipit personi. Struktura personi të përmbajë komponentët emri, mbiemri dhe vitilindjes. Të dhënat për n-‐studentë të lexohen nga tastiera dhe më pas të shtypen ato të dhëna.

#include <iostream> #include <iomanip> using namespace std; struct personi char emri[15], mbiemri[20]; int vitilindjes; ; int main() const int n=3; int i; personi studenti[n]; cout << "\nTë dhenat nga tastiera\n\n"; for (i=0;i<n;i++) cout << "Emri dhe mbiemri: "; cin >> studenti[i].emri>> studenti[i].mbiemri; cout << "Viti i lindjes: "; cin >> studenti[i].vitilindjes; cout << "\n"; cout << "\nTë dhenat e lexuara\n\n" << "Emri dhe mbiemri VitiLindjes" << "\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; for (i=0;i<n;i++) cout<< studenti[i].emri <<" " <<studenti[i].mbiemri; cout << setw(15) << studenti[i].vitilindjes << endl; cout << "-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n\n"; system("pause"); return 0;

www.e-Libraria.com


89

5. Klasat Klasa është një mënyrë për të lidhur të dhënat dhe funksionet së bashku. Klasa është koleksion i një numri të caktuar të komponentëve e të cilat komponentë quhen anëtarë të klasës. Me fjalë tjera, klasat janë strukturat + funksionet. Derisa qasja e nënkuptuar (ang. default access) të strukturat është publike (ang. public), të klasat, qasje e nënkuptuar është private (ang. private).

5.1. Krijimi i klasave të zakonshme Krijimi i klasës fillon me fjalën çelës (keyword) class.

82. Të krijohet klasa me emrin personi e cila përmban emrin, mbiemrin,

qytetin dhe vitin e lindjes. class personi public: char emri[15]; char mbiemri[20]; char qyteti[20]; int vitilindjes; ;

5.2. Deklarimi i objekteve Objekti është një instancë e klasës. Deklarimi bëhet sikurse edhe deklarimi i variablave të tjera. Sintaksa e deklarimit të objektit është:

www.e-Libraria.com


90

Gjatë krijimit të një klase nuk rezervohet memorie, memoria rezervohet për variablen e klasës, d.m.th gjatë deklarimit të objektit. 83. Për klasën e krijuar në shembullin paraprak të deklarohet objekti me

emrin studenti1.

#include <iostream> using namespace std; class personi public: char emri[15]; char mbiemri[20]; char qyteti[20]; int vitilindjes; ; int main() personi studenti1; return 0;

5.3. Qasja në komponentët e klasës Qasja në anëtarët e klasës bëhet duke përdorur operatorin . (pikë).

Shembull, për klasën studenti, është deklaruar objekti studenti1 dhe është bërë qasja në anëtarin emri.

84. Të iniciohen me vlera anëtarët e klasës së dhënë personi në shembullin

paraprak. Më pas të shtypen vlerat e anëtarëve. www.e-Libraria.com


91

#include <iostream> using namespace std; class personi public: char emri[15]; char mbiemri[20]; char qyteti[20]; int vitilindjes; ; int main() personi studenti1; cout << "\nShëno të dhënat e studentit\n"; cout << "Emri dhe mbiemri: "; cin >> studenti1.emri>>studenti1.mbiemri; cout << "Qyteti: "; cin >> studenti1.qyteti; cout << "Viti i lindjes: "; cin >> studenti1.vitilindjes; cout << "\n\nTë dhënat e lexuara\n"; cout<< "\nEmri dhe mbiemri: " << studenti1.emri << " " << studenti1.mbiemri; cout << "\nQyteti: " << studenti1.qyteti; cout << "\nViti i lindjes: " << studenti1.vitilindjes << "\n\n"; return 0; 85. Të shkruhet programi, përmes së cilit krijohet klasa artikulli në

anëtarët e së cilës paraqiten ID, Emërtimi, Sasia dhe Çmimi. Vlerat e anëtarëve të iniciohen duke i lexuar përmes tastierës dhe më pas të shtypen këto vlera.

#include<iostream> #include <iomanip> using namespace std; class artikulli public: int id; char emertimi[15]; double sasia; double cmimi; ; int main() artikulli art; cout << "\nShëno të dhënat e artikullit\n"; cout << "ID: ";

www.e-Libraria.com


92

cin >> art.id; cout << "Emertimi: "; cin >> art.emertimi; cout << "Sasia: "; cin >> art.sasia; cout << " imi: "; cin>> art.cmimi; cout<<"\nTë dhënat e artikullit\n" <<"-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐" <<"\nID:" << setw (10)<<"Emri" << setw (15) <<"Sasia" <<setw (10) <<"Cmimi\n" <<"-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n" <<art.id <<setw (10)<<art.emertimi <<setw (15)<<art.sasia <<setw (10)<<art.cmimi <<endl; system("pause"); return 0;

5.4. Forma e përgjithshme e klasave Anëtarët e klasave janë të klasifikuar në tri kategori: public, private dhe protected.

Në C++, fjalët private, protected, dhe public janë fjalë të rezervuara dhe quhen specifikuesit e qasjes. Nëse anëtari i klasës është variabël, deklarimi bëhet njëjtë sikurse variablat tjera. Gjatë krijimit të klasës, variabla nuk mund të iniciohet. Nëse anëtari i klasës është funksion, përdoret prototipi i funksionit për të deklaruar atë anëtar. Zakonisht, anëtarët me të dhëna deklarohen si privat, kurse funksionet si publike. Skema e mëposhtme paraqet pjesën private dhe publike të klasës. Shihet qartë se tek anëtarët privat nuk lejohet hyrja apo qasja nga jashtë klasës, por atyre anëtarëve duhet qasur përmes funksioneve që janë të pjesa publike.

www.e-Libraria.com


93

86. Të shkruhet programi, përmes të cilit krijohet klasa katrori në

anëtarët e së cilës paraqitet variabla private, krahu dhe variabla publike, varpub, si dhe funksionet publike vendos_vleren dhe lexo_vleren. Në funksionin main të implementohet vendosja dhe leximi i vlerave përmes variablës private dhe publike.

#include <iostream> using namespace std; class katrori private: int krahu; public: int varpub; void vendos_vleren(int k) krahu = k; int lexo_vleren() return krahu; ; int main() katrori kat; cout << "Vlera e brinjes a: "; cin>>kat.varpub; kat.vendos_vleren(55); cout<<"Vlera e variablës publike = " <<kat.varpub; cout << "\nVlera e variablës private = " << kat.lexo_vleren() << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


94

5.5. Shfrytëzimi i funksioneve brenda klasës Edhe tek klasat (sikurse edhe tek strukturat), funksionet mund të krijohen jashtë trupit të klasave, por, brenda klasave duhet të shënohen prototipat e funksioneve.

87. Të shkruhet programi, përmes së cilit krijohet klasa rrethi. Brenda

klasës të krijohet rrezja si private dhe prototipat e funksioneve si publike. Funksionet vendos_rrezen dhe siperfaqja të implementohen jashtë klasës

#include <iostream> using namespace std; const double pi=3.1415; class rrethi private: double rrezja; public: void vendos_rrezen(double); double siperfaqja(); ; void rrethi::vendos_rrezen(double r) rrezja = r; double rrethi::siperfaqja() return pi * rrezja * rrezja ; int main() rrethi rr; rr.vendos_rrezen(5.6); cout<<"Siperfaqja e rrethit = " <<rr.siperfaqja() << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


95

88. Të shkruhet programi, përmes të cilit krijohet klasa katerkendeshi në komponentët e së cilës paraqitet variablat private, gjatesia dhe lartesia si dhe funksionet publike, vendos_gjatesine, vendos_lartesine, siperfaqja dhe perimetri. Në funksione të llogaritet sipërfaqja, respektivisht perimetri i katërkëndëshit kënddrejtë.

#include <iostream> #include <iomanip> using namespace std; class katerkendeshi public: double perimetri() return 2 * ( gjatesia + lartesia ); ; double siperfaqja() return gjatesia * lartesia; ; void vendos_gjatesine( double g ) gjatesia = g ; void vendos_lartesine(double l) lartesia = l; private: double lartesia; double gjatesia; ; int main() katerkendeshi kater; kater.vendos_gjatesine(5.5); kater.vendos_lartesine(3.4); cout<<"Perimetri = " <<kater.perimetri() <<"\nSiperfaqja = " <<kater.siperfaqja() << endl; system("pause"); return 0;

5.6. Forma të tjera të inicimit të variablave

Skema e mëposhtme paraqet inicimin përmes leximit. Duke përdorur funksionin leximi, vlera e variablës private a iniciohet me një vlerë të dhënë përmes tastierës.

www.e-Libraria.com


96

Një formë tjetër e inicimit të variablave është edhe gjatë deklarimit të objektit të klasës. Në skemën e mëposhtme është deklaruar klasa me emrin klasa dhe më pas tek funksioni main është deklaruar objekti kl dhe është iniciuar me vlera.

89. Të krijohet klasa me emrin inicimi e cila përmban variablën private me

emrin variabla dhe dy funksione publike, leximi për inicimin e variablës dhe funksioni shtypja për shtypjen e vlerës së variablës.

#include<iostream> using namespace std; class inicimi private: int variabla; public: void leximi(); void shtypja(); ; void inicimi::leximi() cout << "Jep nje vlere per variablen: "; cin >> variabla; void inicimi::shtypja() cout<< "Variabla e dhënë përmes funksionit leximi: " << variabla << "\n"; int main() inicimi objekti; objekti.leximi(); objekti.shtypja(); system("pause"); return 0;

www.e-Libraria.com


97

90. Të krijohet klasa me emrin inicimi_direkt e cila përmban tri variabla publike të cilat do të inicohen gjatë deklarimit të objektit të klasës. Më pas, përmes funksionit shtypja të shtypen vlerat e variablave.

#include<iostream> using namespace std; class inicimi_direkt public: int x1,x2; double y; void shtypja(); ; void inicimi_direkt::shtypja() cout << "\nVlera e x1=" << x1 << "\nVlera e x2=" << x2 << "\nVlera e y=" << y << "\n\n"; int main() inicimi_direkt ini_d=16,4,20.13; ini_d.shtypja(); system("pause"); return 0; 91. Të shkruhet programi, përmes të cilit krijohet klasa data në

komponentët e së cilës paraqitet variablat private, p_dita, p_muaji dhe p_viti si dhe prototipat e funksioneve për vendosje dhe lexim të ditës, muajit dhe vitit. Funksionet për vendosje dhe lexim të datës të implementohen jashtë klasës data. Në funksionin main të deklarohet një objekt i klasës dhe të shtypet një datë e caktuar.

#include <iostream> using namespace std; class data private: //variablat private int p_dita; int p_muaji; int p_viti; public: int l_dita(); int l_muaji(); int l_viti(); void muaji(int);

www.e-Libraria.com


98

void dita(int); void viti(int); ; int data::l_dita()return p_dita; int data::l_muaji()return p_muaji; int data::l_viti()return p_viti; void data::muaji(int f_muaji) p_muaji=f_muaji; ; void data::dita(int f_dita) p_dita=f_dita; ; void data::viti(int f_viti) p_viti=f_viti; ; int main() data dt; //vendosa e vlerave dt.dita(27); dt.muaji(2); dt.viti(2008); //leximi i vlerave cout << dt.l_dita() << "." << dt.l_muaji() << "." << dt.l_viti() << endl; system("pause"); return 0;

5.7. Shfrytëzimi i vlerave të variablave private Qasja direkte në variablat private të klasës nuk lejohet. Për shfrytëzimin e tyre, duhet të krijohen funksione të veçanta brenda klasës, të deklaruara si publike. Këto funksione mund të jenë: pa parametra formalë ose me parametra referentë. 92. Të shkruhet programi në të cilin krijohet klasa artikulli. Klasa

artikulli si anëtarë privat e ka variablen kodi, kurse si anëtarë publik i ka funksionet leximi, shtypja dhe funksionin merr_vleren i cili e merr vlerën e anëtarit privat dhe e ruan tek një variabël jashtë klasës.

www.e-Libraria.com


99

#include <iostream> using namespace std; class artikulli int kodi; public : void leximi(); void shtypja(); int merr_vleren(); ; void artikulli::shtypja() cout << "Kodi=" << kodi << "\n\n"; void artikulli::leximi() cout << "Jep vlerën e kodit: "; cin >> kodi; int artikulli::merr_vleren() return kodi; int main() int k; artikulli art; art.leximi(); k=art.merr_vleren(); cout<<"Vlera e kodit është ruajtur tek k-‐ja; k=" << k << "\n"; art.shtypja(); system("pause"); return 0; 93. Të modifikohet shembulli paraprak dhe funksioni merr_vleren të ketë si

parametër referent variablen e deklaruar jashtë klasës. #include <iostream> using namespace std; class artikulli int kodi; public : void leximi(); void shtypja(); int merr_vleren(int& k); ; void artikulli::shtypja()

www.e-Libraria.com


100

cout << "Kodi=" << kodi << "\n\n"; void artikulli::leximi() cout << "Jep vlerën e kodit: "; cin >> kodi; int artikulli::merr_vleren(int& k) return kodi; int main() int k; artikulli art; art.leximi(); k=art.merr_vleren(k); cout<<"Vlera e kodit është ruajtur tek k-‐ja; k=" << k << "\n"; art.shtypja(); system("pause"); return 0;

5.8. Llogaritjet me variabla të klasës Variablat që paraqiten në anëtarët e klasës mund të shfrytëzohen për llogaritje të ndryshme. Shfrytëzimi i variablave të klasës varet nga ajo se a janë deklaruar anëtarët përkatës si publik ose privat. Nëse anëtarët e klasës janë publik, mund të shfrytëzohen duke e shënuar para tyre emrin e objektit përkatës dhe pikën. Nëse anëtarët e klasës janë privat, ata mund të shfrytëzohen vetëm përmes funksioneve brenda klasës. 94. Të shkruhet programi në të cilin krijohet klasa llogaritja për

llogaritjen e shprehjes së mëposhtme. Variabla n është private, kurse variabla m është publike.

#include <iostream> using namespace std; class llogaritja private: int n;

www.e-Libraria.com


101

public: int m; void leximi(); void shtypja(); int merr_vleren(); ; int main() int p; double y=0; llogaritja llog; llog.leximi(); cout << "Jep vleren e variables publike m: "; cin >> llog.m; llog.shtypja(); p=llog.merr_vleren(); for (int i=0;i<=(llog.m+p);i++) y=y+(3*i+2*p); y=llog.m+y; cout<< "\nVlera e funksionit y=" << y << "\n\n"; system("pause"); return 0; void llogaritja::leximi() cout << "Jep vleren e variables private n: "; cin >> n; void llogaritja::shtypja() cout<< "\nVlera e variables private n="<< n << "\nVlera e variables publike m=" << m << "\n"; int llogaritja::merr_vleren() return n;

5.9. Shfrytëzimi i funksioneve brenda klasës Funksionet mund të paraqiten në pjesën publike ose private të klasës. Nëse funksionet janë përfshirë tek pjesa publike, shfrytëzimi i tyre si brenda, ashtu edhe jashtë klasës nuk ka asnjë kufizim. Mirëpo një funksion i cili është anëtar privat, mund të thirret vetëm nga një tjetër funksion i cili është anëtar i së njëjtës klasë. Funksioni privat nuk mund të thirret përmes objektit dhe operatorit pikë (.)

www.e-Libraria.com


102

95. Të modifikohet shembulli paraprak dhe shprehja e mëposhtme të llogaritet duke shfrytëzuar funksionin publik shuma i cili është brenda klasës llogaritja.

#include <iostream> using namespace std; class llogaritja private: int n; public: int m; void leximi(); void shtypja(); double shuma(int m, int n); int merr_vleren(); ; int main() int p; double y=0; llogaritja llog; llog.leximi(); cout << "Jep vleren e variables publike m: "; cin >> llog.m; llog.shtypja(); p=llog.merr_vleren(); y=llog.m+llog.shuma(llog.m,p); cout<< "\nVlera e funksionit y=" << y << "\n\n"; system("pause"); return 0; double llogaritja::shuma(int m, int n) double s=0; for (int i=0;i<=(m+n);i++) s=s+(3*i+2*n); return s; void llogaritja::leximi() cout << "Jep vlerën e variablës private n: "; cin >> n; void llogaritja::shtypja()

www.e-Libraria.com


103

cout<< "\nVlera e variablës private n="<< n << "\nVlera e variablës publike m=" << m << "\n"; int llogaritja::merr_vleren() return n; 96. Të modifikohet shembulli paraprak dhe shprehja e mëposhtme të

llogaritet duke shfrytëzuar funksionin privat shuma i cili është brenda klasës llogaritja.

#include <iostream> using namespace std; class llogaritja private: int n,m; double shuma(int m, int n); public: void leximi(); void shtypja(); double thirr_shumen(); ; int main() int p; double y=0; llogaritja llog; llog.leximi(); y=llog.thirr_shumen(); llog.shtypja(); cout<< "\nVlera e funksionit y=" << y << "\n\n"; system("pause"); return 0; double llogaritja::thirr_shumen() return shuma(m,n); double llogaritja::shuma(int m, int n) double s=0; for (int i=0;i<=(m+n);i++) s=s+(3*i+2*n); return m+s; void llogaritja::leximi() cout << "Jep vlerën e variablës m dhe n: ";

www.e-Libraria.com


104

cin >> m>>n; void llogaritja::shtypja() cout<< "\nVlera e variablës n="<< n << "\nVlera e variablës m="<< m << "\n"; 97. Të shkruhet programi në të cilin krijohet klasa llogaritja për

llogaritjen e shprehjes së mëposhtme. Llogaritja e shprehjes të kryhet përmes një funksioni publik të quajtur shuma i cili është brenda klasës llogaritja. Variabla n është private, kurse variabla m është publike.

#include <iostream> using namespace std; class llogaritja private: int n; public: int m; void leximi(); void shtypja(); double shuma(int a, int b, int c, int d ); int merr_vleren(); ; int main() int p; double y=0; llogaritja llog; llog.leximi(); cout << "Jep vleren e variables publike m: "; cin >> llog.m; llog.shtypja(); p=llog.merr_vleren(); y=llog.m+llog.shuma(0,llog.m+p,3,2) + llog.shuma(3,llog.m,1,0); cout<< "\nVlera e funksionit y=" << y << "\n\n"; system("pause"); return 0; double llogaritja::shuma(int a, int b, int c, int d) double s=0; for (int i=a;i<=b;i++)

www.e-Libraria.com


105

s=s+(c*i+d); return s; void llogaritja::leximi() cout << "Jep vlëren e variables private n: "; cin >> n; void llogaritja::shtypja() cout<< "\nVlera e variablës private n="<< n << "\nVlera e variablës publike m=" << m << "\n"; int llogaritja::merr_vleren() return n; 98. Të shkruhet programi në të cilin krijohet klasa llogaritja për

llogaritjen e shprehjes së mëposhtme. Llogaritja e shprehjes të kryhet përmes një funksioni privat të quajtur prodhimi i cili është brenda klasës llogaritja. Variabla n është private.

#include <iostream> using namespace std; class llogaritja private: int n; double prodhimi(); public: void vendos_vlerat(); void shtypja(); double thirr_prodhimin(); ; int main() double y=0; llogaritja llog; llog.vendos_vlerat(); y=llog.thirr_prodhimin(); llog.shtypja(); cout<< "\nVlera e funksionit y=" << y << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


106

double llogaritja::prodhimi() double p=1; for (int i=1;i<=n;i++) p=p*(2*i); return p; void llogaritja::vendos_vlerat() cout << "Jep vleren e variablës n: "; cin >> n; double llogaritja::thirr_prodhimin() return prodhimi(); void llogaritja::shtypja() cout<< "\nVlera e variablës n ="<< n << "\n"; 99. Të shkruhet programi në të cilin krijohet klasa FormatiDates. Klasa të

ketë anëtarët për mbajtjen e ditës, muajit dhe vitit si dhe funksionet për vendosjen dhe marrjen e këtyre vlerave. Të deklarohet disa objekte të klasës dhe përmes konstruktorit të thirret funksioni për vendosjen e datës. Nëse data është gabim të vendoset në 1.1.1900. Funksioni për shfaqjen/shtypjen e datës të ketë disa opsione të shtypjes si p.sh dd.mm.vvv, dd/mm/vvvv etj.

#include <iostream> #include <string> using namespace std; class FormatiDates private: int muaji; int dita; int viti; public: void vendosDaten(int d, int m, int v); int merrDiten(); int merrMuajin(); int merrVitin(); void shfaqDaten(string formati); FormatiDates(int m = 1, int d = 1, int v = 1900); bool vitiBrishte(int); ; void FormatiDates::vendosDaten(int d,int m, int v) bool gabim=false; int shkurt=28;

www.e-Libraria.com


107

switch(m) //muaji 1, 3, 5, 7, 8, 10, 12 i kanë nga 31 ditë case 1 : case 3 : case 5 : case 7 : case 8 : case 10: case 12: if (d > 31) gabim=true; break; case 4 : //muaji 4, 6, 9 dhe 11 i kanë nga 30 ditë case 6 : case 9 : case 11: if (d > 30) gabim=true; break; case 2 : //muaji 2 i ka 28 ose 29 ditë if(vitiBrishte(v)) shkurt=29; if(d>shkurt) gabim=true; if(gabim) cout<<"Data "<<d<<"/"<<m<<"/"<<v<<" është jo valide. Do të përdoret 1/1/1900\n"; d=1; m=1; v=1900; dita = d; muaji = m; viti = v; bool FormatiDates::vitiBrishte(int v) if((v%4==0 && v!=0)|| v==0) return true; return false; int FormatiDates::merrDiten() return dita; int FormatiDates::merrMuajin() return muaji; int FormatiDates::merrVitin() return viti;

www.e-Libraria.com


108

void FormatiDates::shfaqDaten(string formati) if (formati=="dd.mm.vvvv") cout << dita << "." << muaji << "." << viti; else if(formati=="mm.dd.vvvv") cout << muaji << "." << dita << "." << viti; else if(formati=="dd/mm/vvvv") cout << dita << "/" << muaji << "/" << viti; else if(formati=="dd-‐mm-‐vvvv") cout << dita << "-‐" << muaji << "-‐" << viti; else cout << dita << "/" << muaji << "/" << viti; FormatiDates::FormatiDates(int d,int m, int v) vendosDaten(d, m, v); int main() FormatiDates d1(29,2,2010); cout<<"Data e parë: "; d1.shfaqDaten("dd.mm.vvvv"); cout<<endl; FormatiDates d2(17,02,2008); cout<<"Data e dytë: "; d2.shfaqDaten("dd/mm/vvvv"); cout<<endl; system("pause"); return 0;

5.10. Konstruktorët Konstruktori është një funksion anëtar i cili inicion variablat në brendësi të klasës. Konstruktori mënjanon nevojën e inicimit të variablave sa herë që krijohet një objekt i ri. Konstruktori e ka emrin e njëjtë si vetë klasa por nuk ka tip kthyes. Konstruktori thirret automatikisht sa herë që krijohet një instancë e klasës. Nëse nuk krijohet konstruktori, kompajleri do ta krijojë

në vlerën null.

5.10.1. Konstruktorët pa parametra formalë Konstruktorët mund të mos kenë parametra formalë, nëse përcaktimi i vlerave të variablave në anëtarët privat bëhet brenda konstruktorëve.

www.e-Libraria.com


109

100. Të shkruhet programi përmes së cilit llogaritet sipërfaqja s dhe

perimetri p i rrethit me rreze r. Për inicimin e konstantes pi, brenda klasës rrethi, e cila krijohet në program të shfrytëzohet konstruktori përkatës i klasës.

#include <iostream> using namespace std; class rrethi private: double pi,r,s,p; public: rrethi(); //konstruktori void rrezja(double x); void llogaritja(); void shtypja(); ; int main() rrethi rr; double x; cout << "\nRrezja e rrethit x: "; cin >> x; rr.rrezja(x); rr.llogaritja(); rr.shtypja(); system("pause"); return 0; rrethi::rrethi() //thirret gjate deklarimit te instances se klases pi=3.1415926; void rrethi::rrezja(double x) r=x; void rrethi::llogaritja()

www.e-Libraria.com


110

s=pi*r*r; p=2*pi*r; void rrethi::shtypja() cout<< "\nSiperfaqja s="<<s << "\n\nPerimetri p="<<p<< "\n";

5.10.2. Konstruktorët me parametra formalë Konstruktori (default) nuk ka parametra, por nëse nevojiten ai mund të ketë. Kjo ndihmon për inicimin e vlerave gjatë kohës së deklarimit të një instance të re (objekti).

101. Të modifikohet shembulli paraprak dhe për inicimin e konstantes pi dhe

rrezes r të përdoret konstruktori me rrezen e rrethit si parametër formal. #include <iostream> using namespace std; class rrethi private: double pi,r,s,p; public: rrethi(double x); //konstruktori me parametra formale void llogaritja(); void shtypja(); ; int main() double x; cout << "\nRrezja e rrethit x: "; cin >> x; rrethi rr(x); rr.llogaritja(); rr.shtypja(); system("pause"); return 0;

www.e-Libraria.com


111

rrethi::rrethi(double x) //thirret gjate deklarimit te instances se klases pi=3.1415926; r=x; void rrethi::llogaritja() s=pi*r*r; p=2*pi*r; void rrethi::shtypja() cout<< "\nSiperfaqja s="<<s << "\nPerimetri p="<<p<< "\n"; 102. Të shkruhet programi dhe të krijohet klasa NumratKompleks për mbledhjen

dhe zbritjen e numrave kompleks. Vendosja e pjesës reale dhe imagjinare të mundësohet përmes konstruktorit me dy parametra si dhe përmes funksionit vendosNumrin i cili ka parametra pjesën reale dhe imagjinare të numrit kompleks. Në funksionin main të kryhet mbledhja për dy numra të vendosur përmes konstruktorit, kurse zbritja të kryhet përmes dy numrave të vendosur përmes funksionit vendosNumrin.

#include <iostream> using namespace std; class NumratKompleks private: double Reale; double Imagjinare; public: NumratKompleks(double = 0.0, double = 0.0); void mbledhja(NumratKompleks &a ); void zbritja(NumratKompleks &a ); void shtyp(); void vendosNumrin(double r, double i); ; NumratKompleks::NumratKompleks(double reale, double imagjinare) vendosNumrin(reale, imagjinare); void NumratKompleks::mbledhja(NumratKompleks &a) Reale += a.Reale; Imagjinare += a.Imagjinare; void NumratKompleks::zbritja(NumratKompleks &s)

www.e-Libraria.com


112

Reale -‐= s.Reale; Imagjinare -‐= s.Imagjinare; void NumratKompleks::shtyp() cout << '(' << Reale << ", " << Imagjinare << ')'; void NumratKompleks::vendosNumrin(double r, double i ) Reale = r; Imagjinare = i; int main() //përmes konstruktorit NumratKompleks nr1(2, 7.5), nr2(4.2, 2.3 ); nr1.shtyp(); cout << " + "; nr2.shtyp(); cout << " = "; nr1.mbledhja(nr2); nr1.shtyp(); cout << '\n'; //përmes funksionit vendosNumrin nr1.vendosNumrin(10, 1.5); nr2.vendosNumrin(8.5, 5); nr1.shtyp(); cout << " -‐ "; nr2.shtyp(); cout << " = "; nr1.zbritja( nr2 ); nr1.shtyp(); cout << endl; system("pause"); return 0;

5.11. Llogaritjet brenda konstruktorëve Përveç inicimit të variablave, brenda konstruktorëve mund të kryhen edhe llogaritje të ndryshme. Rezultatet e llogaritjeve duhet të përcillen/ruhen tek variablat e përfshira në anëtarët e klasave.

www.e-Libraria.com


113

103. Të shkruhet programi në të cilin krijohet klasa llogaritja. Variablat m

dhe n të deklarohen si private, kurse rezultati i shprehjes të ruhet në variablen publike y. Për inicimin e variablave m dhe n dhe llogaritjen e shprehjes së mëposhtme të përdoret konstruktori i klasës.

#include <iostream> using namespace std; class llogaritja private: int m, n; public: double y; void shtypja(); llogaritja(); //konstruktori ; int main() int p; double y=0; llogaritja llog; llog.shtypja(); system("pause"); return 0; void llogaritja::shtypja() cout<< "\nVlera e variables m="<< m << "\nVlera e variables n=" << n << "\nVlera e funksionit y="<<y <<"\n"; llogaritja::llogaritja()

www.e-Libraria.com


114

cout << "Jep vleren e variables m dhe n: "; cin >> m >>n; double s=0; for (int i=0;i<=(m+n);i++) s=s+(3*i+2*n); y=m+s; 104. Të shkruhet programi përmes së cilit krijohet klasa thjeshte. Duke

shfrytëzuar konstruktorin e klasës i cili ka një parametër formal të kontrollohet nëse numri i dhënë është numër i thjeshtë.

#include<iostream> using namespace std; class thjeshte int nr,i; bool r; public: thjeshte(int x) nr=x; for(i=2;i<=nr/2;i++) if(nr%i==0) r=false; break; else r=true; void shtyp() if(r==true) cout<<"\n"<<nr<<" është numër i thjeshtë."; else cout<<"\n"<<nr<<" nuk është numër i thjeshtë."; cout<<endl; ; int main() int a; cout<<"Sheno nje numer te plote:"; cin>>a; thjeshte obj(a); obj.shtyp(); system("pause"); return 0;

www.e-Libraria.com


115

5.12. Disa konstruktorë njëkohësisht

Klasa mund të ketë më shumë se një konstruktor, por konstruktorët duhet të kenë listë të ndryshme të parametrave formalë. Kjo mundësohet duke përdorur metodën e mbingarkimit.

105. Të shkruhet programi në të cilin krijohet klasa faktorieli dhe

llogariten vlerat e funksioneve të mëposhtme duke shfrytëzuar dy konstruktorë.

#include <iostream> using namespace std; class faktorieli private: int m; double x; public: double g; faktorieli(); faktorieli(int k); ; int main() faktorieli fa1; cout << "Vlera e llogaritur y=" << fa1.g; faktorieli fa2(3); cout << "Vlera e llogaritur z=" << fa2.g << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


116

faktorieli::faktorieli() m=3; cout << "Konstruktori i parë" << "\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐" << "\nVariabla x: "; cin >> x; double F=1; int i; for (i=1;i<=m;i++) F=F*i; g=5*x+F; faktorieli::faktorieli(int k) m=k; cout << "\n\nKonstruktori i dytë" << "\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐" << "\nVariabla x: "; cin >> x; double F=1; int i; for (i=1;i<=(m+1);i++) F=F*i; g=x/2+F;

5.13. Destruktorët Destruktori zakonisht përdoret për lirimin e memories e cila është rezervuar gjatë deklarimit të objekteve. Emri i destruktorit është i njëjtë me emrin e klasës, por para tij vendoset simboli ~ (lexo: tilda). Klasa mund të ketë vetëm një destruktor. Destruktori nuk ka asnjë parametër dhe nuk ka tip kthyes.

106. Të shkruhet programi, dhe të krijohet klasa vlera e cila përmban

funksionet publike për vendosjen dhe marrjen e vlerës së numrit. Numri është variabël private. Të implementohet konstruktori dhe destruktori i klasës në të cilin tregohet se kur po thirret konstruktori dhe kur destruktori.

#include<iostream>

www.e-Libraria.com


117

using namespace std; class vlera int numri; public: void vendos_numrin(int num); int merr_numrin(); vlera() //konstruktori cout<<"\nKonstruktori eshte thirrur \n"; ~vlera() //destruktori cout<<"\nDestruktori eshte thirrur \n"; system("pause"); ; void vlera::vendos_numrin(int nr) numri = nr; int vlera::merr_numrin() return numri; int main() int nr = 2013; vlera obj; obj.vendos_numrin(nr); nr = obj.merr_numrin(); cout<<"\nNumri eshte = "<<nr<<endl; system("pause"); return 0;

5.14. Trashëgimia Trashëgimia është tipar shumë i rëndësishëm në programimin e orientuar në objekte dhe nënkupton ripërdorimin e kodit të krijuar më herët. Me fjalë të tjera trashëgimia është një mekanizëm i ripërdorimit dhe i zgjerimit të klasës ekzistuese pa e modifikuar atë, duke prodhuar marrëdhënie hierarkike midis klasës ekzistuese dhe klasës së re. Pra, përmes trashëgimisë (ang. inheritance), anëtarët e klasës ekzistuese mund të shfrytëzohen për krijimin e klasës së re. Çdo klasë e re trashëgon gjendjen dhe metodat nga klasa prej së cilës është krijuar. Klasa ekzistuese njihet si klasë bazë (ang. Base class), kurse klasa e re e cila i trashëgon karakteristikat e klasës bazë, quhet klasa e derivuar (ang. Derived class). Skema e mëposhtme paraqet një hierarki të trashëgimisë së klasave.

www.e-Libraria.com


118

Klasat e derivuara, përveç variablave dhe metodave të trashëguara, mund të kenë edhe variabla dhe metoda të reja. C + + përkrah lloje të ndryshme të trashëgimisë e të cilat janë: 1. Trashëgimia e vetme 2. Trashëgimia me shumë nivele 3. Trashëgimia e shumëfishtë 4. Trashëgimia hierarkike 5. Trashëgimia hibride Trashëgimia e vetme është kur ekziston vetëm një klasë bazë dhe një klasë e derivuar të cilat kanë një komunikim një me një.

Trashëgimisë me shumë nivele është kur një klasë e derivuar mund të trashëgohet edhe nga një klasë tjetër dhe kështu krijohet nivel i shumëfishtë.

www.e-Libraria.com


119

Trashëgimia e shumëfishtë është kur klasa e derivuar trashëgon tiparet nga dy ose më shumë klasa bazë. Në këtë lloj trashëgimie mund të ketë paqartësi kur më shumë se një klasë përmban një funksion me të njëjtin emër.

Trashëgimia hierarkike është kur klasa bazë ka shumë klasa të derivuara ose kur klasa bazë është përdorur ose trashëguar nga shumë klasa të derivuara.

Trashëgimia hibride është një përzierje e dy ose më shumë trashëgimive në një trashëgimi të vetme.

Forma e përgjithshme e sintaksës për klasën e derivuar është:

Skema e mëposhtme paraqet një shembull të trashëgimisë, ku klasa rrethi është trashëguar nga klasa figurat. Pra rrethi është klasa e derivuar, kurse figurat është klasa bazë.

www.e-Libraria.com


120

107. Të shkruhet programi në të cilin krijohet klasa bazë KlasaBaze dhe

klasa e derivuar KlasaDerivuar. Klasa bazë përmban një variabël private dhe një publike si dhe funksionin për shtypjen e vlerave të këtyre variablave. Klasa e derivuar përmban një variabël private dhe një publike si dhe funksionin për shtypjen e vlerave të variablave të klasës së derivuar dhe variablës publike të klasës bazë.

#include <iostream> using namespace std; class KlasaBaze private: int a; public: double b; void shtyp_baze() a=5; b=8; cout<< "Vlerat e klasës bazë" << "\na="<< a << "\nb="<< b << "\n\n"; ; class KlasaDerivuar:public KlasaBaze private: double c; public: int d; void shtyp_derivuar() b=2; //variabel e klasës bazë c=4; d=7; cout << "Vlerat e klasës së derivuar" << "\nb = "<< b << "\nc = "<< c << "\nd = "<< d << "\n\n"; ; int main() KlasaBaze kb; KlasaDerivuar kd;

www.e-Libraria.com


121

kb.shtyp_baze(); kd.shtyp_derivuar(); system("pause"); return 0; 108. Të shkruhet programi në të cilin krijohet klasa bazë Veturat dhe klasa

e derivuar VeturePolicie. Klasa bazë përmban një variabël private për shpejtësinë dhe funksionet publike për vendosjen dhe marrjen e shpejtësisë. Klasa e derivuar përmban shpejtësinë aktuale dhe nëse vetura është në aksion. Të vendosen vlerat për shpejtësinë, shpejtësinë aktuale dhe nëse vetura është në aksion dhe me pas të shtypen vlerat.

#include <iostream> using namespace std; class Veturat private: int shpejtesia; public: void v_shpejtesine(int sh) shpejtesia=sh; int m_shpejtesine() return shpejtesia; ; class VeturePolicie : public Veturat private: int shpejtesiAktuale; bool aksion; public: void v_shpejtAktuale(int a) shpejtesiAktuale=a; int m_shpejtAktuale() return shpejtesiAktuale; void v_neAksion(bool a) aksion=a; bool m_neAksion() return aksion; ; int main()

www.e-Libraria.com


122

Veturat kb; VeturePolicie kd; kb.v_shpejtesine(260); kd.v_shpejtAktuale(180); kd.v_neAksion(true); if (kd.m_neAksion()==true) cout<<"Vetura e policisë është në aksion\n " <<"dhe po leviz me shpejtesi " <<kd.m_shpejtAktuale() <<"/" <<kb.m_shpejtesine(); else cout<<"Vetura e policisë është në aksion\n" <<"dhe po leviz me shpejtësi " <<kd.m_shpejtAktuale() <<"/" <<kb.m_shpejtesine(); cout<<endl; system("pause"); return 0; 109. Të shkruhet programi në të cilin krijohen klasat pajisjeUSB dhe

pajisjeRrjeti të cilat kanë nga një anëtar privat me të njëjtin emër dhe nga një funksion publik me të njëjtin emër për leximin e vlerës së variablës private. Secila klasë të ketë edhe konstruktorin për vendosjen e vlerës së variablës private. Të krijohet klasa pajisje_wireless e cila trashëgohet nga klasat pajisjeUSB dhe pajisjeRrjeti, pra trashëgimi e shumëfishtë. Tek funksioni main të deklarohet objekti i klasës së derivuar dhe të thirret funksioni për leximin e vlerës së variablës private. Cili funksion do të thirret?

#include <iostream> using namespace std; class pajisjeUSB private: long a_ID; public: pajisjeUSB(long id) : a_ID(id) long m_ID() return a_ID; ; class pajisjeRrjeti private: long a_ID; public: pajisjeRrjeti(long id) : a_ID(id)

www.e-Libraria.com


123

long m_ID() return a_ID; ; class pajisje_wireless: public pajisjeUSB, public pajisjeRrjeti public: pajisje_wireless(long usb_id, long net_id) : pajisjeUSB(usb_id), pajisjeRrjeti(net_id) ; int main() pajisje_wireless RJ45(12345678, 87654321); //cout << RJ45.m_ID(); // Cila m_ID() do të thirret? cout << RJ45.pajisjeUSB::m_ID(); cout<<endl; cout << RJ45.pajisjeRrjeti::m_ID(); system("pause"); return 0;

5.15. Anëtarët statik të klasës Deri me tani u pa se se secili objekt i klasës i ka kopjet e veta të veqanta për të gjithë anëtarët e klasës. Megjithatë ekziston një përjashtim ku vetëm një variabël e caktuar mund të jetë e përbashkët për të gjitha objektet e klasës. Për këtë arsye përdoret një anëtarë statik dhe të gjitha objektet e klasës kanë vetëm një instancë të këtij anëtari. Anëtari statik i klasës mund të thirret edhe pa u krijuar një objekt i klasës. Siç shihet edhe nga skema e mëposhtme janë deklaruar dy objekte ob1 dhe ob2 dhe të dy objektet kanë kopjet e veqanta për anëtarin Y, ob1 ka vlerën 10, kurse ob2 ka vlerën 20. Mirëpo anëtari X është i përbashkët për të dy objektet, pra është vetëm një instancë dhe vlera e këtij anëtari është 5 për të dyja objektet.

www.e-Libraria.com


124

Në bazë të kësaj mund të thuhet se një anëtar statik paraqet apo ruan informacion të gjërë i cili informacion është i përbashkët për të gjitha instancat dhe nuk është specifik për secilin objekt. 110. Të shkruhet programi në të cilin krijohet klasa AnetarStatik me

anëtarët privat rendi dhe anëtarin statik numeruesi. Përmes konstruktorit të nënkuptuar, të rritet numëruesi për një sa herë që krijohet një objekt i klasës dhe të shtypet vlera e numëruesit përmes variablës rendi e cila lexohet përmes funksionit lexoRendi.

#include <iostream> using namespace std; class AnetarStatik private: static int numeruesi; int rendi; public: AnetarStatik() rendi = numeruesi++; int merrRendi() return rendi; ; int AnetarStatik::numeruesi = 1; int main() AnetarStatik ob1; AnetarStatik ob2; AnetarStatik ob3; cout <<"Objekti "<< ob1.merrRendi() <<"\nObjekti "<< ob2.merrRendi()

www.e-Libraria.com


125

<<"\nObjekti "<< ob3.merrRendi() << endl; system("pause"); return 0; 111. Të shkruhet programi në të cilin krijohet klasa kursimet për

llogaritjen e kamatës për paratë e kursyera në llogarinë e kursimeve. Interesi vjetor të ruhet në variablën statike në menyrë që të jetë i njëtë për të gjithë klientët. Të deklarohen dy klient të cilët vendosin shuma të ndryshme të parave në llogarinë e kursimeve dhe më pas të llogaritet interesi për 12 muaj duke e shtypur rezultatin për secilin muaj.

#include <iostream> #include <iomanip> using namespace std; class kursimet private: double bilanciKursimeve; static double InteresiVjetor; public: kursimet(double fillestare) //nëse gjendja fillestare eshte me e vogel se zero vendose 0. bilanciKursimeve = fillestare >= 0 ? fillestare : 0; void interesiMujor(); static void ndryshoInteresinMujor( double ); void shfaqBilancin() ; ; double kursimet::InteresiVjetor = 0.0; void kursimet::interesiMujor() bilanciKursimeve += bilanciKursimeve * ((InteresiVjetor/100)/12.0 ); void kursimet::ndryshoInteresinMujor( double interesi ) //nëse interesi është më I madh se 1.75% vendose ne 1.5 InteresiVjetor = ( interesi >= 0 && interesi <= 1.75 ) ? interesi : 1.5; void kursimet::shfaqBilancin( void ) cout << fixed <<showpoint << setprecision(2) << bilanciKursimeve << fixed <<showpoint ; int main() char v[]="\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; kursimet::ndryshoInteresinMujor(1.5); //inicimi para se të krijohen objektet

www.e-Libraria.com


126

kursimet klienti1(1000), klienti2(1500); //krijimi i dy objekteve cout << "\nBilancet mujore për kursimet me interesi 1.5%" <<v << "Bilanci fillestar i kursimeve: \nKlienti 1 "; klienti1.shfaqBilancin(); cout << "\t\nKlienti 2 "; klienti2.shfaqBilancin(); cout<<v; for (int muaji = 1; muaji <= 12; ++muaji ) klienti1.interesiMujor(); klienti2.interesiMujor(); cout << "\nMuaji" << setw(3) << muaji << "| Klienti 1: "; klienti1.shfaqBilancin(); cout << "\t||\tKlienti 2: "; klienti2.shfaqBilancin(); cout<<v; system("pause"); return 0;

5.16. Shfrytëzimi i anëtarëve të mbrojtur protected

Nëse dëshirohet që anëtarët privat të klasës bazë të përdoren edhe në klasën e derivuar, atëherë këta anëtarë duhet të deklarohen si protected. Anëtarëve të deklaruar si protected nuk mund të iu qaset nga jashtë klasës, por mund të iu qaset nga një klasë e derivuar. 112. Të shkruhet programi në të cilin krijohet klasa bazë figura dhe klasa e

derivuar drejtkendeshi. Klasa bazë përmban anëtarët e mbrojtur gjatesia dhe lartesia si dhe funksionet për vendosjen e këtyre vlerave. Në klasën e derivuar të llogaritet sipërfaqja e drejtkëndëshit, kurse në funksionin kryesor të krijohet objekti i klasës drejtkendeshi dhe të shtypet vlera e sipërfaqes.

#include <iostream> using namespace std; class figura //Klasa bazë protected: int gjatesia; int lartesia; public: void v_gjatesine(int g) gjatesia = g; void v_lartesine(int h)

www.e-Libraria.com


127

lartesia = h; ; class drejtkendeshi: public figura //Klasa e derivuar public: int m_siperfaqe() return (gjatesia * lartesia); ; int main() drejtkendeshi drejt; drejt.v_gjatesine(5); drejt.v_lartesine(7); cout << "Siperfaqja: " << drejt.m_siperfaqe() << endl; system("pause"); return 0; 113. Të shkruhet programi në të cilin krijohet klasa bazë trajnimet dhe

klasa e derivuar topTrajnimi. Klasa bazë përmban anëtarët e mbrojtur id dhe emri të tipit string si dhe funksionet për vendosjen e këtyre vlerave. Në klasën e derivuar është një anëtar privat me emrin vleresimi i tipit int dhe funksioni shtyp për shtypjen e vlerave të id-‐së, emrit dhe vlerësimit. Në funksionin main të krijohet një objekt i klasës së derivuar, të vendosen vlerat dhe me pas të shtypen këto vlera.

#include <iostream> #include <string> using namespace std; class trajnimet protected: string id; string emri; public: void v_id(string id1) id=id1; void v_emrin(string emri1) emri=emri1; ; class topTrajnimi : public trajnimet

www.e-Libraria.com


128

private: int vleresimi; public: void v_vleresimin(int vlera) vleresimi=vlera; void shtyp() cout<<"Kursi me i vleresuar\n" <<"ID: "<<id <<"\nEmri: "<<emri <<"\nVleresimi: "<<vleresimi <<"\n"; ; int main() topTrajnimi top1; top1.v_id("ASDh2013"); top1.v_emrin("Algoritmet dhe Struktura e të Dhenave"); top1.v_vleresimin(5); top1.shtyp(); system("pause"); return 0;

5.17. Shfrytëzimi i anëtarëve gjatë trashëgimisë Shfrytëzimi i anëtarëve gjatë trashëgimisë mund të bëhet si public, protected dhe private. Nëse nuk përcaktohet specifikuesi i qasjes, atëherë merret si private. Skema e mëposhtme paraqet mënyrat e trashëgimisë.

Trashëgimia publike është metoda më e praktikuar, prandaj është më rëndësi që kjo metodë të kuptohet mirë. Kur të trashëgohet një klasë si publike, të gjithë anëtarët do të ruajnë specifikimet origjinale të qasjes.

Trashëgimia publike www.e-Libraria.com


129

Specifikuesi i qasjes (bazë)

Specifikuesi i qasjes (derivuar)

Qasja e klasës së derivuar

Qasja jashtë klasës

Public Public Po Po Protected Protected Po Jo Private Private Jo Jo Me trashëgimi private të gjithë anëtarë e klasës bazë janë të trashëguar si private. Kjo do të thotë anëtarët private qëndrojnë private, dhe anëtarët e mbrojtura dhe publik bëhen private.

Trashëgimia private Specifikuesi i qasjes (bazë)




Public Public Po Jo Protected Protected Po Jo Private Private Jo Jo Me trashëgimi të mbrojtur, anëtarët publik bëhet protected, kurse anëtarët privat mbesin privat. Trashëgimia protected është e ngjashme sikurse edhe trashëgimia private. Kjo mund të shihet edhe nga tabelat.

Trashëgimia e mbrojtur Specifikuesi i qasjes (bazë)




Public Public Po Jo Protected Protected Po Jo Private Private Jo Jo 114. Të shkruhet programi, përmes të cilit krijohet klasa Baza në anëtarët e

së cilës paraqitet tri variabla, një publike, një private dhe një protected. Të krijohet klasa derivuar dhe të trashëgohet si public nga klasa bazë. Më pas të provohet me iu qasur anëtarëve të klasës së derivuar.

#include <iostream> using namespace std; class Baza public: int a_publik; private: int a_privat; protected: int a_mbrojtur; ; class derivuar: public Baza derivuar() // Klasa e derivuar gjithmonë përdorë specifikuesit e klasës prind a_publik = 1;

www.e-Libraria.com


130

a_privat = 2; // Klasa e derivuar nuk mund të qaset tek anëtaret privat. a_mbrojtur = 3; ; int main() derivuar obj; obj.a_publik = 1; obj.a_privat = 2; // është privat dhe nuk mundemi me iu qasur jashtë klasës obj.a_mbrojtur = 3;

115. Të shkruhet programi, përmes të cilit krijohet klasa Baza në anëtarët e së cilës paraqitet tri variabla, një publike, një private dhe një protected. Të krijohet klasa derivuar dhe të trashëgohet si private nga klasa bazë. Më pas të provohet me iu qasur anëtarëve të ndryshëm të klasës bazë dhe të klasës së derivuar.

#include <iostream> using namespace std; class Baza public: int a_publik; private: int a_privat; protected: int a_mbrojtur; ; class derivuar: private Baza derivuar() // Klasa e derivuar gjithmonë përdorë specifikuesit e klases prind a_publik = 1; a_privat = 2; // Klasa e derivuar nuk mund të qaset tek anetarët privat. a_mbrojtur = 3; ; int main() derivuar obj; // a_publik tashme është privat dhe nuk mundemi me iu qasur jashtë klasës obj.a_publik = 1; // a_privat tashme është privat dhe nuk mundemi me iu qasur jashtë klasës obj.a_privat = 2; // a_mbrojtur tashmë është privat dhe nuk mundemi me iu qasur jashte klasës obj.a_mbrojtur = 3; Baza obj_b; obj_b.a_publik = 1; // a_privat është privat dhe nuk mundemi me iu qasur jashtë klasës obj_b.a_privat = 2;

www.e-Libraria.com


131

// a_mbrojtur është protected dhe nuk mundemi me iu qasur jashtë klasës obj_b.a_mbrojtur = 3;

5.18. Operatori i shoqërimit tek objektet Nëse janë deklaruar dy objekte të klasës, o1 dhe o2, përmes operacionit të shoqërimit:

Vlerat e anëtarëve të objektit o1 do u shoqërohen anëtarëve të objektit o2.

116. Të shkruhet programi dhe të krijohet klasa produkti e cila ruan peshën

dhe çmimin e produktit. Të deklarohet objekti i klasës dhe të iniciohet me vlera. Këto vlera të vendosen në objektin e ri. Në fund të printohen vlerat e anëtarëve për të dy objektet.

#include <iostream> using namespace std; class produkti float pesha, cmimi; public: void v_vlerat(float p, float c) pesha = p; cmimi = c; ; void shtypja() cout << "\npesha = " << pesha << "\nmimi = " << cmimi << "\n\n"; ; int main() produkti ob1, ob2;

www.e-Libraria.com


132

ob1.v_vlerat(1,2.55); cout << "\nVlerat origjinale"; ob1.shtypja(); ob2=ob1; //shoqerimi i vlerave të ob1 tek ob2 cout << "Vlerat e shoqëruara"; ob2.shtypja(); system ("pause"); return 0;

5.19. Krahasimi i objekteve të klasës Objektet e klasës nuk mund të krahasohen direkt mes vete. Nëse ob1 dhe ob2 janë objekte të klasës, atëherë nuk mund të kryhet krahasimi direkt.

Duke shfrytëzuar objektet mund të krahasohen vlerat e anëtarëve të klasës. Nëse anetar1 dhe anetar2 janë anëtarë të klasës, kurse ob1 dhe ob2 janë dy objekte të klasës, shihet se mund vlerat e anëtarëve mund të krahasohen.

117. Të shkruhet programi dhe të krijohet klasa produkti e cila ruan peshën

dhe çmimin e produktit. Të deklarohet dy objekte të klasës dhe të iniciohen me vlera. Përmes funksionit shtypja të shtypen vlerat e anëtarëve për të dy objektet. Më pas të krahasohen vlerat e tyre dhe të tregohet nëse vlerat janë të barabarta ose jo.

#include <iostream> using namespace std; class produkti public: float pesha, cmimi; void v_vlerat(float p, float c) pesha = p; cmimi = c; ; void shtypja() cout << "\nPesha = " << pesha << "\nÇmimi = "

www.e-Libraria.com


133

<< cmimi << "\n\n"; ; int main() produkti ob1, ob2; ob1.v_vlerat(1,2.55); ob2.v_vlerat(2.3,1.66); cout << "\nVlerat në objektin ob1"; ob1.shtypja(); cout << "Vlerat në objektin ob2"; ob2.shtypja(); if ((ob1.pesha==ob2.pesha) && (ob1.cmimi==ob2.cmimi)) cout << "Vlerat jane te barabarta"; else cout << "Vlerat nuk janë të barabarta\n\n" ; system ("pause"); return 0;

5.20. Fushat brenda klasave Në anëtarët e klasave mund të përfshihen edhe fusha (p.sh., vektorët,

deklarimit të një konstanteje para krijimit të klasave. 118. Të shkruhet programi dhe të krijohet klasa studenti e cila ka dy

anëtarë, një vektor për ruajtjen e notave dhe një funksion për llogaritjen e notës mesatare.

#include <iostream> #include <iomanip> using namespace std; const int m=10; class studenti public: //int n; //nëse deklarohet n, anetari i parë i vektorit i shoqërohet n-‐it float notat[m]; double mesatare() double mes=0; for (int i=0;i<m;i++) mes=mes+notat[i]; return mes/m; ; int main()

www.e-Libraria.com


134

int i; studenti st1 = 8,6,9,10,7,8,10,8,9,9; cout << "\nNotat e studentit" << "\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; for (i=0;i<m;i++) cout<< setw(4) << i+1 << setw(10) << st1.notat[i] << "\n"; cout << "-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n" << "Nota mesatare: " << st1.mesatare() << "\n\n"; system("pause"); return 0;

5.21. Krijimi i fushave duke përdor objektet Grupet e të dhënave të një klase të caktuar mund të vendosen në një fushë të objektit përkatës. Gjatë kësaj, në një element të fushës përfshihen të dhëna të cilat u përgjigjen anëtarëve të klasës në fjalë. 119. Të shkruhet programi dhe të krijohet klasa personi e cila ka tre

anëtarë (emri, mbiemri dhe qyteti) të tipit char. Në funksionin main të deklarohet një objekt vektor i klasës personi. Të ruhen të dhënat për 2 studentë dhe më pas të shtypen ato të dhëna.

#include <iostream> #include <iomanip> using namespace std; class personi public: char emri[15]; char mbiemri[20]; char qyteti[20]; ; int main() const int n=2; personi studenti[n]; cout << "\nTë dhënat nga tastiera\n\n"; for (int i=0;i<n;i++) cout << "Emri .......: "; cin >> studenti[i].emri; cout << "Mbiemri ....: "; cin >> studenti[i].mbiemri;

www.e-Libraria.com


135

cout << "Qyteti .....: "; cin >> studenti[i].qyteti; cout << "\n"; cout << "\nTe dhënat e lexuara\n"; for (int i=0;i<n;i++) cout << "\nEmri .......: " << studenti[i].emri << "\nMbiemri ....: " << studenti[i].mbiemri << "\nQyteti .....: " << studenti[i].qyteti << "\n"; cout << "\n"; system("pause"); return 0; 120. Të shkruhet programi dhe të krijohet klasa rezervimi dhe enumeration

ditet (hene, marte, merkure, enjte, premte, shtune, diele) si dhe një vektor ditetJaves i tipit string për mbajtjen e ditëve të javës. Shënimet e një klienti të lexohen përmes tastiere dhe dita e rezervimit të caktohet duke përdorur grupin/enumaration. Përmes anëtarit të grupit të merret vlera nga vektori ditetJaves në mënyrë që mesazhi të jetë sa më i kuptueshëm për njeriun.

#include <iostream> #include <string> using namespace std; string diteJaves[]="E hene","E marte","E merkure","E enjte","e premte", "E shtune", "E diele"; enum ditet hene,marte,merkure,enjte,premte, shtune, diele ; class rezervimi public: int numri; char emri[20]; int dita; ditet vendosDiten() ditet rez; switch(dita) case 1 : rez=ditet::hene; break; case 2 : rez=ditet::marte; break;

www.e-Libraria.com


136

case 3 : rez=ditet::merkure; break; case 4 : rez=ditet::enjte; break; case 5 : rez=ditet::premte; break; case 6 : rez=ditet::shtune; break; case 7 : rez=ditet::diele; break; default : rez=ditet::diele; break; return rez; ; int main() rezervimi klienti; cout<<"Numri i klientit: "; cin>>klienti.numri; cin.ignore(); cout<<"Emri i klientit: "; cin.getline(klienti.emri,20); cout<<"Dita (1=H, 2=M, 3=M, 4=E, 5=P, 6=S, 7=D: "; cin>>klienti.dita; cout<<"Të dhënat e klientit:\n" <<"Numri i klientit:"<<klienti.numri<<endl <<"Emri: "<<klienti.emri<<endl <<"ka bërë rezervim për ditën " <<diteJaves[klienti.vendosDiten()] <<endl; system("pause"); return 0;

www.e-Libraria.com


137

6. Pointerët Pointeri është tip i të dhënave i përcaktuar nga përdoruesi i cili krijon lloje të veçanta të variablave. Secili lokacion i memories i cili përdoret për të ruajtur vlera të të dhënave e ka një adresë. Pra, pointeri është një variabël që mban adresën e një variable tjetër. Pointeri mund të mbajë adresën e të dhënave primitive si char, int, float, double ose të dhënave të përcaktuara nga përdoruesi, si funksione, pointer ose të dhëna të derivuara si fusha, struktura, grupe etj.

6.1. Deklarimi i pointerëve Pointerët, si edhe variablat e tipave të tjerë, para se të shfrytëzohen duhet të deklarohen. Deklarimi i pointerëve është pothuajse i njëjtë sikurse i variablave të zakonshme. Për t'i dalluar pointerët nga variablat e zakonshme, para pointerëve shënohet simboli *:

Tipi t i variablës p duhet të përputhet me tipin e variablës adresa e së cilës do të ruhet në të. 121. Të deklarohen disa variante të variabla të tipit pointer. #include <iostream> using namespace std; int main() /*simboli * mund të shkruhet kudo në mes tipit dhe emrit të pointerit*/ int *a; int * b, *b1; int* c; float *d; float * e; double* f; char *g; int x, y, *h, *k; long* pointer, number=99; //lejohet inicimi vetem me zero dhe NULL int *y=0; int *z=NULL;

www.e-Libraria.com


138

6.2. Adresat e pointerëve

Duke e shfrytëzuar operatorin &, përmes shprehjes së formës:

adresa e variablës së zakonshme v vendoset të variabla p e cila është variabël e tipit pointer.

122. Të shkruhet programi në të cilin deklarohet një variabël v dhe një

pointer. Më pas të merret dhe të shtypet adresa e variablës v duke e shfrytëzuar pointerin p.

#include <iostream> using namespace std; int main() int v=5; int *p; cout << "\nVlera e variablës v= "<< v << "\nAdresa e variablës v ="<<&v; p=&v; //krijon një referencë tek v cout << "\nAdresa e variablës v " <<"përmes pointerit p: " << p << "\n\n"; system("pause"); return 0; 123. Të shkruhet programi në të cilin deklarohet variabla x e tipit int dhe

iniciohet me vlerën 37. Adresa e variablës x të ruhet në pointerin p. Vlera e ruajtur në pointer të ndryshohet në 58. Më pas të shtypen adresat e variablës x dhe adresa e pointerit si dhe vlera që është ruajtur në këtë adresë.

#include <iostream> using namespace std; int main()

www.e-Libraria.com


139

int *p; int x = 37; cout << "Vlera e variablës \t\tx = " << x << endl; p = &x; // ruaj adresën e x ne p cout<< "Vlera përmes pointerit \t\t*p = " << *p; *p = 58; //ruaj vlerën 58 në adresën e pointerit cout<< "\nVlera ne: \t\t\t*p = " << *p << "\nAdresa e pointerit \t\tp: " << &p << "\nAdresa e variablës \t\tx: " << p << "\nVlera ne adr. e pointerit \t = "<< *p << "\nAdresa e \t\t\tx: " << &x << "\nVlera e variablës \t\tx = " << x << endl; system("pause"); return 0;

6.3. Përdorimi i vlerës së pointerit Nëse dihet adresa e një variable, përmes procesit të deadresimit ose dereferimit mund të vendoset ose të merret vlera e variablës. Për këtë qëllim shfrytëzohet operatori *.

Vlera a variablës, adresa e së cilës është tek pointeri p do të ruhet në variablën v. Operatorët & dhe * mes vete llogariten si operatorë inverzë. 124. Të shkruhet programi përmes së cilit tregohet shtypja e vlerës së

variablës a dhe variablës b. Vlera e variablës b të shtypet duke shfrytëzuar adresën e cila ruhet tek pointeri p.

#include <iostream> using namespace std; int main() int *p; int a=200,b; cout << "\nVlera e variablës a: " << a << "\n"; //adresa e variablës a ruhet tek pointeri p p=&a; cout<< "\nAdresa të variabla a: " << p << "\n"; /*vlera e variablës, adresa e së cilës ruhet të pointeri p është ruajur tek

www.e-Libraria.com


140

variabla b.*/ b=*p; cout << "\nVlera e variablës b: " << b << "\n\n"; system("pause"); return 0;

6.4. Shoqërimi i vlerave Variablave të tipave të zakonshëm, me ndërmjetësimin e pointerëve mund të u shoqërohen vlera konstante ose vlera të variablave të tjera. Variablës, adresa e së cilës ruhet të pointeri p, mund t'i shoqërohet një vlerë konstante k.

Variablës, adresa e së cilës ruhet të pointeri p, mund t'i shoqërohet vlera e një variable tjetër.

125. Të shkruhet programi përmes së cilit tregohet ndryshimi i vlerës së

variablës x në mënyrë indirekte duke e shfrytëzuar adresën e pointerit p1. #include <iostream> using namespace std; int main() int x = 2013; int *p1 = &x; cout<<"&x = "<< &x << "\t\tx = "<< x <<"\np1 = "<< p1 << "\t\t*p1 = "<< *p1; *p1 += 25; //rritet vlera e variablës cout << "\n&x = " << &x << "\t\tx = " << x << "\np1 = " << p1 << "\t\t*p1 = " << *p1 << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


141

126. Të shkruhet programi përmes së cilit tregohet vendosja e vlerës së variablës x tek variabla y në mënyrë indirekte duke e shfrytëzuar adresën e pointerit p.

#include <iostream> using namespace std; int main() int x=1999,y; int *p; cout<< "\nVlera e variablës x = " << x; /*Adresa e variables y është ruajtur tek pointeri p.*/ p=&y; cout << "\nAdresa e variablës x = " <<&x <<"\nAdresa e variablës y = " << p; /*Vlera e x është ruajtur ne adresen qe e cila është ruajtur tek pointeri p*/ *p=x; cout << "\nVlera e variablës y = " << y << "\n\n"; system("pause"); return 0;

6.5. Llogaritjet përmes pointerëve Për llogaritje të ndryshme përveç variablave, mund të shfrytëzohen edhe pointerët.

www.e-Libraria.com


142

127. Të modifikohet programi i mëposhtëm dhe mbledhja ose zbritja të kryhet duke shfrytëzuar pointerët.

#include <iostream> using namespace std; int main() int x,y,z,*a,*b; cout << "\nx = "; cin >> x; cout << "\ny = "; cin >> y; a=&x; b=&y; if (x>y) z=*a+*b; else z=*a-‐*b; cout << "\nz = " << z << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


143

6.6. Operimi me pointerë Vlerat e pointerëve mund të rriten, të zvogëlohen, të krahasohen, ose përmes operatorit të barazimit, ato vlera edhe mund t'u shoqërohen pointerëve të tjerë. Operacione të vlefshme me pointerë janë:

Mbledhja dhe zbritja e pointerit me një integer. Shoqërimi i pointerit të tipit të njëjtë. Zbritja ose krahasimi i dy pointerëve në fushën e njëjtë. Caktimi ose krahasimi me zero.

Nëse p1 dhe p2 janë variabla pointer, atëherë

e ndryshon vlerën e p1 dhe ajo tani është adresë e memories (pointer) në p2.

128. Të shkruhet programi duke shfrytëzuar një unazë nga 1 deri në 10.

Brenda unazës të rritet vlera e pointerit për 1 dhe të shtypet adresa e pointerit.

#include <iostream> #include <iomanip> using namespace std; int main() int i,x; int *p; p=&x; cout << "\n i adresa (hex) adresa(dec)" << "\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; for (int i=1;i<=10;i++) cout << setw(2) << i << setw(10) << p << setw(15) << (long)p //adresa në decimal << "\n";

www.e-Libraria.com


144

p++; cout << "-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; system("pause"); return 0; 129. Të shkruhet programi në të cilin janë të deklaruar tri variabla: x, y

dhe z të cilat janë të iniciuara me vlera 25, 50 respektivisht 75. Duke shfrytëzuar pointerin p, vlera e x të shumëzohet me 2, vlerës së y të i zbriten 10 dhe vlerës së z të i shtohen 25.

#include <iostream> using namespace std; #include <iostream> int main() int x = 25, y = 50, z = 75; int *p; cout<< "Vlerat e x, y dhe z\n" <<"x = " << x << "\ny = " << y << "\nz = " << z << endl; p = &x; // ruaj adresën e x-‐it në p *p *= 2; // shumëzo vlerën në x me 2 p = &y; // ruaj adresën e y-‐it në p *p -‐= 10; // zbrit vlerën e y-‐it për 10 p = &z; // ruaj adresën e z-‐it në p *p += 25; // shto vlerën ne z-‐it me 25 cout << "Vlerat e reja pr x, y dhe z jan\n" <<"x = " << x << "\ny = " << y << "\nz = " << z << endl; system("pause"); return 0; 130. Të shkruhet programi në të cilin janë të deklaruara dy variabla x dhe y

si dhe dy pointer xp dhe yp. Të bëhet krahasimi i vlerave të ruajtura në pointer dhe të tregohet se vlera e cilës variabël është më e madhe.

#include <iostream> using namespace std; int main() int x, y, *xp, *yp; cout << " \nVlera x = "; cin >> x ; cout << " \nVlera y = "; cin >> y ;

www.e-Libraria.com


145

xp = &x; yp = &y; if (*xp > *yp ) cout << " \nx është më i madh se y\n"; else cout << "\ny është më i madh se x\n"; system("pause"); return 0; 131. Të shkruhet programi në të cilin deklarohet variabla x e tipit double

dhe dy pointer p1 dhe p2. Adresa e variablës x të i shoqërohet pointerit p1 dhe p1 të barazohen me p2. Më pas të krahasohen nëse adresa të pointeri p1 dhe p2 janë të barabarta.

#include <iostream> #include <iostream> using namespace std; int main() double x; double *p1,*p2; p1=&x; cout << "\nAdresa të pointeri p1: " << p1; p2=p1; cout << "\nAdresa të pointeri p2: " << p2; if (p1==p2) cout << "\n\nPointerët janë të barabartë"; else cout << "\n\nPointerët nuk janë të barabartë"; cout << "\n\n"; system("pause"); return 0; 132. Të shkruhet programi në të cilin deklarohet variabla a dhe pointeri ap.

Të tregohet se & dhe * janë inverz ndaj njëri tjetrit. #include <iostream> using namespace std; int main() int a; int *ap; a = 7; ap = &a;

www.e-Libraria.com


146

cout << "Adresa e variablës a është " <<&a <<"\nVlera te pointeri ap është " <<ap; cout << "\n\nVlera e variablës a është " << a << "\nVlera te pointeri *ap është "<< *ap; cout << "\n\nTregon se * dhe & janë inverz ne " << "njeri tjetrin.\n&*ap = "<<&*ap << "\n*&ap = " << *&ap<<endl; system("pause");

6.7. Operatori new dhe delete Derisa një pointer mund të përdoret për t'iu referuar një variable, programi mund të manipulojë me variabla edhe nëse variablat nuk kanë identifikues për emrin e tyre. Operatori new mund të përdoret për të krijuar variabla që nuk kanë identifikues për emrat e tyre. Këto variabla pa emër janë të referuara nëpërmjet pointerëve. Shembulli vijues krijon një variable të re të tipit int dhe vendos variablën pointer p1 në adresën e kësaj variable. p1=new int; Një zonë e veçantë e memories e quajtur freestore ose heap është e rezervuar për variablat dinamike. Secila variabël e re dinamike e krijuar prej programit konsumon një pjesë të memories në freestore. Madhësia e freestore ndryshon në varësi të implementimeve të C++. Operatori delete e eliminon variablen dinamike e rikthen memorien që e ka rezervuar variabla e krijuar në mënyrë dinamike. Memoria e liruar mund ë përdoret përsëri nga variablat dinamike. Shprehja e mëposhtme delete p; e eliminon variablen dinamike, adresa e së cilës është pointuar tek pointeri p. 133. Të shkruhet programi në të cilin deklarohet dy pointer p1 dhe p2. Duke

përdorur pointerin p1 dhe operatorin new të krijohen dy variabla dinamike të tipit int dhe të iu shoqërohen vlera konstante. Në fund të lirohet hapësira memoruese e cila është rezervuar me rastin e krijimit të krijimit të variablave dinamike

#include <iostream> using namespace std; int main() int *p1, *p2; p1 = new int;//krijo një variabël të tipit int *p1 = 44;

www.e-Libraria.com


147

p2 = p1; cout << "*p1 == " << *p1 << endl; cout << "*p2 == " << *p2 << endl; *p2 = 55; cout << "*p1 == " << *p1 << endl; cout << "*p2 == " << *p2 << endl; p1 = new int; //krijo një variabël të tipit int *p1 = 88; cout << "*p1 == " << *p1 << endl; cout << "*p2 == " << *p2 << endl; system("pause"); return 0; 134. Të shkruhet programi në të cilin deklarohet klasa personi e cila ruan

emrat e disa personave dhe ka funksionin për vendosjen dhe leximin e emrave. Të deklarohet pointeri persPtr i klasës personi dhe duke shfrytëzuar operatorin new të krijohen objekte të reja dhe të vendosen disa emra. Më pas të shfrytëzohet pointeri dhe një unazë për të printuar emrat dhe numrin rendor të anëtarëve.

#include <iostream> using namespace std; class personi protected: char emri[40]; public: void vendos_emrin() cout << "Emri: "; cin >> emri; void lexo_emrin() cout << "\nEmri: " << emri; ; int main() personi* persPtr[50]; //vektor pointeri në klasën personi int n = 0; char pyetja; do persPtr[n] = new personi; //objekt i ri persPtr[n]-‐>vendos_emrin(); n++; //numero personat cout << "Regjistro person tjet (p/j)? "; cin >> pyetja;

www.e-Libraria.com


148

while( pyetja=='p' ); for(int j=0; j<n; j++) cout << "\nNumri: " << j+1; persPtr[j]-‐>lexo_emrin(); cout << endl; system("pause"); return 0;

6.8. Pointerët const Ka dy vende kur fjala çelës const mund të vendoset brenda një deklarimi të variablës pointer. Varianti i parë është kur fjala const pas shenjës * (ylli). int * const ptr; deklaron një pointer konstant në të dhëna të ndryshueshme integer. Vlera integer mund të ndryshohet përmes këtij pointeri, por pointeri nuk mund të ndryshohet për të treguar vlera të ndryshme si konstante integer. Me fjalë të tjera pointeri konstant është një tregues që nuk mund të ndryshojë adresën. Varianti i dytë është kur fjala çelës const paraqitet para tipit të të dhënave. const int *ptr; deklaron një pointer të ndryshueshëm në një konstante integer. Vlera integer nuk mund të ndryshohet përmes këtij pointeri, por pointeri mund të ndryshohet për të treguar adresa të ndryshme të konstanteve integer. Sikurse konstantet normale edhe pointeri konstant duhet të iniciohet gjatë deklarimit. 135. Të shkruhet programi në të cilin deklarohet një pointer konstant tek i

cili mund të ndryshohet vlera por jo adresa. Vlera fillestare të ndryshohet dhe me pas të shtypet vlera e variablës dhe adresa variablës duke shfrytëzuar pointerin.

#include<iostream> using namespace std; int main() int vlera = 5; int *const vPtr = &vlera; *vPtr = 10; //lejohet ndryshimi i adresës, por jo i vlerës cout<< vlera <<" -‐ " <<vPtr <<"\n" <<*vPtr <<" -‐ " <<vPtr <<"\n";

www.e-Libraria.com


149

system("pause"); return 0; 136. Të shkruhet programi në të cilin deklarohet një pointer konstant tek i

cili mund të ndryshohet adresa, por jo vlera. Për këtë të deklarohen dy variabla dhe pointerit të i ndryshohet adresa prej variablës së parë tek e dyta. Më pas të shtypen vlerat e variablave dhe adresar e tyre duke shfrytëzuar pointerin.

#include<iostream> using namespace std; int main() int vlera1 = 10; int vlera2 = 15; const int * vPtr = &vlera1; vPtr = &vlera2; // lejohet ndryshimi i adresës, por jo i vlerës cout<< vlera1 <<" -‐ " <<vPtr <<"\n" <<vlera2 <<" -‐ " <<vPtr <<"\n"; system("pause"); return 0;

6.9. Pointerët dhe fushat Emri i një fushe është në fakt një pointer për elementin e parë në grup. Deklarimi fusha[3] i tregon kompajlerit që të kthejë elementin që është 3 elemente larg nga elementi i fillimit. Kjo shpjegon pse fushat kanë qenë gjithmonë si referencë: pasimi i një fushe me të vërtetë është pasimi i një pointeri. Kjo gjithashtu shpjegon pse indekset e fushave fillojë në 0: elementi i parë i një fushe është element që është 0 elemente larg nga fillimi i fushës. Mund të thuhet se fushat janë të lidhura ngushtë me pointerët dhe janë sinonim në aspektin se si i qasen memories. Për të iu qasur anëtarit të i-‐të vektorit v me ndërmjetësimin e pointerit p mund të shfrytëzohet shprehja: p = &v[i]; Në fusha, emri i fushës tregon gjithmonë për elementin e parë. Adresa e anëtarit të parë të fushës është &v[0]. Nëse janë të deklaruara: int a[m]; dhe int* p; atëherë p=a dhe a=p janë të vlefshme dhe

www.e-Libraria.com


150

Dallimi i vetëm në mes tyre është se vlera e "p" mund të ndryshojë tek secila adresë e variablës integer, ndërsa "a" gjithmonë do të tregojë një fushë integer me madhësi m.

137. Të shkruhet programi përmes së cilit tregohet shfrytëzimi i pointerit p

për shtypjen e adresave të vektorit v(5). #include <iostream> #include <iomanip> using namespace std; int main() int v[5], *p; for(int i=0;i<5;++i) p=&v[i]; cout<<"Adresa e v["<<i<<"]=" <<p<<"\n"; system("pause"); return 0; 138. Të shkruhet programi përmes së cilit shtypen anëtarët e vektorit vek[]

në menyrë direkte dhe përmes pointerit pvek duke pasur parasysh që vlejnë shprehjet a[i] *(a+i) dhe p[i] *(p+i).

#include <iostream> using namespace std; int main() int vek[] = 10, 20, 30, 40 ; int *pvek = vek; cout << "Printimi përmes emrit të vektorit\n"; for ( int i = 0; i < 4; ++i ) cout << "vek[" << i << "] = " <<vek[i] << '\n'; cout << "\nPrintimi përmes emrit të vektorit dhe operatorit *\n"; for ( int j = 0; j < 4; ++j ) cout << "*(vek + " << j << ") = " <<*(vek + j ) << '\n';

www.e-Libraria.com


151

cout << "\nAnëtaret përmes pointerit \n"; for ( int k = 0; k < 4; ++k ) cout << "pvek[" << k << "] = " << pvek[k] << '\n'; cout << "\nAnëtaret përmes pointerit me zhvendosje\n"; for ( int m = 0; m < 4; ++m ) cout << "*(pvek + " << m << ") = " << *( pvek + m ) << '\n'; system("pause"); return 0; 139. Të shkruhet programi përmes së cilit tregohet mbushja e anëtarëve të

vektorit arr[m] duke shfrytëzuar pointerin p. #include <iostream> using namespace std; int main() const int m=5; int i, *p, arr[m]; //mbushja e anetareve te vektorit for (i = 0; i < m; i++) arr[i] = m; //ndryshimi i vlerave permes pointerit for (p = arr; p < &arr[m]; p++) *p = m+1; //shtypja e vlerave te anetareve te vektorit for (i = 0; i < m; i++) cout<< arr[i] ; if (i<m-‐1) cout <<", "; cout<<endl; system("pause"); return 0; 140. Të shkruhet programi përmes së cilit shtypen anëtarët e matricës

A[m][m] përmes pointerit pA sikurse shihet në pamjen e mëposhtme.

www.e-Libraria.com


152

#include <iostream> #include <iomanip> using namespace std; int main() const int m=4; int A[m][m]= 1,2,3,-‐1, 2,3,-‐1,4, 3,-‐1,4,5, -‐1,1,2,3, ; int i,j,k=0,*pA; char vija[]="-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; cout << "\nVl. Adr(Hex) Adr(Dec)\n" <<vija; pA=&A[0][0]; for (i=0;i<m;i++) for (j=0;j<m;j++) cout << setw(2) <<*(pA+k) <<setw(10) << pA <<setw(10) << (long)pA; pA=pA+1; cout<<endl; cout << endl; cout << vija; system("pause"); return 0;

www.e-Libraria.com


153

6.10. Ponterët stringje Një pointer karakter është një tregues/pointer për adresën e një variable të tipit karakter, p.sh char *p;

Pointeri k tregon për sekuencën e karaktereve dhe mund të lexohet sikurse të ishte një vektor. 141. Të shkruhet programi në të cilin deklarohet një pointer k i tipit char

dhe të shtypet vlera e tij. #include<iostream> using namespace std; int main() char *k = "tung"; cout<<"\nk =["<<k <<"]" <<"\n"; system("pause"); return 0;

6.11. Fusha pointerësh Për të vendosur stringje brenda fushave, p.sh., siç janë emrat e ndryshëm, fushat duhet të deklarohen si dy dimensionale, përkatësisht si matrica.

Por, nëse fushat e tilla ruhen në një vektor të deklaruar si fushë pointerësh (ang. array of pointers), hapësira memoruese do të jetë minimale.

www.e-Libraria.com


154

Nëse është deklaruar një matricë e tipit char e cila ruan ditët e javës dhe të njëjtat vlera ruhen edhe përmes pointerit.

Atëherë më poshtë shihet se si rezervohet memoria kur ditët e javës janë ruajtur në matricë dhe si kur janë të ruajtura në pointer.

Pamja në të majtë paraqet se si është rezervuar memoria kur ditët e javës janë ruajtur në matricë dhe shihet se dita e mërkure është dita më e gjatë dhe edhe për ditët më të shkurta është dashur të rezervohet memorie e njëjtë si për ditën e mërkure. Si pasojë një pjesë e memories është rezervuar, por nuk është shfrytëzuar (ka shkuar dëm). Kurse me rastin kur ditët janë ruajtur përmes pointerit shihet se memoria është menaxhuar më mirë dhe dita vijuese ka vazhduar pas ditës paraardhëse dhe pointeri e ruan vetëm adresën e shkronjës së parë. #include <iostream> using namespace std; const int m = 4; int main) char *studentet[m] = "Filan Fisteku", "Kosovare Shkodra", "Saranda Prizreni", "Milot Mitrovica",

www.e-Libraria.com


155

; for (int i = 0; i < m; i++) cout<< "Studenti[" << i << "] = " << studentet[i] << endl; system("pause"); return 0;

6.12. Pointerët si parametra të funksioneve Pointerët mund të jenë si parametra të funksioneve, mund të kthehen nga funksionet, mund të ruhen në fusha, dhe mund të shoqërohen në pointerë të funksioneve tjera

142. Të shkruhet programi përmes së cilit bëhet konvertimi prej inçëve në

centimetra. Për këtë të shfrytëzohet funksioni inchNeCm i cili ka parametrin formal p të tipit pointer.

#include <iostream> using namespace std; double inchNeCm(double*); //prototipi int main() double y,x = 5.0; cout << "x = " << x << " inch" << endl; y=inchNeCm(&x); //dergo adresen e var cout << "y = " << y << " centimetra" << endl; system("pause"); return 0;

www.e-Libraria.com


156

double inchNeCm(double* p) double y; y =*p * 2.54; return y; 143. Të shkruhet programi përmes së cilit llogaritet vlera e shprehjes së

mëposhtme duke shfrytëzuar funksionin shuma. Funksioni shuma si parametra formalë të tipit pointerë ka x, n dhe y. Funksioni rezultatin ta ruajë hapësirën memoruese, adresa e së cilës ruhet në pointerin y.

#include <iostream> using namespace std; void shuma(double *x, int *n, double *y); int main() int n; double x,y; cout << "Vlera x = "; cin >> x; cout << "Vlera n = "; cin >> n; shuma(&x,&n,&y); cout << "\nVlera y = " << y << "\n\n"; system("pause"); return 0; void shuma(double *x, int *n, double *y) double s=0; for (int i=3;i<=*n;i++) s=s+(3*i-‐2*(*x)); *y=pow((*x+3),2) + s; return;

www.e-Libraria.com


157

6.13. Pointerët në funksione Funksionet gjatë ekzekutimit të programit vendosën në hapësira të caktuara memoruese. Adresa ku fillon vendosja e një funksioni në memorien e kompjuterit quhet adresë e funksionit. Për ruajtjen e adresës së funksionit shfrytëzohet pointeri në funksion, i cili njihet edhe si pointer funksioni. Pointeri i funksionit mund të shfrytëzohet për thirrjen e funksionit adresa e së cilit është ruajtur tek ky pointer.

Në skemën e sipërme shihet se si është deklaruar pointeri për funksionin shuma. Funksioni shuma ka dy parametra formalë të tipit integer dhe prandaj edhe pointeri duhet të ketë parametrat e njëjtë sikurse funksioni. 144. Të shkruhet programi përmes së cilit llogaritet vlera e shprehjes së

mëposhtme duke shfrytëzuar funksionin shuma. Funksioni shuma të thirret përmes pointerit p.

#include <iostream> using namespace std; void shuma(int n); int main() void (*p)(int); p=shuma; int n=10; (*p)(n); system("pause"); return 0; void shuma(int n) int y=0; for (int i=1; i<=n;i++) y=y+i; cout << "\ny=" << y << "\n\n";

www.e-Libraria.com


158

145. Të shkruhet programi i cili përmes funksionit shkembe_vlerat i shkëmben vlerat e parametrave të funksionit. Parametrat e funksionit janë pointer.

#include <iostream> using namespace std; void shkembe_vlerat(int *px, int *py) int temp; temp = *px; *px = *py; *py = temp; int main() int a = 10, b = 20; cout<< "a = "<< a << "\nb = " <<b; shkembe_vlerat(&a, &b); cout<<"\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n" << "\na = "<< a << "\nb = " <<b <<"\n\n"; system("pause"); return 0; 146. Të shkruhet programi në të cilin krijohet funksioni mesatarja për

gjetjen e notës mesatare. Në funksionin main të deklarohet një vektor me madhësi m dhe i iniciuar me nota. Ky vektor të jetë parametri i parë, kurse madhësia e vektorit të jetë parametri i dytë gjatë thirrjes së funksionit mesatarja.

#include <iostream> using namespace std; double mesatarja(int *, int ); const int m=5 int main() int notat[m] = 6, 8, 10, 9, 9; double mes; mes = mesatarja(notat, 5) ; cout << "Nota mesatare = " << mes << endl; system("pause"); return 0; double mesatarja(int *vek, int m)

www.e-Libraria.com


159

double s=0; for (int i = 0; i < m; ++i) s += vek[i]; return double(s) / m; 147. Të shkruhet programi përmes së cilit llogaritet faktorieli n! duke

shfrytëzuar funksionin faktorieli. Funksioni faktorieli të thirret përmes pointerit p.

#include <iostream> using namespace std; void faktorieli(int); int main() void (*p)(int); p=faktorieli; int n=6; (*p)(n); system("pause"); return 0; void faktorieli(int n) long f=1; for (int i=1; i<=n;i++) f=f*i; cout << "\nf=" << f << "\n\n";

6.14. Pointerët në struktura Pointerët, përveç tek të dhënat e tipave të zakonshëm, mund të shfrytëzohen edhe gjatë operimit me struktura. Deklarimi i variablave të tipit pointer për strukturat dhe operimin me anëtarët e tyre nuk dallon nga mënyra e shfrytëzimit të pointerëve për tipat e zakonshëm të të dhënave. Më poshtë është dhënë një shembull i deklarimit të një strukture dhe deklarimi i pointerit të kësaj strukture.

www.e-Libraria.com


160

148. Të shkruhet programi në të cilin deklarohet struktura vija e cila ruan

koordinatat e pikës A dhe B. Në funksionin main të deklarohet një pointer i strukturës dhe qasja tek anëtarët e strukturës të bëhet përmes pointerit.

#include <iostream> using namespace std; struct vija double x1,y1; double x2, y2; ; int main() vija v; vija *p; p=&v; (*p).x1=0; (*p).y1=0; (*p).x2=5; (*p).y2=5; cout<< "\n\nPika A = (" << (*p).x1 <<", " <<(*p).y1 <<")"; cout << "\nPika B = (" << (*p).x2 <<", " <<(*p).y2 <<")" << "\n\n"; system("pause"); return 0; 149. Të modifikohet shembulli paraprak dhe për të qasje tek anëtarët e

strukturës të përdoret operatori -‐>. #include <iostream> using namespace std; struct vija

www.e-Libraria.com


161

double x1,y1; double x2, y2; ; int main() vija v; vija *p; p=&v; p-‐>x1=0; p-‐>y1=0; p-‐>x2=5; p-‐>y2=5; cout<< "Pika A = (" << p-‐>x1 <<", " <<p-‐>y1 <<")"; cout << "\nPika B = (" << p-‐>x2 <<", " <<p-‐>y2 <<")" << "\n\n"; system("pause"); return 0;

6.15. Pointerët në objekte Pointerët mund të shfrytëzohen gjatë operimit me objekte të klasave, njëlloj sikurse edhe tek strukturat. Shembulli më poshtë paraqet se si është deklaruar një objekti i klasës dhe si pointeri i klasës.

150. Të shkruhet programi, përmes së cilit krijohet klasa rrethi. Brenda

klasës të krijohet rrezja si private dhe funksionet publike vendos_rrezen dhe siperfaqja. Objekti i klasës të jetë pointeri rrp.

#include <iostream> using namespace std; const double pi=3.1415;

www.e-Libraria.com


162

class rrethi private: double rrezja; public: void vendos_rrezen(double); double siperfaqja(); ; void rrethi::vendos_rrezen(double r) rrezja = r; double rrethi::siperfaqja() return pi * rrezja * rrezja ; int main) rrethi rr, *rrp; rrp=&rr; rrp-‐>vendos_rrezen(5.6); cout<<"Siperfaqja e rrethit = " <<rrp-‐>siperfaqja() << "\n\n"; system("pause"); return 0; 151. Të shkruhet programi në të cilin krijohet klasa Kutia me anëtarë privat

lartesia, gjeresia, lartesia, dhe anëtarë publik funksionin vellimi dhe konstruktorin e klasës. Vlerat e nënkuptuara për anëtarët privat të jenë 1.0. Më pas të deklarohen dy objekte dhe të iniciohen me vlera duke shfrytëzuar konstruktorin. Pointeri të shfrytëzohet për ruajtjen e adresave të objektit të parë dhe të dytë dhe shtypjen e vëllimit për secilin objekt.

#include <iostream> using namespace std; class Kutia private: double gjatesia; double gjeresia; double lartesia; public: Kutia(double gjat=1.0, double gjer=1.0, double lar=1.0) cout <<"Konstruktori u thirr." << endl; gjatesia = gjat; gjeresia = gjer; lartesia = lar; double vellimi()

www.e-Libraria.com


163

return gjatesia * gjeresia * lartesia; ; int main() Kutia kutia1(4.49, 3.27, 3.41); Kutia kutia2(5.55, 2.22, 3.33); Kutia *pKutia; // Deklarimi i pointerit të klases. pKutia = &kutia1; // adresa e kutia1 ruhet tek pointeri cout<< "V imi i kutis : " << pKutia-‐>vellimi() << endl; pKutia = &kutia2; // adresa e kutia2 ruhet tek pointeri cout<< "Vëllimi i kutisë: " << pKutia-‐>vellimi() << endl; system("pause"); return 0;

www.e-Libraria.com


164

7. Referencat

7.1. Referencat e zakonshme Në C++, përmes referencave mund të deklarohen dy ose më shumë variabla ose objekte, tek të cilat ruhen të dhëna të njëjta. Ndryshimi tek njëra do të përcillet edhe tek tjetra. Referencat kryesisht shfrytëzohen gjatë operimit me parametrat e funksioneve. Për deklarimin e referencave shfrytëzohet operatori për referim &. Forma e përgjithshme e deklarimi të një reference është dhënë më poshtë.

Ku t paraqet tipin e të dhënave për variablën referente; & -‐operatorin për referim, r variabla referente; v variabla së cilës i referohet variabla referente r. Referenca është emri i një lokacioni. P.sh up është një variabël e tipit int dhe fiek është një referencë e variablës up. int up; int& fiek = up; 152. Të shkruhet programi në të cilin deklarohet një variabël v e tipit

integer si dhe variabla referente vref. Vlera e variablës vref të rritet për 1 dhe më pas të shtypet vlera e variablës v.

#include <iostream> using namespace std; int main() int v=15; int &vref = v; v++; cout<< "Vlera e vref është: " <<vref <<endl; system("pause"); return 0;

www.e-Libraria.com


165

7.2. Parametrat referentë

Referenca ofron një pseudonim të ndryshëm për një variabël. Përdorimi më i rëndësishëm i referencave është tek funksionet, ku referencat pasohet si parametra të funksioneve. Në rastin kur funksionit i pasohen parametrat sipas vlerës, funksioni i thirrur krijon variabla të reja me tip të njëjtë dhe i kopjon vlerat e parametrave duke i vendosur në këto variabla. Pra funksioni i thirrur nuk ka qasje tek variabla e cila është e deklaruar tek funksioni thirrës, por vetëm në kopjen e krijuar. Për të deklaruar një parametër referent të funksionit, pas tipit të të dhënave shënohet simboli & dhe me pas emri i parametrit. Parametri i tillë paraqet një parametër formal referent. Emri parametrit në trupin e funksion të thirrur i referohet variablës origjinale në funksionin thirrës. Parametrat referentë janë të dobishëm për kthimin e vlerave/rezultateve të shumëfishta. Më poshtë është deklaruar një funksion me emrin ndrysho i cili si parametër formalë referentë e ka parametrin pref.

153. Të shkruhet programi në të cilin deklarohet funksioni param_ref i cili

ka një parametër formalë referentë dhe parametrin formal e rrit për një. Nga funksioni kryesor të thirret funksioni param_ref për dy variabla të deklaruara dhe të iniciuara brenda funksionit kryesor.

#include <iostream> using namespace std; void param_ref(int &pref) pref++; int main() int a=10; int b=20; param_ref(a) ; param_ref(b) ; cout<< "a = " << a << " b = "<< b <<endl;

www.e-Libraria.com


166

system("pause"); return 0; 154. Të shkruhet programi në të cilin deklarohet funksioni shkembe i cili

shkëmben vlerat e parametrave formalë referentë. Nga funksioni kryesor të thirret funksioni shkembe për dy variabla të deklaruara dhe iniciuara brenda funksionit kryesor.

#include <iostream> using namespace std; void shkembe(int& x, int& y) int temp = x; x = y; y = temp; int main() int a=10; int b=20; shkembe(a,b) ; cout<< "a = " << a << " b = "<< b <<endl; system("pause"); return 0; 155. Të shkruhet programi në të cilin deklarohet funksioni SinCos i cili

llogarit sinusin dhe kosinusin e këndit të dhënë. Sinusi dhe kosinusi të jenë parametra referentë të funksionit SinCos. Nga funksioni kryesor të thirret funksioni SinCos për këndin 45 .

#include <iostream> using namespace std; const double pi=3.1415; void SinCos(double kendi, double &Sin, double &Cos) Sin = sin(kendi); Cos = cos(kendi); int main() double Sin = 0.0; double Cos = 0.0; double kendi=45*(pi/180); //këndi 45 në radian SinCos(kendi, Sin, Cos);

www.e-Libraria.com


167

cout << "Sinusi " << Sin << endl; cout << "Kosinusi " << Cos << endl; system("pause"); return 0; 156. Të shkruhet programi në të cilin deklarohen dy funksione funk1 dhe

funk2. Funksioni parë e ka një parametër referentë, kurse funksioni i dytë e ka një parametër konstant referent. Të thirren të dy funksionet për vlera të njëjta dhe të vërehet dallimi në mes parametrit referentë dhe parametrit konstant referent.

#include <iostream> using namespace std; int funk1(int& nr1); int funk2(const int& nr2); int main() int numri1(4); int vlera1(6); char vija[]="\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; cout<<vija; int rez1 = funk1(numri1); cout<< "\nfunk1(numri1) = " << rez1 << "\nnumri1 = " << numri1 <<endl; rez1 = funk1(vlera1); cout<< "\nfunk1(vlera1) = " << rez1 << "\nvlera1 = " << vlera1 << vija; int numri2(4); int vlera2(6); cout<<vija; int rez2= funk2(numri2); cout << "\nfunk2(numri2) = " << rez2 << "\nnumri2 = " << numri2 <<endl; rez2 = funk2(vlera2); cout << "\nfunk2(vlera1) = " << rez2 << "\nvlera2 = " << vlera2 << vija; system("pause"); return 0; int funk1(int& numri1) // Funksioni me parametër referent

www.e-Libraria.com


168

cout << endl << "Vlera e pranuar = " << numri1; numri1 += 10; return numri1; int funk2(const int& numri1) // Funksioni me parameter konstant referent cout << endl << "Vlera e pranuar = " << numri1; // numri1 += 10; // veprim jo i lejueshuem nga kompajleeri return numri1+10;

7.3. Fushat referente Gjatë operimit me anëtarët e fushave (vektorë, matrica...), si referente mund të deklarohen edhe fushat. Vlerat e anëtarëve të fushës referente barazohen me vlerat e anëtarëve të fushës për të cilën është krijuar referenca. Forma e përgjithshme për të deklaruar një vektor apo matricë referente është dhënë më poshtë.

Ku t është tipi i të dhënave për vektorin/matricën referente; & -‐ operatori për referim; R vektori/matrica referente; m numri anëtarëve/rreshtave të vektorit/matricës referente; n numri i shtyllave të matricës referente; V vektori të cilit i referohet vektori referent; M matrica të cilës i referohet matrica referente. 157. Të shkruhet programi përmes të cilit tregohet deklarimi i vektorit B(m)

si vektor referent i vektorit A(m). Vektori A(m) gjatë deklarimit të iniciohet me vlera.

#include<iostream> #include <iomanip> using namespace std; int main() const int m=5; int A[m]=2,5,8,9,1; int (&B)[m]=A; //vektori referent cout << "Vektori origjinal A\n\n"; for (int i=0;i<m;i++) cout << setw(3) << A[i]; cout << "\n\nVektori referent B\n\n"; for (int i=0;i<m;i++) cout << setw(3) << B[i]; cout << "\n\n";

www.e-Libraria.com


169

system("pause"); return 0; 158. Të shkruhet programi përmes të cilit tregohet deklarimi i matricës

B(m,n) si matricë referente e matricës A(m,n). Matrica A(m,n) të mbushet me vlera të çfarëdoshme përmes një unaze.

#include<iostream> #include <iomanip> using namespace std; int main() const int m=5; int A[m][m]; for (int i=0; i<m;i++) for (int j=0;j<m;j++) A[i][j]=i*j; int (&B)[m][m]=A; //matrica referente cout << "Matrica origjinale A\n\n"; for (int i=0;i<m;i++) for (int j=0;j<m;j++) cout << setw(5) << A[i][j]; cout << "\n"; cout << "\n\nMatrica referente B\n\n"; for (int i=0;i<m;i++) for (int j=0;j<m;j++) cout << setw(5) << B[i][j]; cout << "\n"; cout << "\n\n"; system("pause"); return 0;

7.4. Parametrat referentë brenda anëtarëve të strukturave

Parametrat e funksioneve që shfrytëzohen brenda komponentëve të strukturave mund të jenë edhe si parametra referentë. Kjo ka rëndësi të veçantë kur prej strukturës dëshirohet të merren rezultatet e llogaritjeve të ndryshme dhe jo vetëm një rezultat. Në shembullin më poshtë është dhënë struktura rrethi e

www.e-Libraria.com


170

cila njërin nga anëtarët e saj e ka funksionin lexo i cili ka dy parametra formalë referentë.

159. Të shkruhet programi në të cilin shfrytëzohet struktura rrethi me

variablat r, s, dhe p. Të llogaritet sipërfaqja dhe perimetri i rrethit dhe rezultati të ruhet në variablat e strukturës s dhe p. Për të lexuar vlerat e variablave s dhe p të shfrytëzohet funksioni lexo me parametrat referentë x dhe y.

#include<iostream> using namespace std; const double pi=3.1415; struct rrethi double r,s,p; void vendos_rrezen(); void llogarit(); void lexo(double &x,double &y); ; void rrethi::vendos_rrezen() cout << "\nRrezja r="; cin >> r; void rrethi::llogarit() s=pi*r*r; p=2*pi*r; void rrethi::lexo(double &x,double &y) x=s; y=p; int main() rrethi rr; double s,p; rr.vendos_rrezen(); rr.llogarit(); rr.lexo(s,p); cout<< "\nSipërfaqja s=" << s << "\nPerimetri p="<< p << "\n\n"; system("pause");

www.e-Libraria.com


171

return 0; 160. Të shkruhet programi në të cilin shfrytëzohet struktura sfera me

variablat r, s, dhe v. Të llogaritet sipërfaqja dhe vëllimi i sferës dhe rezultati të ruhet në variablat e strukturës s dhe v. Për të lexuar vlerat e variablave s dhe v të shfrytëzohet funksioni lexo me parametrat referentë x dhe y.

#include<iostream> using namespace std; const double pi=3.1415; struct sfera double r,s,p; void vendos_rrezen(); void llogarit(); void lexo(double &x,double &y); ; void sfera::vendos_rrezen() cout << "\nRrezja r="; cin >> r; void sfera::llogarit() s=4*pi*r*r; p=(4/3)*pi*r*r*r; void sfera::lexo(double &x,double &y) x=s; y=p; int main() sfera rr; double s,p; rr.vendos_rrezen(); rr.llogarit(); rr.lexo(s,p); cout<< "\nSipërfaqja s=" << s << "\nVellimi v="<< p << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


172

7.5. Parametrat referentë brenda anëtarëve të klasave

Ngjashëm sikurse strukturat, edhe tek klasat mund të shfrytëzohen parametra referentë. Parametrat referentë janë si parametra të funksioneve brenda anëtarëve të tyre.

161. Të shkruhet programi në të cilin shfrytëzohet klasa rrethi me anëtarët

privat r, s, dhe p. Të llogaritet sipërfaqja dhe perimetri i rrethit dhe rezultati të ruhet në anëtarët privat të klasës, s dhe p. Për të lexuar vlerat e variablave s dhe p të shfrytëzohet funksioni lexo me parametrat referentë x dhe y.

#include<iostream> using namespace std; const double pi=3.1415; class rrethi private: double r,s,p; public: void vendos_rrezen(); void llogarit(); void lexo(double &x,double &y); ; void rrethi::lexo(double &x,double &y) x=s; y=p; void rrethi::vendos_rrezen() cout << "\nRrezja r="; cin >> r; void rrethi::llogarit() s=pi*r*r; p=2*pi*r; int main()

www.e-Libraria.com


173

rrethi rr; double s,p; rr.vendos_rrezen(); rr.llogarit(); rr.lexo(s,p); cout<< "\nSipërfaqja s=" << s << "\nPerimetri p="<< p << "\n\n"; system("pause"); return 0; 162. Të shkruhet programi në të cilin shfrytëzohet klasa sfera me anëtarët

privat r, s, dhe v. Të llogaritet sipërfaqja dhe vëllimi i sferës dhe rezultati të ruhet në anëtarët privat të klasës, s dhe v. Për të lexuar vlerat e variablave s dhe v të shfrytëzohet funksioni lexo me parametrat referentë x dhe y.

#include<iostream> using namespace std; const double pi=3.1415; class sfera double r,s,p; public: void vendos_rrezen(); void llogarit(); void lexo(double &x,double &y); ; void sfera::vendos_rrezen() cout << "\nRrezja r="; cin >> r; void sfera::llogarit() s=4*pi*r*r; p=(4/3)*pi*r*r*r; void sfera::lexo(double &x,double &y) x=s; y=p; int main() sfera rr; double s,p; rr.vendos_rrezen(); rr.llogarit(); rr.lexo(s,p); cout<< "\nSiperfaqja s=" << s

www.e-Libraria.com


174

<< "\nVellimi v="<< p << "\n\n"; system("pause"); return 0;

7.6. Objektet referente Objektet e strukturave dhe të klasave mund të deklarohen si objekte referente plotësisht njëlloj, siç deklarohen edhe variablat e zakonshme. Si rezultat, të dhënat që u shoqërohen anëtarëve të strukturave ose të klasave do të barazohen me vlerat e anëtarëve përkatës në objektet të cilave u referohen. 163. Të shkruhet programi në të cilin është deklaruar struktura librat me

anëtarët: titulli, autori dhe funksioni shtypja. Të deklarohet objekti referent libRef i objektit libri dhe më pas të thirret funksioni shtypja përmes objektit libri dhe libRef.

#include <iostream> #include <string> using namespace std; struct librat string titulli; string autori; void shtypja(); ; void librat::shtypja() cout<<"\nTitulli i librit: " <<titulli <<"\nAutori i librit: " <<autori; int main() librat libri; cout<<"Titulli i librit: "; getline(cin,libri.titulli); cout<<"Autori i librit: "; getline(cin,libri.autori); cout<<"Shtypja përmes objekit libri\n"; libri.shtypja(); librat &libRef=libri; cout<<"Shtypja përmes objekit libRef\n"; libRef.shtypja(); system("pause"); return 0;

www.e-Libraria.com


175

164. Të shkruhet programi në të cilin është deklaruar klasa studentet me anëtarët: emri, notat dhe funksionet për vendosje dhe shtypjen e vlerave të anëtarëve. Të deklarohet objekti referent studRef i objektit stud. Duke shfrytëzuar objektin dhe objektin referent të thirret funksioni i cili shtyp emrin dhe notat e studentit.

#include <iostream> #include <iomanip> #include <string> using namespace std; class studentet public: string emri; int notat[5]; void shtypja(); ; void studentet::shtypja() cout<<"\nStudenti: " <<emri <<"\nNotat: "; for (int i=0;i<5; i++) cout << setw(3) << notat[i]; int main() studentet stud; cout<<"Emri i studentit: "; getline(cin,stud.emri); for (int i=0;i<5; i++) cout<< "Nota " <<i+1 <<": "; cin >>stud.notat[i]; cout<<"\nShtypja permes objekit stud\n"; stud.shtypja(); studentet &studRef=stud; cout<<"\n\nShtypja permes objekit studRef\n"; studRef.shtypja(); cout<<"\n\n"; system("pause"); return 0;

www.e-Libraria.com


176

8. Fajllat

8.1. Fajllat me qasje sekuenciale Fajllat tek të cilët të dhënat shkruhen ose lexohen si sekuenca (vargje) bajtësh, paraqesin fajlla me qasje sekuenciale. Tek fajllat e tillë, si njësi elementare që mund të shkruhet ose të lexohet është bajti. Zakonisht, tek fajllat me qasje sekuenciale të dhënat shkruhen si tekste, prandaj këta fajlla shpeshherë quhen edhe fajlla tekstualë.

Për të shkruar në fajll duhet të krijohet një objekt/rrjedhë e klasës ofstream dhe të hapet fajlli. Për krijimin e objektit dhe hapjen e fajllit, komandat përkatëse në formën themelore shkruhen:

Ku r është rrjedha e deklaruar si objekt i klasave për punë me fajlla; f -‐ emri i fajllit që hapet; ios::out -‐ modi i hapjes së fajllit për shkrim. ios::in-‐ modi i hapjes së fajllit për lexim. Skema e mëposhtme paraqet një pamje vizuale për klasës ofstream dhe ifstream.

www.e-Libraria.com


177

165. Të shkruhet programi përmes së cilit lexohen tre numra nga fajlli leximi.txt dhe më pas ruhen në variabla të ndara. Shuma e këtyre tre numrave të shkruhet të fajllin shkrimi.txt.

#include <iostream> #include <fstream> using namespace std; int main() ofstream shkruaj; ifstream lexo; int nr1, nr2, nr3; lexo.open("leximi.txt", ios::in); //ifstream lexo("leximi.txt", ios::in); if(!lexo) //kontrolli në fajlli është hapur cout << "\nGabim gjatë hapjes së fajllit"; return 0; lexo >> nr1 >> nr2 >> nr3; shkruaj.open("shkrimi.txt", ios::out); //shkruaj.open("shkrimi.txt", ios::out); shkruaj << "Shuma e tre numrave në " << "fajllin leximi.txt është " << (nr1 + nr2 + nr3) << endl; lexo.close( ); shkruaj.close( ); system("pause"); return 0;

8.2. Qasja të fajllat në unazë Komandat për shkrim dhe lexim në fajlla mund të përfshihen edhe brenda unazave. Paraprakisht deklarohen rrjedhat si objekte të klasave përkatëse dhe hapen fajllat. Për të shkruar në fajlla, të dhënat që fitohen përmes llogaritjeve të ndryshme brenda unazave, komandat për shkrim përfshihen brenda unazës. Për leximin e të dhënave të shkruara në më shumë rreshta duhet të shfrytëzohet unaza, e ngjashme me unazën që është shfrytëzuar për shkrim. 166. Të shkruhet programi përmes së cilit në fajllin rrethi.txt ruhen të

dhënat e rrezes, sipërfaqes dhe perimetrit të rrethit për vlera të ndryshme të rrezes nga 1 deri në 5 me hapin 1. Për shkrim të të dhënave të përdoret manipulatori setw. Më pas të dhënat e shkruara në fajllin rrethi.txt të lexohen dhe të shtypen në ekran.

#include <iostream> #include <fstream> #include <iomanip> using namespace std;

www.e-Libraria.com


178

int main() double pi=3.1415926,r,s,p; ofstream shkruaj("rrethi.txt",ios::out); for(int r=1;r<=5;r++) s=2*pi*r; p=pi*r*r; shkruaj << setw(4) << r << ' ' << setw(7) << s << ' ' << setw(7) << p << endl; cout << "\nShkrimi në fajll përfundoi\n\n"; ifstream leximi("rrethi.txt",ios::in); cout << "\nTë dhënat e lexuara nga fajlli" << "\n\n r s p\n\n" << fixed << setprecision(2); for(int i=1;i<=5;i++) //a dihet sa rreshta jane? Jo! leximi>> r >> s >> p; cout<< setw(4) << r << setw(7) << s << setw(7) << p << "\n"; leximi.close( ); shkruaj.close( ); system("pause"); return 0; 167. Të modifikohet shembulli paraprak duke përdorur vetëm një objekt edhe

për lexim edhe për shkrim. Leximi të bëhet deri sa nuk arrihet në fund të fajllit.

//Shfrytëzimi i një objekti të vetëm #include <iostream> #include <fstream> #include <iomanip> using namespace std; int main() double pi=3.1415926,r,s,p; fstream rrethi("rrethi.txt",ios::in|ios::out); for(int r=1;r<=5;r++) s=2*pi*r; p=pi*r*r; rrethi << setw(4) << r << ' ' << setw(7) << s << ' ' << setw(7) << p << endl;

www.e-Libraria.com


179

cout << "\nShkrimi në fajll përfundoi\n\n"; //pozita ne fajll; provoni edhe rrethi.seekp(0); rrethi.seekg(0); cout << "\nTë dhënat e lexuara nga fajlli" << "\n\n r s p\n\n" << fixed << setprecision(2); while(!rrethi.eof()) rrethi>> r >> s >> p; if(!rrethi.eof()) cout<< setw(4) << r << setw(7) << s << setw(7) << p << "\n"; rrethi.close(); system("pause"); return 0;

8.3. Tekstet dhe numrat në fajlla Në fajlla mund të shkruhen dhe të lexohen edhe tekste edhe numra, përkatësisht stringje. Vlerat numerike që shkruhen në fajll mund të shoqërohen edhe me tekste, plotësisht njëlloj siç shoqërohen edhe gjatë shtypjes në ekran. Por, këtu duhet pasur kujdes që në mes të dhënave të veçanta të lihet së paku një hapësirë, në mënyrë që të dallohen të dhënat e veçanta. 168. Të shkruhet programi përmes së cilit shkruhet së paku një fjali në

fajllin teksti.txt. Më pas të lexohet përmbajtja e këtij fajlli dhe të shtypet në ekran duke shfrytëzuar një variabël të tipit string.

#include <iostream> #include <fstream> #include <string> using namespace std; int main() // -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ Shkrimi në fajll -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ ofstream shkruaj("teksti.txt",ios::out); shkruaj << "Universiteti i Prishtinës -‐ FIEK"; cout << "\nShkrimi në fajll përfundoi\n"; shkruaj.close(); // -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ Leximi nga fajlli -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ string str; ifstream Lexo("teksti.txt",ios::in); cout << "\nTeksti i lexuar nga fajlli\n\n"; while (!Lexo.eof())

www.e-Libraria.com


180

Lexo >> str; cout<< str << endl; //cout<< str <<' '; //cout<< str ; cout << "\nLeximi nga fajlli përfundoi\n\n"; system("pause"); return 0; 169. Të shkruhet programi përmes së cilit në një fajll shkruhen dy variabla

të shoqëruara me vlerat e tyre (pamja 1). Më pas të lexohen këto të dhëna dhe të shtypen në ekran (pamja 2).

#include <iostream> #include <fstream> #include <string> using namespace std; int main() int v1=2013; double v2=23.05; ofstream shkruaj("numrat.txt",ios::out); shkruaj << "v1= " << v1 << " v2= " << v2; cout << "\nShkrimi në fajll përfundoi\n\n"; shkruaj.close(); int a; double b; string s1,s2; ifstream lexo("numrat.txt",ios::in); lexo>> s1 >> a >> s2 >> b; cout << "\nTë dhënat e lexuara nga fajlli\n\n" << s1 << a << "\n" << s2 << b << "\n\n"; lexo.close();

www.e-Libraria.com


181

system("pause"); return 0; 170. Të shkruhet programi përmes së cilit në fajllin data.txt shkruhen

vlerat e tri variablave (char, int, double) dhe vlerat e dy variablave string.

#include <fstream> #include <iostream> #include <string> using namespace std; int main() char k = 'x'; int n = 77; double d = 6.02; string emri = "Vehbi"; string mbiemri = "Neziri"; ofstream outfile("data.txt"); outfile << k //shkrimi i të dhënave << n << ' ' //hapësira në mes numrave << d << emri << ' ' //hapësira në mes stringjeve << mbiemri; cout << "Të dhënat u ruajten në fajll\n"; system("pause"); return 0; 171. Të shkruhet programi përmes së cilit lexohen të dhënat e shkruara

përmes shembullit paraprak. include <fstream> #include <iostream> #include <string> using namespace std; int main() char k; int n; double d; string emri; string mbiemri; ifstream infile("data.txt"); //ekstrakto (lexo) te dhenat nga fajlli infile >> k >> n >> d >> emri >> mbiemri; cout << k << endl //shfaq te dhenat

www.e-Libraria.com


182

<< n << endl << d << endl << emri << endl << mbiemri << endl; system("pause"); return 0;

8.4. Shkrimi dhe leximi i karaktereve Për shkrimin e të dhënave apo leximin e tyre nga fajlli si karaktere, mund të shfrytëzohen funksionet put dhe get. Në formë të përgjithshme, versionet themelore të këtyre dy funksioneve duken si më poshtë, ku k është karakteri që shkruhet ose lexohet:

Vlera e k mund të jetë edhe numër, p.sh cout.put(65); do të vendos shkronjën A, pasi që 65 është kodi ASCII i shkronjës A. 172. Të shkruhet programi i cili tekstin e dhënë në një string e shkruan në

fajll duke përdorur funksionin put(). Më pas teksti i shkruar në fajll të lexohet përmes funksionit get() dhe të shfaqet në ekran.

#include <fstream> #include <iostream> #include <string> using namespace std; int main() string str = "Nëse rrezikon mund të humbasësh, " "nëse nuk rrezikon ke humbur gjithsesi"; ofstream shkruaj("putget.txt"); for(int i=0; i<str.size(); i++) //për secilin karakter, shkruaj.put(str[i] ); //shkruaj në fajll cout << "Fajlli u shkrua\n"; shkruaj.close(); char ch; ifstream lexo("putget.txt"); while(lexo ) //lexo deri në fund të fajllit lexo.get(ch); //lexo karakterin if(lexo) cout << ch; //shfaqe karakterin e lexuar cout << endl; lexo.close();

www.e-Libraria.com


183

system("pause"); return 0; 173. Të shkruhet programi i cili tekstin e dhënë përmes tastiere e lexon

deri tek karakteri i caktuar dhe të njëjtin e ruan në fajllin karakteri.txt. Më pas, teksti të lexohet nga fajlli dhe të shtypet në ekran.

#include <iostream> #include <fstream> using namespace std; int main () ofstream shkruaj ("karakteri.txt", ios::out); char k; cout << "Shëno një fjali (përdor . per të përfunduar):\n"; do k = std::cin.get(); shkruaj.put(k); while (k!='.'); shkruaj.close(); ifstream lexo("karakteri.txt",ios::in); cout << "\nFjalia e lexuar nga fajlli\n\n"; while (lexo.good()) char c = lexo.get(); if (lexo.good()) cout << c; lexo.close(); system("pause"); return 0;

8.5. Leximi i rreshtave Nga fajllat mund të lexohen rreshtat komplet, përfshirë edhe hapësirat që mund të paraqiten brenda tyre. Gjithashtu, të dhënat në këta rreshta mund të lexohen deri në paraqitjen e një simboli të caktuar. Në të dy këto raste, për leximin e të dhënave nga fajlli, shfrytëzohet funksioni getline.

Ku, str është baferi në të cilin ruhet teksti i lexuar; max -‐ gjatësia e stringut që lexohet; delim -‐ Karakteri ndarës ose kufitar (delimiter).

www.e-Libraria.com


184

174. Të shkruhet programi përmes së cilit shkruhet disa rreshta tekst të

çfarëdoshëm në fajllin getline.txt. Më pas këta rreshta të tekstit të lexohen përmes funksionit getline dhe të shtypen në ekran.

#include <fstream> #include <iostream> using namespace std; int main() ofstream shkruaj("getline.txt"); shkruaj << "Kur s'ke kokë, ke këmbë.\n"; shkruaj << "Mate shtatë herë, e preje një herë.\n"; shkruaj << "Cdo hap drejt kulturës, është hap drejt lirisë.\n"; shkruaj.close(); const int max = 80; char buffer[max]; //bufer ifstream lexo("getline.txt"); while(!lexo.eof() ) lexo.getline(buffer, max); //lexo një rresht lexo.getline(buffer,max,'ë'); //lexo deri në karakterin 'ë' cout << buffer << endl; //shfaqe rreshtin system("pause"); return 0;

8.6. Mode të hapjes së fajllave Fajllat mund të hapen në mode të ndryshme, në varësi se për ëka nevojiten, për shkrim, lexim, modifikim.

Modi i hapjes Përshkrimi

in Hapet fajlli për lexim.

out Hapet fajlli për shkrim.

trunc Fshihet përmbajtja e fajllit.

app Fillo shkrimin në fund të fajllit (append).

nocreate Nëse fajlli nuk ekziston, hapja e tij dështon.

noreplace Nëse fajlli ekziston, hapja e tij dështon.

ate Fillo leximin ose shkrimin në fund të fajllit.

binary Hapet fajlli si fajll binar.

www.e-Libraria.com


185

175. Të shkruhet programi përmes së cilit shtohet tekst në fajllin ekzistues append.txt. Më pas, përmes një objekti tjetër të shkruhen disa rreshta tekst në fajllin binar.bin e të hapur në modin binar.

#include <fstream> #include <iostream> using namespace std; int main() //-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐modi append-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ cout << "Teksti do të shkruhet në vazhdim të" " përmbajtes ekzistuese\n"; ofstream shkruaj; shkruaj.open("append.txt", ios::app); shkruaj << "Filan Fisteku\n"; shkruaj.close( ); cout << "Shtimi i studentit u krye.\n"; //-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐modi binar-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ ofstream binar("binar.bin",ios::out|ios::binary); binar << "Rreshti i parë\n"; binar << "Rreshti i dytë\n"; cout << "\nShkrimi në fajllin binar përfundoi\n\n"; system("pause"); return 0; 176. Të shkruhet programi përmes së cilit në fajllin ekzistues i cili

përmban disa emra të shtohen edhe disa emra të rinj. Gjatë hapjes së fajllit të shtypet përmbajtja ekzistuese, kurse pas regjistrimit të emrave të rinj të shtypet përsëri përmbajtja e fajllit.

#include <iostream> #include <fstream> #include <string> using namespace std; const char * fajlli = "emrat.txt"; int main() char ch; ifstream lexo; lexo.open(fajlli); if (lexo.is_open()) cout << "Permbajtja aktuale e fajllit " << fajlli << ":\n"; while (lexo.get(ch)) cout << ch; lexo.close(); ofstream shkruaj(fajlli, ios::out | ios::app); if (!shkruaj.is_open()) cout << "Fajlli " << fajlli << " nuk mund te hapet.\n";

www.e-Libraria.com


186

exit(EXIT_FAILURE); cout << "Sheno emrat e rinj (rresht i zbrazur per ta perfunduar):\n"; string name; while (getline(cin,name) && name.size() > 0) shkruaj << name << endl; shkruaj.close(); lexo.open(fajlli); if (lexo.is_open()) cout << "Permbajtja e ndryshuar e fajllit " << file << ":\n"; while (lexo.get(ch)) cout << ch; lexo.close(); system("pause"); return 0;

8.7. Pozita në fajll Pozita në të cilën shkruhen ose lexohen të dhënat nga fajlli, përcaktohet me pozitën e pointerit në fajll. Sa herë që shkruhet ose lexohet në fajll, pointeri i pozitës në fajll rritet automatikisht. Pozita e pointerit në fajll mund të përcaktohet edhe direkt, duke i shfrytëzuar funksionet: seekp() dhe seekg(). 177. Të shkruhet programi përmes së cilit lexohet karakteri i cili gjendet

në pozitën e dhënë përmes tastierës. #include <iostream> #include <fstream> using namespace std; int main() int p; char k; fstream pozita("pozita.txt",ios::out|ios::in|ios::trunc); pozita << "Ky shembull mundëson leximin e " "karakterit në pozitën e caktuar\n"; cout << "\nJep pozitën e karakterit që dëshiron të lexohet: "; cin >> p; pozita.seekg(p); pozita.get(k); cout << "\nKarakteri në bajtin me numër rendor " << p << " është: " << k

www.e-Libraria.com


187

<< "\n\n"; //për ta lexuar pozitën aktuale ne fajll //përdoret tellg(); p.sh pozita.tellg(); system("pause"); return 0; 178. Të shkruhet programi përmes së cilit lexohet nga një fajll tekstual.

Pointeri të zhvendoset në pozita të ndryshme dhe të lexohen karakteret që gjendet në ato pozita.

#include <iostream> #include <fstream> using namespace std; int main() char ch; ifstream fajlli; fajlli.open("alfabeti.txt"); if (!fajlli) cout << "Fajlli nuk ekziston. " << endl; system("pause"); return 1; fajlli.get(ch); cout << "Bajti i parë: " << ch << endl; fajlli.seekg(6, ios::cur); fajlli.get(ch); cout << "Bajti tek pozita 6: " << ch << endl; fajlli.seekg(7, ios::beg); fajlli.get(ch); cout << "Bajti i shtatë prej fillimi: " << ch << endl; fajlli.seekg(-‐26, ios::end); fajlli.get(ch); cout << "Bajti i 26 prej fundi: " << ch << endl; system("pause"); return 0;

8.8. Fajllat me qasje direkte Për qasje direkte tek të dhënat e përfshira në fajlla shfrytëzohen fajllat me qasje direkte. Në praktikë, fajllat e tillë deklarohen si fajlla binarë duke shfrytëzuar regjistrime me gjatësi fikse. Të dhënat individuale të një fajll me qasje të rastit mund të arrihen drejtpërdrejt (dhe shpejt), pa kërkuar shumë shënime të tjera.

www.e-Libraria.com


188

Tek fajllat me qasje direkte, të dhënat shkruhen ose lexohen si blloqe të dhënash, duke i shfrytëzuar funksionet write dhe read. Hapësira memoruese, e cila shfrytëzohet në fajll për ruajtjen e të dhënave të veçanta, është fikse dhe varet nga tipi i variablave përkatëse. P.sh. për ruajtjen e vlerës 12345678 të një variable të tipit int, në fajll do të shfrytëzohet hapësirë 4-‐bajtëshe, gjë që dallon nga fajllat me qasje sekuenciale, tek të cilët numri i njëjtë vendoset në 8-‐bajtë (për çdo shifër shfrytëzohet 1 bajt). Forma e përgjithshme e këtyre funksioneve është dhënë në vijim:

Ku &v është adresa e variablës v, vlera e së cilës shkruhet në fajll; sizeof(v) -‐ numri i bajtëve tek të cilët shkruhet vlera e variablës v. 179. Të shkruhet programi përmes së cilit vlera e variablës a shkruhet në

fajllin me qasje direkte direkt.bin. Më pas të deklarohet një variabël b dhe vlera e lexuar nga fajlli të i shoqërohet kësaj variable.

#include <iostream> #include <fstream> using namespace std; int main() //-‐-‐-‐-‐-‐-‐shkrimi në fajll-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ int a=12345678; ofstream shkruaj ("direkt.bin",ios::out|ios::binary); shkruaj.write((char*) &a,sizeof(a)); shkruaj.close(); cout << "\nShkrimi ne fajll përfundoi\n\n"; //-‐-‐-‐-‐-‐-‐leximi nga fajlli-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ int b; ifstream lexo("direkt.bin",ios::in|ios::binary); lexo.read((char*) &b,sizeof(b)); cout<< "\nVlera e lexuar nga fajlli b=" << b << "\n\n"; system("pause"); return 0;

www.e-Libraria.com


189

180. Të shkruhet programi i cili duke përdorur operatorin sizeof përcakton

madhësinë në bajt për tipat e ndryshëm të të dhënave. Rezultati të ruhet në fajllin me emrin madhësia.txt.

#include <fstream> #include <iostream> using namespace std; #include <iomanip> int main() char v[]="\n-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐\n"; ofstream shkruaj( "madhesia.txt" ); if ( !shkruaj ) cout << "Nuk mund të hapet fajlli \"madhesia.txt\".\n"; exit(0); shkruaj << "Tipi i të dhenave" << setw(12) << "Madhësia" <<v <<"char" << setw(21) << sizeof( char ) << "\nunsigned char" << setw(12) << sizeof( unsigned char ) << "\nshort int" << setw(16) << sizeof( short int ) << "\nunsigned short int" << setw(7) << sizeof( unsigned short) << "\nint" << setw(22) << sizeof(int) << '\n' << "unsigned int" << setw(13) << sizeof(unsigned) << "\nlong int" << setw(17) << sizeof( long ) << "\nunsigned long int" << setw(8) << sizeof( unsigned long ) << "\ndouble" << setw(19) << sizeof( double ) << "\ndouble" << setw(19) << sizeof( double ) << "\nlong double" << setw(14) << sizeof( long double ) <<v << endl; shkruaj.close(); return 0;

8.9. Vlerat e fushave në fajlla Në fajllat me qasje direkte mund të shkruhen vlerat e fushave një dimensionale (vektorëve), fushave dy dimensionale (matricave), ose edhe të fushave shumëdimensionale. Komandat të cilat përdoren për shkrim/lexim të fushave në fajlla me qasje direkte nuk dallojnë nga ato të shfrytëzuara gjatë shkrim/leximit të vlerave të variablave të zakonshme. Hapësira në të cilën shkruhet/lexohet fusha në fajll përcaktohet duke e shumëzuar numrin e anëtarëve të fushës dhe numrin e bajtëve që shfrytëzohen prej tyre, p.sh sizeof(int).

www.e-Libraria.com


190

181. Të shkruhet programi përmes së cilit vlerat e vektorit A shkruhen në fajllin vektori.bin. Më pas vlerat e vektorit të lexohen nga fajlli dhe të shtypen në ekran.

#include <fstream> #include <iostream> using namespace std; const int m=6; int main() int i,A[m]=3,4,-‐1,-‐5,5,8; // -‐-‐-‐Shkrimi ne fajll i vlerave të vektorit -‐-‐-‐-‐-‐ ofstream shkruaj ("vektori.bin",ios::out|ios::binary); shkruaj.write((char*) &A,sizeof(A)); cout << "\nShkrimi ne fajll perfundoi\n\n"; shkruaj.close(); /*Për tu siguruar se vlerat lexohen nga fajlli provoni që vlerat e vektorit të bëhen zero A[i]=0 */ // -‐-‐-‐-‐-‐-‐ Leximi i vektorit nga fajlli -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ ifstream lexo("vektori.bin",ios::in|ios::binary); lexo.read((char*) &A,sizeof(A)); // -‐-‐-‐-‐-‐-‐ Shtypja e vektorit në ekran -‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐-‐ cout << "\nVlerat e lexuara nga fajlli:\n"; for (i=0;i<m;i++) cout<< "\n A[" << i << "]=" << A[i]; cout << "\n\n"; system("pause"); return 0; 182. Të shkruhet programi përmes së cilit vlerat e matricës Mat shkruhen në

fajllin matrica.bin. Më pas vlerat e matricës të lexohen nga fajlli dhe të shtypen në ekran.

#include <fstream> #include <iostream> #include <iomanip> using namespace std; const int m=4, n=3; int main() int Mat[m][m]= 3,-‐1,4, 3, 6,2, 2,-‐5,6, 3, 4,9

www.e-Libraria.com


191

; ofstream shkruaj; shkruaj.open("matrica.bin", ios::out | ios::binary); for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) if (Mat[i][j] != 0) shkruaj.write (reinterpret_cast<char*> (&Mat[i][j]), sizeof(int)); shkruaj.close(); ifstream lexo; lexo.open("matrica.bin", ios::in | ios::binary); for (int i = 0; i < m; i++) for (int j = 0; j < n; j++) lexo.read (reinterpret_cast<char*> (&Mat[i][j]), sizeof(int)); cout<<setw(3)<<Mat[i][j]; cout<<endl; lexo.close(); system("pause"); return 0;

8.10. Objektet në fajlla Të dhënat e përfshira në anëtarët e strukturave ose të klasave mund të lexohen ose të shkruhen në fajlla me qasje sekuenciale, ose edhe në fajlla me qasje direkte. 183. Të shkruhet programi në të cilin deklarohet struktura studentet (emri,

indeksi, vendi). Vlerat e anëtarëve të merren përmes tastiere dhe më pas duke shfrytëzuar objektin e strukturës këto të dhëna të shkruhen dhe të lexohen nga fajlli me qasje direkte i quajtur objekti.dat.

#include <fstream> #include <iostream> #include <string> using namespace std; struct studentet string emri; string indeksi; string vendi;

www.e-Libraria.com


192

; int main() studentet ob_sh; cout << "Emri dhe mbiemri: "; getline(cin,ob_sh.emri); cout << "Numri i indeksit: "; getline(cin,ob_sh.indeksi); cout << "Vendbanimi: "; getline(cin,ob_sh.vendi); //shkrimi në fajll i i vlerave të anëtarëve të objektit stud ofstream shkruaj("objekti.dat",ios::out|ios::binary); shkruaj.write((char *)(&ob_sh),sizeof(ob_sh)); shkruaj.close(); cout<<"\nShkrimi i të dhënave të anëtarëve të strukturës përfundoi" <<"\n\nLeximi i të dhënave nga fajlli\n\n"; //leximi i të dhënave dhe vendosja në anëtarët e objektit stud ifstream lexo("objekti.dat",ios::in|ios::binary); lexo.read((char *)(&ob_sh),sizeof(ob_sh)); lexo.close(); // shtypja e të dhënave në ekran cout<<"Emri: " <<ob_sh.emri<<endl; cout<<"Indeksi: " <<ob_sh.indeksi<<endl; cout<<"Vendi:"<< ob_sh.vendi<<endl; system("pause"); return 0; 184. Të shkruhet programi në të cilin duke përdorur strukturën presidenti

(id, emri, mbiemri, qyteti, viti lindjes, titulli), të dhënat presidentit që cilat merren përmes tastiere shkruhen në fajllin binar presidenti.bin

#include <iostream> #include <fstream> #include <sstream> using namespace std; struct presidenti int idkandidat; string emri; string mbiemri; string qyteti; int vitilindjes; string titulli; pres; void ruaj_kandidat(ofstream &rrjedha) rrjedha.write(reinterpret_cast<char*>(&pres), sizeof(pres));

www.e-Libraria.com


193

rrjedha.close(); void regjistro_kandidat() cout<<"ID: " ; cin>>pres.idkandidat; cout<<"Emri: " ; cin>>pres.emri; cout<<"Mbiemri: " ; cin>>pres.mbiemri; cout<<"Qyteti: " ; cin>>pres.qyteti; cout<<"Viti lindjes: " ; cin>>pres.vitilindjes; cout<<"Titulli: " ; cin>>pres.titulli; int main() ofstream rrjedha("presidenti.dat", ios::binary|ios::app); if(!rrjedha) cout << "Fajlli nuk eshte gjendur ose nuk mund te hapet!" << endl; return 0; else cout << "Regjistrimi i kandidateve per president. \n\n"; char pyet; do regjistro_kandidat(); ruaj_kandidat(rrjedha); cout<<"A deshiron te regjistrosh kandidat tjeter? (Po=p, Jo=j)"; cin>>pyet; while (pyet!='j' || pyet!='J'); system("pause"); return 0; 185. Të shkruhet programi në të cilin duke përdorur strukturën presidenti,

të deklaruar në shembullin paraprak, të lexohen të dhënat e kandidatëve për president dhe të shtypen në ekran.

#include <iostream> #include <fstream> #include <sstream> using namespace std; struct presidenti int idkandidat; string emri; string mbiemri; string qyteti; int vitilindjes; string titulli; pres; void shfaq_kandidat()

www.e-Libraria.com


194

cout<<"ID: " <<pres.idkandidat; cout<<"\nEmri: " <<pres.emri; cout<<"\nMbiemri: " <<pres.mbiemri; cout<<"\nQyteti: " <<pres.qyteti; cout<<"\nViti lindjes: "<<pres.vitilindjes; cout<<"\nTitulli: " <<pres.titulli<<endl<<endl; void lexo_kandidat(ifstream &rrjedha) while(rrjedha.read((char *) (&pres), sizeof(pres))) shfaq_kandidat(); rrjedha.close(); int main() ifstream rrjedha("presidenti.dat", ios::binary); if(!rrjedha) cout << "Fajlli nuk është gjendurr ose nuk mund të hapet!" << endl; return 0; else lexo_kandidat(rrjedha); system("pause"); return 0; 186. Të shkruhet programi në të cilin deklarohet klasa personi (emri,

mosha). Vlerat e anëtarëve të merren përmes tastiere dhe më pas duke shfrytëzuar objektin e klasës, këto të dhëna të shkruhen dhe të lexohen nga fajlli me qasje direkte i quajtur personi.dat.

#include <fstream> #include <iostream> using namespace std; class personi protected: char emri[30]; short mosha; public: void vendos_vlerat() cout << "Emri dhe mbiemri: "; cin.getline(emri,30); cout << "Mosha: "; cin >> mosha; void lexo_vlerat() cout << "\nEmri dhe mbiemri: "<< emri;

www.e-Libraria.com


195

cout << "\nMosha: "<< mosha; ; //reinterpret_cast përdoret për konvertimin // e adresës së objektit në char int main() personi pers; pers.vendos_vlerat(); //shkrimi i të dhënave të objektit pers në fajll ofstream shkruaj("personi.dat", ios::binary); shkruaj.write(reinterpret_cast<char*>(&pers), sizeof(pers)); shkruaj.close(); //leximi i të dhënave nga fajlli dhe // vendosja e tyre në objektin pers ifstream lexo("personi.dat", ios::binary); lexo.read(reinterpret_cast<char*>(&pers), sizeof(pers)); lexo.close(); // shtypja e të dhënave në ekran pers.lexo_vlerat(); cout<<endl; system("pause"); return 0;

www.e-Libraria.com


196

9. Pyetje dhe shembuj vetë-‐testues

9.1. Funksionet

1. A paraqet prototip të funksionit apo thirrje të funksionit rreshti i mëposhtëm?

totali(); 2. A paraqet prototip të funksionit apo thirrje të funksionit rreshti i

mëposhtëm? void rezultati(); 3. Cili prototip është i shkruar saktë?

a. void numri(double); b. numri(10.55);

4. Sa vlera mund të kthejë një funksion në C++?

a. 1 b. 2 c. Shumë d. Asnjë

5. Kur funksioni merr më shumë se një parametër, a ka rëndësi renditja e tyre

gjatë thirrjes së funksionit? 6. A mundet funksioni të ketë variabël me emrin e njëjtë sikurse variabla

globale? 7. Gjej gabimet në funksionin e mëposhtëm.

void totali(int v1, v2, v3) return v1 + v2 + v3; 8. Gjej gabimet në funksionin e mëposhtëm. double mesatarja(int v1, int v2, int v3) double average; average = v1 + v2 + v3 / 3;

www.e-Libraria.com


197

9. Shkruaj prototipin e funksionit dhe krijimin e tij i cili merr tre parametra (argumente) int dhe kthen si rezultat shumën e tyre.

10. Shkruaj deklarimin dhe krijimin e funksionit i cili merr një parametër

të tipit double. Funksionin duhet të kthej 'P' nëse parametri është pozitiv dhe 'N' nëse parametri është negativ.

11. Të shkruhet funksionin void i cili ka tre parametra të tipit int dhe i

cili shtyp në ekran prodhimin e tre parametrave. 12. Të shkruhet funksioni i cili ka një parametër të tipit char dhe i cili

kthen true nëse parametri është numër, dhe false nëse parametri nuk është numër.

13. Supozoni se funksioni funksioni1 e ka një variabël të deklaruar

përbrenda tij me emrin shuma, por edhe funksioni2 e ka të deklaruar variablen me të njëjtin emër shuma.

a. A do të kompilohet programi? b. A do të ekzekutohet programi?

14. Nëse një variabël përdoret vetëm tek një funksion, ku duhet të

deklarohet ajo?

a. Në të njëjtin funksion? b. Në funksionin main? c. Në çdo pjesë të kodit?

15. Të shkruhet shprehja e cila ia shoqëron variablës n një numër të plotë

të gjeneruar në mënyrë të rastësishme. a. b.

16. Të shkruhet shprehja për secilin grup e cila do të shtyp numrat e

rastit nga grupi. c. 2, 4, 6, 8, 10 d. 6, 10, 14, 18, 22

17. Një parking e ka tarifën e parkingut 1Euro deri në 3 orë dhe më pas çdo

orë nga 0.5Euro. Maksimumi i pagesës për 24 orë është 5 euro. Të shkruhet funksioni i cili llogarit koston e parkingut për disa vetura të cilat janë parkuar në kohë të ndryshme (të jepet para sa orësh janë parkuar). Më pas të printohet kostoja për secilën veturë dhe totali për të gjitha veturat.

18. Të shkruhet programi i cili i pranon 10 numra përmes tastiere dhe i

ruan në një vektor. Vektori të jetë parametër i një funksioni i cili e shtyp në ekran numrin më të madh dhe më të vogël.

www.e-Libraria.com


198

19. Të shkruhet programi i cili përmes një funksioni i cili ka si parametër

numrin e minutave e kthen rezultatin në orë. P.sh nëse kemi 90 minuta të kthehet rezultati 1 orë e 30 minuta.

20. Të shkruhet programi i cili përmes një funksioni i konverton numrat romak në numra decimal.

9.2. Numerimet 1. Çka është enumeration dhe grupim i kujt është?

2. Nëse deklarimet e mëposhtme janë pjesë e një programi të rregullt, çfarë do të shtypet pas ekzekutimit.

enum drejtimi V, J, L, P ; // ... cout << P << " " << L << " " << J << " " << V << endl; 3. Nëse deklarimet e mëposhtme janë pjesë e një programi të rregullt, çfarë

do të shtypet pas ekzekutimit. enum drejtimi V=3, J, L=6, P ; // ... cout << P << " " << L << " " << J << " " << V << endl; 4. Të deklarohet një grup me emrin qytetet i cili përmban qytetet e Kosovës. 5. Enumeration janë:

a) konstante b) tipa të dhëna të përcaktuara nga përdoruesi c) karaktere

6. Enumeration ruhen nga kompajleri si:

a) string b) integer c) float

7. Çka ndodh kur të krijohet një enumeration (grup)?

a) Rezervohet memorie b) Nuk rezervohet memorie c) Nuk rezervohet memorie për variablën e grupit

www.e-Libraria.com


199

8. Të shkruhet një program i cili simulon punën e semaforëve të trafikut. Të

përdoret një enumeration për ngjyrat e semaforit. Programi të përseritet për një numër të caktuar të cikleve.

9. Të shkruhet një programi i cili në një enumeration/grup definon tipat e

gabimeve të mundshme për programin e shkruar dhe më pas duke përdorur vlerat e grupit të shfaqet lloji i gabimit.

10. Të shkruhet programi dhe të deklarohet një grup/enumeration me emrin

nota i cili si anëtarë ka notat nga pesë deri në dhjetë. Secilit anëtar të i shoqërohet vlera numerike. Të lexohen vlerat e anëtarëve të grupit dhe të ruhen në një vektor.

9.3. Sinonimet 1. Të deklarohet sinonime të ndryshme për tipat klasik të të dhënave.

9.4. Strukturat 1. Të shkruhet programi dhe të krijohet një strukturë e të dhënave e quajtur

Vetura e cila përmban dy anëtarë: një anëtarë int për vitin dhe një fushë double për shpenzimet e derivateve për 100km. Në program të deklarohet një makinë dhe të caktohen vlerat për të si dhe të shfaqen në ekran.

2. Të shkruhet programi dhe të krijohet një strukturë e të dhënave Fakulteti

e cila përmban anëtarët për vitin e themelimit, numrin e studentëve dhe pagesën vjetore të shkollimit: Të dhënat tç lexohen përmes tastiere dhe më pas të shtypen në ekran.

3. Të shkruhet programi dhe të krijohet një strukturë e të dhënave Kompjuteri

e cila përmban disa anëtarë për karakteristikat e kompjuterit. Në program të krijohen dy kompjuterë dhe më pas të krahasohen disa nga karakteristikat e kompjuterëve.

4. Nëse është dhënë struktura katrori

struct katrori int gjeresia int gjatesia ;

Të shkruhet funksioni i cili shfaq përmbajtjen e strukturës. Funksioni ka si parametër strukturën katrori.

www.e-Libraria.com


200

5. Të deklarohet një strukturë me emrin Llogaria e cila mban të dhënat për një llogari bankare. Të përfshihet konstruktori i cili lejon që anëtarët të inicohen me vlera. Më pas të shtypen në ekran të dhënat e klientit.

6. Të deklarohet një strukturë me emrin ShkallaTemp me anëtarët Fahreiheit

dhe Celsius. Struktura tjetër të jetë Leximi me anëtarët shpejtesiEra, Lageshtia dhe variabla e strukturës ShkallaTemp. Në funksionin main të deklarohet variabla e strukturës Leximi dhe të shtypet të dhënat si në vijim:

Shpejtësia e erës: 35 m/h Lagështia 29% Temperatura në Fahreinheit: 89.6 Temperatura në Celsius: 32

7. Të shkruhet programi i cili ka një funksion me parametër strukturën Leximi

(detyra paraprake) dhe i cili shtyp në ekran të dhënat për motin.

8. Të shkruhet programi dhe të krijohet struktura e cila mban listën e emailave. Përmes një funksioni të shtypet lista e emailave.

9. Të shkruhet programi në të cilin krijohet një strukturë për të mbajtur të

dhënat për rezervimet e biletave të aeroplanit. Të dhënat e nevojshme janë:

Numri i fluturimit Kodi i aeroportit të nisjes Kodi i aeroportit të destinacionit Koha e nisjes Koha e arritjes Çmimi i biletës

10. Nëse buxheti mujor i një studenti është si më poshtë:

Të shkruhet programi që deklaron një strukturë BuxhetiMujor me anëtarë për të mbajtur vlerat e kategorive të mësipërme. Në program të deklarohen dy variabla të strukturës; njëra me vlerat e dhëna më lart dhe tjetra me vlera të ndryshme. Përmes një funksioni i cili ka si parametra formalë dy variablat e strukturës së krahasohen shpenzimet e variablës së parë dhe të dytë dhe të tregohet se për cilat kategori është tejkaluar buxheti e për cilat jo.

www.e-Libraria.com


201

9.5. Klasat 1. Cili është dallimi teknik në mes strukturave dhe klasave? 2. Të përmirësohet gabimi për klasën e mëposhtme:

class fiek public: void printo()const; shuma(); fiek(); int fiek(int, int); private: int x; int y; ; 3. Të krijohet një klasë me emrin drejtkendeshi. Klasa të ketë anëtarët

privat gjatesia dhe gjeresia të cilët kanë vlera të nënkuptuara 1.0 dhe anëtarët publik për llogaritjen e sipërfaqes dhe perimetrit të drejtkëndëshit. Klasa, po ashtu duhet të ketë funksionet për vendosjen dhe marrjen e vlerave të gjatësisë dhe gjerësisë. Funksionet për vendosjen e vlerës duhet të verifikojnë që gjatësia dhe gjerësia të jenë më mëdha se 0.0 dhe më të vogla se 20.00, në të kundërtën vlerat të vendosen në 0.0.

a. Të implementohet klasa drejtkendeshi me anëtarët e cekur në përshkrimin në të majtë.

b. Të implementohet funksioni për llogaritjen e sipërfaqes dhe perimetrit të drejtkëndëshit si dhe funksionet për vendosjen dhe marrjen e vlerave të gjatësisë dhe gjerësisë.

c. Të implementohet funksioni main në të cilin deklarohen tre objekte të klasës drejtkendeshi dhe thirren për vlera të ndryshme. Objekti i parë të thirret me vlerat e nënkuptuara, objekti i dytë me çfarëdo vlerash dhe objekti i tretë me vlera më të mëdha se 0 ose më të vogla se 20.

4. Anëtarët e klasës mund të jenë?

a) Variabla b) Funksione c) Edhe variabla edhe funksione d) Asnjëra

5. Kodi i mëposhtëm ka gabime. Të gjenden dhe të përmirësohen gabimet.

class fiek public: void printo()const; shuma(); fiek(); int fiek(int, int); private: int x;

www.e-Libraria.com


202

int y; ;

6. Të implementohet klasa shitja me anëtarin privat taksa dhe anëtarin

publik, funksionin shitjaTotale i cili kthen çmimin së bashku me taksë. Klasa të ketë konstruktorin e nënkuptuar i cili vendos taksen në zero dhe konstruktorin i cili vendos taksen në vlerën e caktuar.

a. Të implementohet klasa shitja sipas përshkrimit të sipërm. b. Të implementohet funksioni main dhe të deklarohen dy objekte.

Objekti i parë nuk ka parametër, kurse objekti i dytë e ka si parametër taksën e cila jepet në përqindje.

7. Të krijohet një enumeration ngjyrat (kuqe, kaltër, verdhë, portokalli,

vjollce) dhe klasa perzierja e cila përmban një anëtar me të dhëna të tipit ngjyrat si dhe konstruktorin i cili vendos vlerën e anëtarit nga parametri i tij.

8. Të shkruhet programi dhe të deklarohet klasa Data e cila ka anëtarët për

ruajtjen e ditës, muajit dhe vitit. Klasa të ketë konstruktorin e nënkuptuar (default) dhe konstruktorin me tre parametra i cili e vendos datën gjatë krijimit të objektit. Nëse objekti krijohet pa parametra, ose vlerat e vendosura janë jo të sakta, atëherë data të vendoset në 1.1.2000. Klasa të ketë funksionin Formato i cili e printon datën në njërin nga formatet e zgjedhura si më poshtë:

17/02/2008 17 Shkurt 2008 17.02.2008

9. Llogaritja e shkallës së lindjeve dhe të vdekjeve të një popullsie është

bërë si më poshtë: Shkalla e lindjeve = numri i lindjeve / numri i popullsisë Shkalla e vdekjeve = numri i vdekjeve / numri i popullsisë

Të shkruhet programi dhe të deklarohet klasa Popullsia e cila ruan numrin e popullsisë, numrin e lindjeve dhe vdekjeve vjetore. Vendosja e këtyre vlerave të mundësohet përmes konstruktorit ose përmes funksioneve, vendos_popullsi, vendos_lindje dhe vendos_vdekje. Klasa të ketë edhe funksionet për leximin dhe llogaritjen e shkallës së lindjeve dhe vdekjes. 10. Të shkruhet programi në të cilin krijohet klasa Afatizimet për

afatizimin e parave për periudha të ndryshme kohore. Interesi vjetor të jetë i përshkallëzuar. P.sh afatizimi për 0-‐5 vite për shumat 0-‐jetë 3.2%; 5-‐8 vite për shumat 1000-‐mbi 8 nëpër muaj dhe të shtypet gjendja për secilin klient.

www.e-Libraria.com


203

11. Të shkruhet programi në të cilën krijohet klasa koha e cila ruan orën, minutat dhe sekondat. Të krijohen dy kohe të ndryshme dhe të gjendet sa kohë ka kaluar prej kohës së parë deri të koha e dytë.

12. Të krijohet klasa libraria e cila përmban anëtarët titulli,

autori, botuesi, isbn, viti_botimit, cmimi dhe stoku. Të gjithë këta janë anëtarë privat të klasës, kurse si anëtarë publik duhet të jenë funksionet për vendosjen dhe marrjen e të dhënave për secilin anëtarë. Emërtimi i funksioneve të klasës për vendosjen e të dhënave të jetë sipas standardit v_emertimi (p.sh v_titullin), kurse emërtimi për leximin/marrjen e vlerës së anëtarit të jetë sipas standardit m_emertimi (p.sh m_titullin). Për numrat e ISBN të krijohet një enumeration dhe të përmbajë numrin e juaj të indeksit dhe katër numra të tjerë të indeksit. Në konstruktorin e klasës të bëhet inicimi i anëtarëve të të dhënave (titulli, autori dhe botuesi =" "; isbn me anëtarin e grupit që parqet numrin e juaj të indeksit; viti_botimit=2008, cmimi=26 dhe stoku=50). Objekti i klasës të jetë një vektor me madhësi të njëjtë sikurse muaji i datëlindjes suaj + 1 (p.sh 17.02.2008; m=2+1=3). Mbushja e anëtarëve me të dhëna të bëhet përmes një unaze duke përdorur funksionin mbush() i cili si parametra formalë ka klasën libraria dhe grupin isbn_numrat. Emri i librit të mbushet me një emër të çfarëdoshëm; autori të jetë emri dhe mbiemri i juaj; botuesi të

indeksit i cili është anëtar i grupit; viti i botimit të jetë i rastësishëm nga 2008 deri në 2013; çmimi i librit të jetë çmim i

të zbritet për nga një për secilin objekt. Shtypja e rezultateve të bëhet përmes funksionit shtyp() dhe rezultati të jetë i formatuar si në pamjen e mëposhtme.

9.6. Pointerët 1. Nëse z është variabël, cila shprehje e kthen adresën e variablës z?

a. *p b. &p c. *z d. &z

2. Çka do të shtypet në ekran nëse ekzekutohet kodi i mëposhtëm?

int x, y; int *p = &x; int *q = &y; *p = 35; *q = 98; *p = *q; cout << x << " " << y << endl; cout << *p << " " << *q << endl;

www.e-Libraria.com


204

3. Çka do të shtypet në ekran?

int x, y; int *p = &x; int *q = &y; x = 35; y = 46; p = q; *p = 78; cout << x << " " << y << endl; cout << *p << " " << *q << endl;

4. Të shkruhet programi në të cilin deklarohet vektori A me madhësi 5 dhe të

iniciohet me vlera (5, 10, 15, 20, 25). a. Duke përdorur pointerin ptrA të shtypen vlerat e vektorit A dhe

adresat e anëtarëve të vektorit sipas rendit nga fillimi në fund. b. Duke përdorur pointerin ptrA të shtypen vlerat e vektorit A dhe

adresat e anëtarëve të vektorit sipas rendit nga fundi në fillim duke ia hequr secilit anëtarë edhe vlerën e indeksit.

5. Të shkruhet programi i cili notat e një studenti të dhëna përmes tastiere

i ruan në vektorin nota. Pasi të jenë ruajtur notat, duke shfrytëzuar pointerin notaPtr të gjendet nota më e madhe, nota më e vogël dhe nota mesatare.

6. Të shkruhet programi i cili vlerat e një vektori ku ruhen emrat e studentëve i sorton duke shfrytëzuar pointerët.

9.7. Referencat 1. Të shkruhet programi në të cilin deklarohet një variabël v e tipit double

si dhe variabla referente vref. Vlera e variablës v të ndryshohet në mënyrë të rastësishme dhe të shtypet vlera e variablës referente vref.

2. Të shkruhet programi në të cilin deklarohet funksioni çmimi_ri i cili ka dy parametra formalë referentë. Në parametrin e parë të ruhet çmimi i vjetër kurse në parametrin e dytë të jetë çmimi i ri. Zbritja të jetë e rastësishme në me 5-‐25%.

www.e-Libraria.com


205

3. Të shkruhet programi përmes të cilit tregohet deklarimi i një fushe tredimensionale A(m, n, k) dhe fusha referente B(m, n, k). Dy dimensione të fushës të mbushen me vlera përmes fushës A, kurse një dimension të mbushet përmes fushës referente B.

9.8. Fajllat 1. Të shkruhet programi i cili lexon në një fajll tekstual dhe i numëron

secilin karakter se sa herë paraqitet. Rezultati të shfaqet në ekran ose të ruhen në një fajll tjetër.

2. Të shkruhet programi dhe të krijohet klasa teksti e cila përmban një anëtar të tipit string për të mbajtur tekstin e një fajlli. Klasa të përmbajë konstruktorin e nënkuptuar dhe konstruktorin i cili e ka si parametër emrin e fajllit. Përmes këtij konstruktori të hapet fajlli tekstual dhe përmbajtja e tij të ruhet në anëtarin e klasës. Përmbajtja e tekstit të shtypet në ekran përmes funksionit permbajtja.

3. Të shkruhet programi i cili e lexon një fajll tekstual dhe paraqet raportin e paraqitjes së secilës fjalë, pra sa herë është paraqitur secila fjalë veç e veç.

4. Të shkruhet programi i cili ju mundëson që të mbani evidencën për pajisjet

që keni në punëtorinë tuaj. Të dhënat të ruhen në fajllin me qasje të rastësishme puntoria.dat. Në evidencë duhet të përfshihen numri dhe emri i pajisjes, vlera dhe viti i blerjes dhe koha e amortizimit. Programi të ketë opsionet për shfaqjen e të gjitha pajisjeve, fshirjen e një pajisje, përditësimin e të dhënave të pajisjes së caktuar si dhe regjistrimin e pajisjeve të reja. Vlera aktuale e pajisjes të llogaritet në bazë të vlerës së blerjes dhe kohës së amortizimit.

5. Të shkruhet programi i cili mundëson regjistrimin e numrave të telefonit në një fajll me qasje të rastësishme adresari.dat. Formati i numrave të telefoni të jetë ### ### ### p.sh 044 000 000. Të mundësohet gjetja e numrit në bazë të emrit ose gjetja e emrit në bazë të numrit.

6. Të shkruhet programi i cili përmbajtjen e një fajlli e kopjon në një fajll tjetër.

7. Të shkruhet programi i cili lexon përmbajtjen e një fajlli tekstual. Përmbajtja e fajlliit është e përzier me shkronja dhe me numra. Të ndahen numrat nga shkronjat dhe të ruhen në fajlla të veçantë.

www.e-Libraria.com


206

8. Të shkruhet programi i cili emrave të shkruar në një fajll tekstual ua largon rreshtin e ri dhe të gjithë emrat të jenë në një rresh, por të ndarë me pikëpresje (;).

9. Të shkruhet programi i cili përmbajtjen e një fajlli e ruan në një vektor

të tipit string. Numri i rreshtave të lexuar të përcaktohet gjatë ekzekutimit.

10. Të shkruhet programi i cili lexon një fajll dhe të gjitha shkronjat i

kthen në shkronja të vogla dhe rezultatin e ruan në një fajll të ri.

11. Të shkruhet programi i cili lexon një fajll tekstual dhe i cili shfaq në ekran nga 15 rreshta të tekstit. Pas shtypjes së tastit Enter të shfaqen 15 rreshtat e ardhshëm.

12. Të shkruhet programi për menaxhimin e bankës. Për këtë të krijohet klasa banka e cila si anëtarë privat ka numrin e llogarisë, mbajtësin e llogarisë dhe depozitën fillestare e cila jepet/caktohet gjatë hapjes së llogarisë së klientit. Funksionet e domosdoshme të implementuara brenda klasës duhet të jenë:

Funksioni për krijimin e llogarisë, Funksioni për deponim të parave Funksioni për tërheqje të parave Funksioni për shfaqjen e bilancit për klientin e caktuar Funksioni për mbyllje të llogarisë. Funksioni për afatizimin e parave. Funksion sipas dëshirës për një shërbim të caktuar bankar (Opsioni i

lirë) Mund të implementohen edhe funksione tjera sipas nevojës, si brenda klasës ashtu edhe jashtë klasës. Shënimet e klientit, duke shfrytëzuar objektin e klasës të deklaruar si pointer të ruhen në fajllin me qasje direkte (banka.bin). 13. Të shkruhet programi i cili të gjithë fajllat tekstual që gjenden në

një direktorium të caktuar i ruan në një fajll të vetëm. Përmbajtja e secilit fajll të ndahet duke përdorur emrin e fajllit dhe përmbajtjen si në vijim:

*********************** fajlli1 +++++++++++++++++++++++ . . . përmbajtja e fajlli1 . . . *********************** fajlli2

www.e-Libraria.com


207

+++++++++++++++++++++++ . . . përmbajtja e fajlli2 ***********************

14. Të shkruhet programi i cili krijon një fajll binar në formatin si në vijim: integer, char[15], char[15], byte[1024]. Në këtë fajll të ruhen shënime të studenteve si numri, emri, mbiemri dhe foto. Gjatë futjes së shënimeve në fajll, numri të plotësohet prej programit si numër rendor, emri dhe mbiemri mbushen përmes tastiere, ndërsa foto lexohet prej fajllit të ruajtur në një direktorium të caktuar p.sh c:\foto\. Emri i fotos është i njëjtë me numrin rendor p.sh. 1.jpg, 2.jpg etj.

15. Të shkruhet programi i cili përmbajtjen e një fajlli tekstual e enkripton duke përdorur kodin e Cezarit dhe përmbajtjen e enkriptuar e ruan në fajll të veçantë.

www.e-Libraria.com


208

Literatura

1. Agni Dika, Programimi i Orientuar në Objekte në C++; 2008, ISBN 9989-‐866-‐25-‐2.

2. Bjarne Stroustrup, The C+ + Programming Language, Third Edition, AT&T 1997, ISBN 0201889544

3. Dale, Nell B.; Weems, Chip.; Headington, Mark R, Programming and Problem Solving With C++ 3Rd Ed., Jones & Bartlett Publishers, Inc. 2002, ISBN13 9780763721039.

4. Dirk Henkemans, Mark Lee , C++ Programming for the Absolute Beginner, Premier Press 2001, ISBN:1931841438

5. D.S. MALIK. C++ PROGRAMMING: PROGRAM DESIGN INCLUDING DATA STRUCTURES, 2011, ISBN-‐13: 978-‐0-‐538-‐79809-‐2

6. Edward Scheinerman, C++ for Mathematicians (An Introduction for Students and Professionals), Chapman & Hall/CRC 2006, International Standard Book Number-‐13: 978-‐0978-‐1-‐58488-‐584-‐9.

7. Introduction), John Wiley & Sons Ltd 2006, ISBN-‐13: 978-‐0-‐470-‐01468-‐4.

8. Michael Goodrich, Roberto Tamassia, David Mount, Data Structures & Algorithms, Second Edition, John Wiley & Sons, Inc 2011, ISBN-‐13 978-‐0-‐470-‐38327-‐8

9. Ivor Horton's, Beginning Visual C++ 2012, John Wiley & Sons, Inc 2012, ISBN: 978-‐1-‐118-‐36808-‐4

10. Joyce Farrell, Object-‐Oriented Programming Using C++, Fourth Edition, Course Technology 2009, ISBN-‐13: 978-‐1-‐4239-‐0257-‐7

11. Paul Deitel, Harvey Dietel, C++ How to Program, 8/E, ISBN-‐10: 0-‐13-‐266236-‐1

12. P.S. Deshpande and O.G. Kakde, C & Data Structures, Dreamtech

Press 2003, ISBN:1584503386

13. Robert Lafore, Object-‐Oriented Programming in C++, Fourth Edition, Sams 2002, International Standard Book Number: 0-‐672-‐32308-‐7

www.e-Libraria.com


209

14. Stephen Prata, C++ Primer Plus, Sixth edition, Addision -‐Wesley 2012, ISBN-‐13: 978-‐0-‐321-‐77640-‐2

15. Stephen Randy Davis, C++ For Dummies 5th Edition, Wiley Publishing, Inc. 2004, ISBN: 0-‐7645-‐6852-‐3

16. Trevor Misfeldt, Gregory Bumgardner, Andrew Gray; The Elements of C++Style, Cambridge university press 2004, isbn-‐13 978-‐0-‐521-‐89308-‐4

17. Tony Gaddis, Judy Walters, Godfrey Muganda; Starting Out with C++ Early Objects, Seventh Edition, Addison-‐Wesley 2010, ISBN 10: 0-‐13-‐607774-‐9.

18. Walter Savitch, Absolute C++, Fifth Edition, Pearson 2013, ISBN-‐10: 0-‐13-‐283071-‐X

19. Walter Savitch, Problem Solving with C++, Seventh Edition, 2009, ISBN 13: 9780321531346

20. Vehbi Neziri, Përmbledhje detyrash në C++ (edicioni 1), Prishtinë 2012;

www.e-Libraria.com


210

www.e-Libraria.com

Education

C++ permbledhje detyrash-v-neziri-r-dervishi-fiek